github-router 0.3.249 → 0.3.255

package/dist/server-setup-DcO9qvN3.js

@@ -0,0 +1,4776 @@
+import { A as ADVISOR_INTERNAL_TOOL_NAME, At as UPSTREAM_FETCH_TIMEOUT_MS, B as relayAnthropicStream, F as buildAnthropicErrorEvent, H as handleMcpPost, I as buildOpenAIErrorEvent, L as isControllerClosedError, M as buildAdvisorStream, Mt as generateRandomPort, N as injectAdvisorTool, P as isAdvisorRequested, Pt as withInstallLock, R as logStreamError, Tt as toolbeltPathOverride, U as agentToolsEnabled, V as handleMcpDelete, at as createMessages, ct as resolveMcpToolTimeoutMs, dt as createChatCompletions, ft as MAX_RESPONSE_BODY_BYTES, it as countTokens, j as ADVISOR_TOOL_INSTRUCTIONS, jt as UPSTREAM_INACTIVITY_TIMEOUT_MS, k as searchWeb, lt as pickEndpoint, mt as parseJsonOrDiagnose, ot as getTokenCount, pt as readResponseBodyCapped, r as assertMcpToolSurfaceConsistent, rt as shimDefaultsToXhigh, st as assembleResponsesPayload, ut as createResponses, w as toolbeltEnabled, z as readIteratorWithTimeout } from "./peer-mcp-personas-BDet588n.js";
+import { t as getPackageVersion } from "./version-_Q1WpsQp.js";
+import { i as ensurePaths, t as PATHS } from "./paths-C1cLZ7Ga.js";
+import { C as copilotHeaders, O as state, S as copilotBaseUrl, a as cacheCopilotVersion, c as filterBetaHeader, d as resolveModel, f as sleep, g as fetchWithTransientRetry, i as tryRefreshAndRetry, l as isNullish, n as setupGitHubAgentToken, o as cacheModels, r as setupGitHubToken, s as cacheVSCodeVersion, t as setupCopilotToken, v as HTTPError, y as forwardError } from "./token-R2ocFC3M.js";
+import { t as getCopilotUsage } from "./get-copilot-usage-DD1N0Xlh.js";
+import { a as resolveExecutable, n as killManagedTree, o as runCommandCapture, r as parseBoolEnv, s as runCommandVoid } from "./exec-DTO2oin0.js";
+import consola from "consola";
+import * as fs$2 from "node:fs";
+import { existsSync } from "node:fs";
+import * as nodePath from "node:path";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+import fs$1 from "node:fs/promises";
+import os from "node:os";
+import process$1 from "node:process";
+import { spawn } from "node:child_process";
+import { Agent, ProxyAgent, setGlobalDispatcher } from "undici";
+import { serve } from "srvx";
+import { createBodyTooLargeError, limitRequestBody } from "srvx/body-limit";
+import { getProxyForUrl } from "proxy-from-env";
+import { Hono } from "hono";
+import { cors } from "hono/cors";
+//#region src/lib/claude-version-check.ts
+const NPM_PACKAGE$1 = "@anthropic-ai/claude-code";
+const THROTTLE_HOURS$1 = 1;
+const NPM_VIEW_TIMEOUT_MS$1 = 5e3;
+const CLAUDE_VERSION_TIMEOUT_MS = 3e3;
+const NPM_INSTALL_TIMEOUT_MS = 12e4;
+/** Path to the throttle cache. Created on demand. */
+function cacheFilePath$1() {
+	return path.join(os.homedir(), ".local", "share", "github-router", "last-update-check");
+}
+/**
+* Read the throttle cache. Returns null on missing/corrupt file —
+* triggers a fresh check.
+*/
+async function readCache$1() {
+	try {
+		const raw = await fs$1.readFile(cacheFilePath$1(), "utf8");
+		const parsed = JSON.parse(raw);
+		if (typeof parsed.checkedAt !== "string" || parsed.installedVersion !== null && typeof parsed.installedVersion !== "string" || parsed.latestVersion !== null && typeof parsed.latestVersion !== "string") return null;
+		return parsed;
+	} catch {
+		return null;
+	}
+}
+async function writeCache$1(cache) {
+	try {
+		await fs$1.mkdir(path.dirname(cacheFilePath$1()), { recursive: true });
+		await fs$1.writeFile(cacheFilePath$1(), JSON.stringify(cache), { mode: 384 });
+	} catch (err) {
+		consola.debug("Failed to write claude version-check cache:", err);
+	}
+}
+/** Check if it's been more than THROTTLE_HOURS since the last check. */
+function shouldCheckNow$1(cache) {
+	if (!cache) return true;
+	const lastCheck = new Date(cache.checkedAt).getTime();
+	if (Number.isNaN(lastCheck)) return true;
+	return (Date.now() - lastCheck) / 1e3 / 3600 >= THROTTLE_HOURS$1;
+}
+/**
+* Read the installed `claude` version. Returns null if claude is not
+* on PATH or the version probe fails (e.g. older versions that don't
+* support `--version` cleanly).
+*
+* Windows-safe: `claude` is a `.cmd` shim that `execFile` cannot launch
+* directly. We resolve it to an absolute path (excluding the cwd, so a
+* planted `claude.cmd` in an untrusted repo can't run) and invoke it
+* through the shared exec helper.
+*/
+async function getInstalledVersion() {
+	const claudePath = resolveExecutable("claude");
+	if (!claudePath) return null;
+	try {
+		const { stdout, code } = await runCommandCapture([claudePath, "--version"], { timeoutMs: CLAUDE_VERSION_TIMEOUT_MS });
+		if (code !== 0) return null;
+		const match = stdout.match(/(\d+\.\d+\.\d+)/);
+		return match ? match[1] : null;
+	} catch {
+		return null;
+	}
+}
+/**
+* Fetch the latest version of @anthropic-ai/claude-code from the npm
+* registry. Returns null on network failure / npm unavailable.
+*
+* Windows-safe: `npm` is `npm.cmd`; resolved to an absolute path
+* (excluding cwd) before invocation.
+*/
+async function getLatestVersion$1() {
+	const npmPath = resolveExecutable("npm");
+	if (!npmPath) return null;
+	try {
+		const { stdout, code } = await runCommandCapture([
+			npmPath,
+			"view",
+			NPM_PACKAGE$1,
+			"version",
+			"--silent"
+		], { timeoutMs: NPM_VIEW_TIMEOUT_MS$1 });
+		if (code !== 0) return null;
+		const v = stdout.trim();
+		return /^\d+\.\d+\.\d+/.test(v) ? v : null;
+	} catch {
+		return null;
+	}
+}
+/**
+* Compare two semver-shaped strings (only the leading X.Y.Z, no
+* pre-release / metadata handling — sufficient for npm-published
+* stable releases). Returns true if `latest` is strictly higher than
+* `installed`.
+*/
+function isNewer(installed, latest) {
+	if (!installed || !latest) return false;
+	const a = installed.split(".").map((n) => parseInt(n, 10));
+	const b = latest.split(".").map((n) => parseInt(n, 10));
+	for (let i = 0; i < 3; i++) {
+		const av = a[i] ?? 0;
+		const bv = b[i] ?? 0;
+		if (av < bv) return true;
+		if (av > bv) return false;
+	}
+	return false;
+}
+/**
+* Run a version check (subject to throttle). Side-effect: updates the
+* throttle cache. Returns the comparison result.
+*/
+async function checkClaudeVersion(opts = {}) {
+	if (opts.noCheck) return {
+		installed: false,
+		installedVersion: null,
+		latestVersion: null,
+		needsUpdate: false,
+		skipped: true,
+		skipReason: "disabled"
+	};
+	const cache = await readCache$1();
+	if (!opts.force && !shouldCheckNow$1(cache)) return {
+		installed: cache?.installedVersion !== null,
+		installedVersion: cache?.installedVersion ?? null,
+		latestVersion: cache?.latestVersion ?? null,
+		needsUpdate: isNewer(cache?.installedVersion ?? null, cache?.latestVersion ?? null),
+		skipped: true,
+		skipReason: "throttled"
+	};
+	const installedVersion = await getInstalledVersion();
+	if (installedVersion === null) return {
+		installed: false,
+		installedVersion: null,
+		latestVersion: null,
+		needsUpdate: false,
+		skipped: true,
+		skipReason: "no-claude"
+	};
+	const latestVersion = await getLatestVersion$1();
+	await writeCache$1({
+		checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		installedVersion,
+		latestVersion
+	});
+	if (latestVersion === null) return {
+		installed: true,
+		installedVersion,
+		latestVersion: null,
+		needsUpdate: false,
+		skipped: true,
+		skipReason: "no-npm"
+	};
+	return {
+		installed: true,
+		installedVersion,
+		latestVersion,
+		needsUpdate: isNewer(installedVersion, latestVersion),
+		skipped: false
+	};
+}
+/**
+* Heuristic: did `claude update` fail because the subcommand does not
+* exist (a build predating `claude update`), as opposed to a transient
+* update error? We only npm-fall-back on this specific signal — falling
+* back on any failure would install a conflicting npm copy on
+* native-installer machines.
+*
+* Matches the usage/Commander-style "unknown command" messages CLIs emit
+* for an unrecognized subcommand. Deliberately narrow.
+*/
+function looksLikeUnknownUpdateCommand(output) {
+	return /unknown command|unknown subcommand|unrecognized (sub)?command|invalid command|command not found|is not a (known|valid) command/i.test(output);
+}
+async function updateClaude(latestVersion, deps = {}) {
+	const _resolve = deps.resolveExecutable ?? resolveExecutable;
+	const _capture = deps.runCommandCapture ?? runCommandCapture;
+	const _void = deps.runCommandVoid ?? runCommandVoid;
+	const _lock = deps.withInstallLock ?? withInstallLock;
+	const claudePath = _resolve("claude");
+	if (!claudePath) throw new Error("claude not found on PATH");
+	if (!await _lock("claude-update.lock", async () => {
+		consola.info(`Updating Claude Code to ${latestVersion} via \`claude update\`...`);
+		const { code, stdout, stderr } = await _capture([claudePath, "update"], { timeoutMs: NPM_INSTALL_TIMEOUT_MS });
+		const combined = `${stdout}${stderr}`;
+		const trimmed = combined.trim();
+		if (trimmed) process.stdout.write(trimmed.endsWith("\n") ? trimmed : `${trimmed}\n`);
+		if (code === 0) {
+			consola.success(`Claude Code updated to ${latestVersion}`);
+			return;
+		}
+		if (!looksLikeUnknownUpdateCommand(combined)) throw new Error(`\`claude update\` exited with code ${code}`);
+		const npmPath = _resolve("npm");
+		if (!npmPath) throw new Error(`this Claude Code build predates \`claude update\` and npm is not on PATH; update manually: npm install -g ${NPM_PACKAGE$1}@latest`);
+		consola.warn(`This Claude Code build predates \`claude update\`; falling back to \`npm install -g ${NPM_PACKAGE$1}@latest\`.`);
+		const { code: npmCode, stderr: npmStderr } = await _void([
+			npmPath,
+			"install",
+			"-g",
+			`${NPM_PACKAGE$1}@latest`,
+			"--silent"
+		], { timeoutMs: NPM_INSTALL_TIMEOUT_MS });
+		if (npmCode !== 0) throw new Error(`npm install failed: ${npmStderr.trim() || `exit ${npmCode}`}`);
+		consola.success(`${NPM_PACKAGE$1} updated to ${latestVersion}`);
+	})) consola.debug("Claude Code update already in progress in another process; skipping.");
+}
+//#endregion
+//#region src/lib/self-update.ts
+/**
+* Self-update for the `github-router` proxy.
+*
+* The proxy is a *running* process, so updating its own global install
+* in place (`npm install -g github-router@latest`) deletes/overwrites
+* files the OS holds open — on Windows that fails deterministically
+* (EPERM/EBUSY) and can corrupt the install. So we never install in
+* place: when a newer version exists we spawn a **detached updater that
+* waits for this process to exit**, then installs. The update takes
+* effect on the next launch — no re-exec, no restart prompt.
+*
+* Best-effort throughout: every failure is swallowed to debug/warn and
+* never blocks startup. The startup probe is bounded and the install is
+* off the critical path (detached), so even a blackholed network can't
+* delay the proxy from serving.
+*/
+const NPM_PACKAGE = "github-router";
+const THROTTLE_HOURS = 1;
+const NPM_VIEW_TIMEOUT_MS = 5e3;
+function cacheFilePath() {
+	return path.join(os.homedir(), ".local", "share", "github-router", "last-self-update-check");
+}
+async function readCache() {
+	try {
+		const parsed = JSON.parse(await fs$1.readFile(cacheFilePath(), "utf8"));
+		if (typeof parsed.checkedAt !== "string") return null;
+		return parsed;
+	} catch {
+		return null;
+	}
+}
+async function writeCache(cache) {
+	try {
+		await fs$1.mkdir(path.dirname(cacheFilePath()), { recursive: true });
+		await fs$1.writeFile(cacheFilePath(), JSON.stringify(cache), { mode: 384 });
+	} catch (err) {
+		consola.debug("Failed to write self-update cache:", err);
+	}
+}
+function shouldCheckNow(cache) {
+	if (!cache) return true;
+	const last = new Date(cache.checkedAt).getTime();
+	if (Number.isNaN(last)) return true;
+	return (Date.now() - last) / 1e3 / 3600 >= THROTTLE_HOURS;
+}
+async function getLatestVersion(npmPath) {
+	try {
+		const { stdout, code } = await runCommandCapture([
+			npmPath,
+			"view",
+			NPM_PACKAGE,
+			"version",
+			"--silent"
+		], { timeoutMs: NPM_VIEW_TIMEOUT_MS });
+		if (code !== 0) return null;
+		const v = stdout.trim();
+		return /^\d+\.\d+\.\d+/.test(v) ? v : null;
+	} catch {
+		return null;
+	}
+}
+/**
+* Spawn a detached process that waits for THIS proxy (pid) to exit,
+* then runs `npm install -g github-router@latest`. Fully detached and
+* unref'd so it outlives the proxy; output discarded.
+*
+* The waiter is a tiny inline Node script (Node is guaranteed present —
+* the proxy runs on it) that polls `process.kill(pid, 0)` until the
+* parent is gone, then execs npm. This avoids the Windows file-lock by
+* never touching the global install while the proxy holds it open.
+*/
+function spawnDetachedUpdater(npmPath) {
+	const waiter = `
+    const pid = ${process.pid};
+    const { spawn } = require("node:child_process");
+    function alive() { try { process.kill(pid, 0); return true } catch { return false } }
+    const timer = setInterval(() => {
+      if (alive()) return;
+      clearInterval(timer);
+      const args = ["install", "-g", ${JSON.stringify(`${NPM_PACKAGE}@latest`)}, "--silent"];
+      const isWin = process.platform === "win32";
+      const child = spawn(${JSON.stringify(npmPath)}, args, {
+        stdio: "ignore", windowsHide: true, shell: isWin, detached: !isWin,
+      });
+      child.on("error", () => process.exit(0));
+      child.on("exit", () => process.exit(0));
+      // Safety: never hang forever.
+      setTimeout(() => process.exit(0), 180000).unref();
+    }, 500);
+    // Safety cap on the wait itself (e.g. extremely long sessions still
+    // eventually give up rather than leak the waiter).
+    setTimeout(() => { clearInterval(timer); process.exit(0); }, 24 * 3600 * 1000).unref();
+  `.trim();
+	spawn(process.execPath, ["-e", waiter], {
+		detached: true,
+		stdio: "ignore",
+		windowsHide: true
+	}).unref();
+}
+/**
+* Probe npm for a newer `github-router` and, if found, queue a detached
+* post-exit update. Returns quickly; never throws. Call AFTER the
+* server is listening so the bounded probe can't delay binding.
+*/
+async function runSelfUpdate(opts) {
+	if (!opts.selfUpdate) return;
+	if (parseBoolEnv(process.env.GH_ROUTER_NO_SELF_UPDATE) === true) return;
+	try {
+		const cache = await readCache();
+		if (!opts.force && !shouldCheckNow(cache)) return;
+		const installed = getPackageVersion();
+		if (installed === "unknown") return;
+		const npmPath = resolveExecutable("npm");
+		if (!npmPath) return;
+		const latest = await getLatestVersion(npmPath);
+		await writeCache({
+			checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			installedVersion: installed,
+			latestVersion: latest
+		});
+		if (!latest || !isNewer(installed, latest)) return;
+		if (await withInstallLock("self-update.lock", async () => {
+			spawnDetachedUpdater(npmPath);
+		})) consola.info(`github-router ${installed} → ${latest} update queued; it takes effect on the next launch.`);
+	} catch (err) {
+		consola.debug("Self-update check failed:", err);
+	}
+}
+//#endregion
+//#region src/lib/model-validation.ts
+const ENDPOINT_ALIASES = {
+	"/chat/completions": "/chat/completions",
+	"/v1/chat/completions": "/chat/completions",
+	"/responses": "/responses",
+	"/v1/responses": "/responses",
+	"/v1/messages": "/v1/messages"
+};
+/**
+* Check whether a model supports the given endpoint, based on cached
+* `supported_endpoints` metadata from the Copilot `/models` response.
+*
+* Returns `true` (allow) when:
+* - the model is not found in the cache (don't block unknown models)
+* - the model has no `supported_endpoints` field (backward-compat)
+* - the endpoint is listed in `supported_endpoints`
+*/
+function modelSupportsEndpoint(modelId, path) {
+	const endpoint = ENDPOINT_ALIASES[path] ?? path;
+	const model = state.models?.data.find((m) => m.id === modelId);
+	if (!model) return true;
+	const supported = model.supported_endpoints;
+	if (!supported || supported.length === 0) return true;
+	return supported.includes(endpoint);
+}
+/**
+* Log an error when a model is used on an endpoint it doesn't support.
+* Returns `true` if a mismatch was detected (for testing).
+*/
+function logEndpointMismatch(modelId, path) {
+	if (modelSupportsEndpoint(modelId, path)) return false;
+	const supported = (state.models?.data.find((m) => m.id === modelId))?.supported_endpoints ?? [];
+	consola.error(`Model "${modelId}" does not support ${path}. Supported endpoints: ${supported.join(", ")}`);
+	return true;
+}
+/**
+* Return model IDs that support the given endpoint.
+*/
+function listModelsForEndpoint(path) {
+	const endpoint = ENDPOINT_ALIASES[path] ?? path;
+	return (state.models?.data ?? []).filter((m) => {
+		const supported = m.supported_endpoints;
+		if (!supported || supported.length === 0) return true;
+		return supported.includes(endpoint);
+	}).map((m) => m.id);
+}
+//#endregion
+//#region src/lib/keep-awake/flags.ts
+/**
+* Env-flag parsing for the Windows keep-awake feature. Pure +
+* unit-testable (no spawn, no platform branch — the platform gate lives
+* in `keepAwakeEnabled()`).
+*/
+/**
+* True unless the operator opted out via `GH_ROUTER_DISABLE_KEEP_AWAKE`.
+* Keep-awake is ON BY DEFAULT (the win32-only platform gate is applied
+* separately in `keepAwakeEnabled()`). Mirrors the colbert opt-out idiom
+* (`parseBoolEnv(...) !== true`) so on/off semantics don't drift.
+*/
+function keepAwakeOptedIn() {
+	return parseBoolEnv(process$1.env.GH_ROUTER_DISABLE_KEEP_AWAKE) !== true;
+}
+/**
+* True iff the operator opted IN to keeping the DISPLAY awake too via
+* `GH_ROUTER_KEEP_DISPLAY_ON=1`. Default OFF: the machine stays awake
+* (`ES_SYSTEM_REQUIRED`) but the panel is allowed to sleep.
+*/
+function keepDisplayOn() {
+	return parseBoolEnv(process$1.env.GH_ROUTER_KEEP_DISPLAY_ON) === true;
+}
+//#endregion
+//#region src/lib/keep-awake/helper.ts
+/**
+* The persistent PowerShell helper that holds a Win32
+* `SetThreadExecutionState` assertion for the proxy's lifetime.
+*
+* `SetThreadExecutionState` is THREAD-scoped: a one-shot process that
+* sets it and exits releases the assertion immediately. So a long-lived
+* helper holds it on its own main thread and blocks on stdin; when the
+* proxy dies (clean exit, signal, SIGKILL/taskkill, OOM) the stdin pipe
+* closes, the helper hits EOF, clears the assertion, and exits — and
+* Windows releases the thread's assertion on process death regardless.
+* The helper therefore cannot outlive the proxy, so no orphan sweep is
+* needed (unlike colbert/worktrees, which leave on-disk artifacts).
+*
+* Best-effort: every failure path (no powershell, Constrained Language
+* Mode blocking `Add-Type`, spawn error) degrades to a clean no-op. We
+* NEVER attempt to install, enable, or bypass language-mode/WDAC policy.
+*/
+const ES_CONTINUOUS = 2147483648;
+const ES_DISPLAY_REQUIRED = 2;
+/** Default time to wait for the helper's `OK` readiness line.
+*
+*  Sized for the slowest LEGITIMATE path, not the typical one. The script's
+*  `Add-Type -MemberDefinition` compiles a C# P/Invoke shim through csc.exe on
+*  first use, and that compile happens BEFORE the `OK` line is printed. On a
+*  cold machine (a fresh CI runner, a laptop that just booted, a host with
+*  aggressive on-access AV scanning) it routinely takes well over five seconds.
+*
+*  CORRECTION to the rationale this constant shipped with. An earlier version of
+*  this comment (and the commit that raised the value) claimed a short timeout
+*  made the user "silently lose keep-awake". That is wrong, and a cross-lab
+*  reviewer caught it: `startKeepAwake` does nothing with `ready` but
+*  `consola.debug` it (`index.ts:128`). The handle is retained and the child
+*  keeps running, so the assertion is still set, just later than we observed it.
+*
+*  The real cost of a tight value is therefore a LYING LOG, not a lost feature:
+*  we report "inactive" for a helper that is about to work. That is still worth
+*  fixing, because a false negative in a diagnostic is how you lose an afternoon
+*  chasing a working feature. Waiting longer costs nothing either way, since the
+*  readiness promise is awaited in the background and never blocks launch. */
+const DEFAULT_READY_TIMEOUT_MS = 2e4;
+/**
+* The execution-state flags to assert. Always `ES_CONTINUOUS |
+* ES_SYSTEM_REQUIRED` (machine stays awake); adds `ES_DISPLAY_REQUIRED`
+* (screen stays on) when `displayRequired`. `>>> 0` forces an unsigned
+* 32-bit value so the hex literal handed to PowerShell is positive.
+*/
+function executionStateFlags(displayRequired) {
+	let flags = -2147483647;
+	if (displayRequired) flags |= ES_DISPLAY_REQUIRED;
+	return flags >>> 0;
+}
+/** Format a uint32 as a PowerShell `[uint32]<decimal>` literal.
+*
+* Decimal, NOT hex: in Windows PowerShell a hex literal like `0x80000001`
+* parses as a *negative* Int32 (`-2147483647`) and fails to convert to
+* the `uint` parameter ("Value was either too large or too small for a
+* UInt32"). A decimal literal over Int32.MaxValue auto-promotes to a
+* positive Int64, and the explicit `[uint32]` cast then fits. Verified
+* against a real win32 host before shipping. */
+function psUint32(n) {
+	return `[uint32]${n >>> 0}`;
+}
+/**
+* Build the PowerShell script the persistent helper runs. PURE — the
+* flag value is our own constant templated as a numeric literal, so
+* there is no injection surface. The script:
+*   1. P/Invokes `SetThreadExecutionState` with the requested flags.
+*   2. Prints `OK` once the assertion succeeds (the readiness signal;
+*      no `OK` => `Add-Type` was CLM-blocked or the call returned 0).
+*   3. Blocks reading stdin so it self-exits on parent death (pipe EOF).
+*   4. Clears the assertion (`ES_CONTINUOUS` only) on the way out.
+*
+* The C# member-definition is a PowerShell SINGLE-quoted string so its
+* embedded `"kernel32.dll"` double-quotes need no escaping.
+*/
+function buildKeepAwakeScript(displayRequired) {
+	const assert = psUint32(executionStateFlags(displayRequired));
+	const clear = psUint32(ES_CONTINUOUS);
+	return [
+		`Add-Type -Name P -Namespace W -MemberDefinition '[System.Runtime.InteropServices.DllImport("kernel32.dll")] public static extern uint SetThreadExecutionState(uint e);'`,
+		`if ([W.P]::SetThreadExecutionState(${assert}) -ne 0) { [Console]::Out.WriteLine('OK'); [Console]::Out.Flush() }`,
+		`while ($null -ne [Console]::In.ReadLine()) {}`,
+		`[void][W.P]::SetThreadExecutionState(${clear})`
+	].join("\n");
+}
+/** The argv passed to powershell.exe (excluding the executable itself). */
+function buildHelperArgs(displayRequired) {
+	return [
+		"-NoProfile",
+		"-NonInteractive",
+		"-Command",
+		buildKeepAwakeScript(displayRequired)
+	];
+}
+/**
+* Spawn the persistent helper. Returns a null handle (and `ready` →
+* `false`) when powershell.exe can't be resolved or spawn throws — both
+* clean no-op degradations. The helper's stdout is piped only to detect
+* the `OK` readiness line; stderr is ignored.
+*/
+function spawnHelper(opts) {
+	const ps = resolveExecutable("powershell.exe");
+	if (!ps) return {
+		handle: null,
+		ready: Promise.resolve(false)
+	};
+	let child;
+	try {
+		child = spawn(ps, buildHelperArgs(opts.displayRequired), {
+			stdio: [
+				"pipe",
+				"pipe",
+				"ignore"
+			],
+			windowsHide: true,
+			shell: false
+		});
+	} catch {
+		return {
+			handle: null,
+			ready: Promise.resolve(false)
+		};
+	}
+	child.on("error", () => {});
+	return {
+		handle: { child },
+		ready: new Promise((resolve) => {
+			let settled = false;
+			let buf = "";
+			const done = (v) => {
+				if (settled) return;
+				settled = true;
+				clearTimeout(timer);
+				resolve(v);
+			};
+			const timer = setTimeout(() => done(false), opts.readyTimeoutMs ?? DEFAULT_READY_TIMEOUT_MS);
+			timer.unref?.();
+			child.stdout?.on("data", (c) => {
+				if (settled || buf.length > 256) return;
+				buf += c.toString("utf8");
+				if (buf.includes("OK")) done(true);
+			});
+			child.stdout?.on("error", () => {});
+			child.once("exit", () => done(false));
+			child.once("error", () => done(false));
+		})
+	};
+}
+/**
+* Release the assertion: close the helper's stdin (→ pipe EOF → the
+* helper clears `ES_*` and exits) then `taskkill /T /F` as a
+* belt-and-suspenders reap. Windows also releases the assertion on the
+* helper's process death regardless. Best-effort; never throws.
+*/
+function killHelper(handle) {
+	const { child } = handle;
+	try {
+		child.stdin?.end();
+	} catch {}
+	try {
+		killManagedTree(child);
+	} catch {}
+}
+//#endregion
+//#region src/lib/keep-awake/index.ts
+/**
+* Windows keep-awake — public entry points.
+*
+* `startKeepAwake()` is the fire-and-forget call the `start` / `claude` /
+* `codex` launchers invoke after `setupAndServe` (alongside
+* `provisionAndIndexColbert()` / `runSelfUpdate()`). On Windows, by
+* default, it spawns a persistent PowerShell helper that holds a
+* `SetThreadExecutionState(ES_CONTINUOUS | ES_SYSTEM_REQUIRED)`
+* assertion so the machine doesn't idle-sleep mid-session, and registers
+* SIGINT/SIGTERM/exit handlers to release it.
+*
+* Best-effort and model-agnostic: non-win32 is a total no-op; any
+* failure (no powershell, Constrained Language Mode blocking `Add-Type`)
+* degrades to a clean debug-logged no-op. We NEVER install, enable, or
+* bypass language-mode/WDAC policy, and never block or crash launch.
+*
+* Crash safety: the helper blocks on stdin, so if the proxy is hard-
+* killed the pipe closes, the helper hits EOF and exits, and Windows
+* releases the assertion on process death — no orphan is possible, so no
+* boot-time sweep is needed.
+*/
+/**
+* True iff keep-awake should run THIS launch: win32 AND not opted out.
+* Non-win32 short-circuits before anything else (no spawn, no flags read
+* beyond the opt-out, no handler registration). `platform` is injectable
+* for tests; production callers use the default `process.platform`.
+*/
+function keepAwakeEnabled(platform = process$1.platform) {
+	return platform === "win32" && keepAwakeOptedIn();
+}
+let _handle = null;
+let _started = false;
+/** Synchronously release the assertion + drop the handle. Idempotent.
+* Also clears the `_started` latch so a transient failure never
+* permanently disables a later start. */
+function releaseSync() {
+	const h = _handle;
+	_handle = null;
+	_started = false;
+	if (h) try {
+		killHelper(h);
+	} catch {}
+}
+let _registered = false;
+let _exitHandler = null;
+let _sigintHandler = null;
+let _sigtermHandler = null;
+/**
+* Wire SIGINT/SIGTERM/exit handlers that release the assertion.
+* Idempotent. The signal handlers re-raise after releasing (remove self
+* + `process.kill(self)`) so Node's default terminate-on-signal is
+* restored — otherwise merely attaching a listener cancels the default
+* and Ctrl-C would clean but not exit. This is load-bearing for the
+* `start` subcommand, which has no `launchChild`/`onShutdown` of its own.
+*/
+function registerExitHandlers() {
+	if (_registered) return;
+	_registered = true;
+	_exitHandler = () => releaseSync();
+	_sigintHandler = () => {
+		releaseSync();
+		if (_sigintHandler) process$1.off("SIGINT", _sigintHandler);
+		process$1.kill(process$1.pid, "SIGINT");
+	};
+	_sigtermHandler = () => {
+		releaseSync();
+		if (_sigtermHandler) process$1.off("SIGTERM", _sigtermHandler);
+		process$1.kill(process$1.pid, "SIGTERM");
+	};
+	process$1.on("SIGINT", _sigintHandler);
+	process$1.on("SIGTERM", _sigtermHandler);
+	process$1.on("exit", _exitHandler);
+}
+/**
+* Start keeping the machine awake. Synchronous, fire-and-forget,
+* idempotent within a run. No-op off win32 or when opted out. Never
+* throws.
+*/
+function startKeepAwake() {
+	if (!keepAwakeEnabled()) return;
+	if (_started) return;
+	_started = true;
+	try {
+		const { handle, ready } = spawnHelper({ displayRequired: keepDisplayOn() });
+		if (!handle) {
+			_started = false;
+			consola.debug("keep-awake: inactive (powershell.exe not resolvable)");
+			return;
+		}
+		_handle = handle;
+		handle.child.once("exit", () => {
+			if (_handle === handle) _handle = null;
+		});
+		registerExitHandlers();
+		ready.then((ok) => {
+			consola.debug(ok ? "keep-awake: holding SetThreadExecutionState assertion (system sleep prevented)" : "keep-awake: inactive (helper did not confirm — Constrained Language Mode or PowerShell unavailable)");
+		});
+	} catch (err) {
+		_started = false;
+		_handle = null;
+		consola.debug("keep-awake: failed to start (continuing):", err);
+	}
+}
+/**
+* Release the assertion / reap the helper. Idempotent; safe to `await`
+* from a subcommand's `onShutdown` chain. Never throws.
+*/
+async function stopKeepAwake() {
+	releaseSync();
+}
+//#endregion
+//#region src/lib/first-mate/scheduler/autospawn.ts
+/**
+* Opt-in auto-spawn of the first-mate scheduler daemon as a SEPARATE process
+* (a hung tick must not starve the proxy event loop).
+*
+* DEFAULT OFF — gated by GH_ROUTER_FM_DAEMON === "1" (explicit opt-in). The
+* durable [fm-heartbeat] cron is the DEFAULT driver and the proven path; the
+* daemon is experimental and NOT yet safe as the default because two hardening
+* items remain (a verifier-stall wall-clock escalation, and an atomic-claim
+* lock in durable-store) — flip the default only once those land.
+*
+* Requirements + honest boundaries:
+*  - The daemon entry is `scripts/first-mate-daemon.ts` (a TS source file run via
+*    `bun`); it is NOT in the published dist tarball, so auto-spawn only fires
+*    from a source checkout with `bun` available. If the script is absent we
+*    no-op (never a false "spawned" log).
+*  - Spawn failures NEVER crash the proxy: an async ENOENT (`bun` not on PATH)
+*    arrives as an `'error'` EVENT, not a sync throw, so we attach an `'error'`
+*    listener (without it the emitter re-throws → uncaughtException → exit(1)).
+*  - The returned handle MUST be killed by the caller on shutdown (no `detached`);
+*    an orphaned drive-primary daemon would keep merging PRs after the proxy is
+*    gone. The parent ALSO holds the child's stdin write end (`stdio[0]==="pipe"`)
+*    so it can EOF the child for a GRACEFUL stop (lease + pidfile released
+*    immediately, not by expiry) — the cross-platform teardown trigger, since an
+*    external SIGTERM on Windows is a hard kill the child can't observe. `kill()`
+*    stays the hard backstop so a wedged child is never orphaned (see
+*    `wireDaemonTeardown`).
+*  - It owns the deterministic drive loop only; live judgments still wake the
+*    lead via the heartbeat (no server->lead push).
+*/
+function shouldAutoSpawnDaemon(env, agentsEnabled) {
+	if (!agentsEnabled) return false;
+	return env.GH_ROUTER_FM_DAEMON === "1";
+}
+/**
+* The real (non-injected) spawner: node:child_process (not the Bun runtime's spawn) so the
+* bundled dist/main.js stays node-loadable. No `detached` — the caller kills
+* this on shutdown. stdin is "pipe" (parent holds the write end for a graceful
+* EOF stop); stdout/stderr stay "ignore".
+*/
+function nodeDaemonSpawn(cmd, spawnOpts, spawnImpl = spawn) {
+	const proc = spawnImpl(cmd[0], cmd.slice(1), {
+		env: spawnOpts.env,
+		stdio: spawnOpts.stdio
+	});
+	proc.on("error", (err) => consola.debug("first-mate daemon spawn error (ignored):", err));
+	return {
+		pid: proc.pid,
+		kill: () => void proc.kill("SIGKILL"),
+		endStdin: () => {
+			try {
+				proc.stdin?.end();
+			} catch {}
+		}
+	};
+}
+/**
+* Spawn the daemon child if the opt-in gate passes AND the daemon script is
+* present; else return undefined. Never throws, and never lets an async spawn
+* error crash bootstrap.
+*/
+function maybeSpawnDaemon(opts) {
+	const env = opts.env ?? process.env;
+	if (!shouldAutoSpawnDaemon(env, opts.agentsEnabled)) return void 0;
+	const script = path.join(opts.repoRoot ?? process.cwd(), "scripts/first-mate-daemon.ts");
+	if (opts.spawn === void 0 && !existsSync(script)) {
+		consola.debug(`first-mate daemon entry not found (${script}); auto-spawn skipped.`);
+		return;
+	}
+	try {
+		const child = (opts.spawn ?? ((cmd, spawnOpts) => nodeDaemonSpawn(cmd, spawnOpts)))(["bun", script], {
+			env,
+			stdio: [
+				"pipe",
+				"ignore",
+				"ignore"
+			]
+		});
+		return {
+			pid: child.pid,
+			kill: child.kill,
+			endStdin: child.endStdin ?? (() => {})
+		};
+	} catch {
+		return;
+	}
+}
+/**
+* Wire the proxy's teardown to shut the daemon child down GRACEFULLY, then hard
+* kill as a backstop. Ordering (per teardown path):
+*  1. `endStdin()` — EOF the child so it releases its lease/pidfile cleanly (the
+*     cross-platform trigger; on Windows an external SIGTERM would never run the
+*     child's handler, so this EOF is the ONLY graceful path there).
+*  2. `kill()` — hard backstop so a wedged child is never orphaned (a prior
+*     review blocker: an orphaned drive-primary daemon keeps merging PRs).
+*
+* On SIGINT/SIGTERM the kill is deferred by a short, NON-BLOCKING, unref'd grace
+* window (proxy exit is never delayed for it). On `'exit'` — where timers cannot
+* run — we EOF then kill synchronously as a last resort. All steps are
+* once-guarded and non-throwing.
+*/
+function wireDaemonTeardown(handle, opts = {}) {
+	const proc = opts.proc ?? process;
+	const graceMs = opts.graceMs ?? 300;
+	const setTimer = opts.setTimer ?? ((fn, ms) => setTimeout(fn, ms));
+	let killed = false;
+	const kill = () => {
+		if (killed) return;
+		killed = true;
+		try {
+			handle.kill();
+		} catch {}
+	};
+	let ended = false;
+	const endStdin = () => {
+		if (ended) return;
+		ended = true;
+		try {
+			handle.endStdin();
+		} catch {}
+	};
+	const onSignal = () => {
+		endStdin();
+		const t = setTimer(kill, graceMs);
+		if (t && typeof t.unref === "function") t.unref();
+	};
+	proc.once("SIGINT", onSignal);
+	proc.once("SIGTERM", onSignal);
+	proc.once("exit", () => {
+		endStdin();
+		kill();
+	});
+}
+//#endregion
+//#region src/lib/proxy.ts
+function initProxyFromEnv() {
+	if (typeof Bun !== "undefined") return;
+	try {
+		const direct = new Agent();
+		const proxies = /* @__PURE__ */ new Map();
+		setGlobalDispatcher({
+			dispatch(options, handler) {
+				try {
+					const origin = typeof options.origin === "string" ? new URL(options.origin) : options.origin;
+					const raw = getProxyForUrl(origin.toString());
+					const proxyUrl = raw && raw.length > 0 ? raw : void 0;
+					if (!proxyUrl) {
+						consola.debug(`HTTP proxy bypass: ${origin.hostname}`);
+						return direct.dispatch(options, handler);
+					}
+					let agent = proxies.get(proxyUrl);
+					if (!agent) {
+						agent = new ProxyAgent(proxyUrl);
+						proxies.set(proxyUrl, agent);
+					}
+					let label = proxyUrl;
+					try {
+						const u = new URL(proxyUrl);
+						label = `${u.protocol}//${u.host}`;
+					} catch {}
+					consola.debug(`HTTP proxy route: ${origin.hostname} via ${label}`);
+					return agent.dispatch(options, handler);
+				} catch {
+					return direct.dispatch(options, handler);
+				}
+			},
+			close() {
+				return direct.close();
+			},
+			destroy() {
+				return direct.destroy();
+			}
+		});
+		consola.debug("HTTP proxy configured from environment (per-URL)");
+	} catch (err) {
+		consola.debug("Proxy setup skipped:", err);
+	}
+}
+//#endregion
+//#region package.json
+var name = "github-router";
+var version = "0.3.255";
+//#endregion
+//#region src/lib/approval.ts
+const awaitApproval = async () => {
+	if (!await consola.prompt(`Accept incoming request?`, { type: "confirm" })) throw new HTTPError("Request rejected by user", Response.json({ message: "Request rejected by user" }, { status: 403 }));
+};
+//#endregion
+//#region src/lib/rate-limit.ts
+const RATE_LIMIT_QUEUE_TIMEOUT_MS = 5e3;
+let rateLimitChain = Promise.resolve();
+async function checkRateLimit(state) {
+	if (state.rateLimitSeconds === void 0) return;
+	const ticket = { aborted: false };
+	const myTurn = rateLimitChain.then(() => doCheck(state, ticket));
+	rateLimitChain = myTurn.catch(() => {});
+	return Promise.race([myTurn, sleep(RATE_LIMIT_QUEUE_TIMEOUT_MS).then(() => {
+		ticket.aborted = true;
+		throw new HTTPError("Rate limit queue wait exceeded", Response.json({
+			type: "error",
+			error: {
+				type: "rate_limit_error",
+				message: `Rate limit queue exceeded ${RATE_LIMIT_QUEUE_TIMEOUT_MS}ms; try again`
+			}
+		}, { status: 429 }));
+	})]);
+}
+async function doCheck(state, ticket) {
+	if (state.rateLimitSeconds === void 0) return;
+	if (ticket.aborted) return;
+	const now = Date.now();
+	if (!state.lastRequestTimestamp) {
+		state.lastRequestTimestamp = now;
+		return;
+	}
+	const elapsedSeconds = (now - state.lastRequestTimestamp) / 1e3;
+	if (elapsedSeconds > state.rateLimitSeconds) {
+		state.lastRequestTimestamp = now;
+		return;
+	}
+	const waitTimeSeconds = Math.ceil(state.rateLimitSeconds - elapsedSeconds);
+	if (!state.rateLimitWait) {
+		consola.warn(`Rate limit exceeded. Need to wait ${waitTimeSeconds} more seconds.`);
+		throw new HTTPError("Rate limit exceeded", Response.json({ message: "Rate limit exceeded" }, { status: 429 }));
+	}
+	const waitTimeMs = waitTimeSeconds * 1e3;
+	consola.warn(`Rate limit reached. Waiting ${waitTimeSeconds} seconds before proceeding...`);
+	await sleep(waitTimeMs);
+	if (ticket.aborted) return;
+	state.lastRequestTimestamp = Date.now();
+	consola.info("Rate limit wait completed, proceeding with request");
+}
+//#endregion
+//#region src/lib/request-log.ts
+/**
+* Format a number with K/M suffix for compact display.
+*/
+function formatTokens(n) {
+	if (n >= 1e6) return `${(n / 1e6).toFixed(1)}M`;
+	if (n >= 1e3) return `${(n / 1e3).toFixed(1)}K`;
+	return String(n);
+}
+/**
+* Build a context window summary: "in:1.2K out:50 ctx:1.2K/1M (0.1%)"
+*/
+function formatTokenInfo(inputTokens, outputTokens, model) {
+	if (inputTokens === void 0) return void 0;
+	const parts = [];
+	const maxPrompt = model?.capabilities?.limits?.max_prompt_tokens;
+	if (maxPrompt) {
+		const pct = (inputTokens / maxPrompt * 100).toFixed(1);
+		parts.push(`in:${formatTokens(inputTokens)}/${formatTokens(maxPrompt)} (${pct}%)`);
+	} else parts.push(`in:${formatTokens(inputTokens)}`);
+	if (outputTokens !== void 0) parts.push(`out:${formatTokens(outputTokens)}`);
+	return parts.join(" ");
+}
+/**
+* Print a single summary line for a completed request.
+*
+* Examples:
+*   POST /v1/messages  claude-opus-4.6-1m  in:1.2K/1M (0.1%) out:50  200  2.3s
+*   POST /v1/messages  claude-opus-4-6→claude-opus-4.6-1m  in:743/1M (0.1%)  200  198ms
+*   POST /v1/chat/completions  claude-sonnet-4  in:15 out:16  200  2.1s stream
+*/
+function logRequest(info, model, startTime) {
+	const parts = [];
+	parts.push(`${info.method} ${info.path}`);
+	if (info.resolvedModel && info.resolvedModel !== info.model) parts.push(`${info.model}→${info.resolvedModel}`);
+	else if (info.resolvedModel ?? info.model) parts.push(info.resolvedModel ?? info.model);
+	const tokenInfo = formatTokenInfo(info.inputTokens, info.outputTokens, model);
+	if (tokenInfo) parts.push(tokenInfo);
+	if (info.status !== void 0) parts.push(String(info.status));
+	const elapsed = Date.now() - startTime;
+	const duration = elapsed >= 1e3 ? `${(elapsed / 1e3).toFixed(1)}s` : `${elapsed}ms`;
+	parts.push(info.streaming ? `${duration} stream` : duration);
+	const line = parts.join("  ");
+	if (detectCapabilityMismatch(info, model)) consola.error(`[MISMATCH] ${line}`);
+	else consola.info(line);
+}
+/**
+* Detect when the API rejects a request for token/context reasons
+* that contradict what the /models endpoint reported.
+*/
+function detectCapabilityMismatch(info, model) {
+	if (!info.errorBody || !model) return false;
+	if (!info.status || info.status < 400) return false;
+	const err = info.errorBody.toLowerCase();
+	return err.includes("token") || err.includes("context") || err.includes("too long") || err.includes("max_tokens") || err.includes("prompt is too long");
+}
+/**
+* Opt-in instrumentation for the discovery loop (Phase 0.5 of the
+* long-horizon plan). When `GH_ROUTER_LOG_FIELDS=1` is set in the
+* environment, emits a single structured `[fields]` log line per request
+* recording the top-level body keys, per-tool field keys, and
+* anthropic-beta header values seen.
+*
+* Default-off (zero overhead). The companion
+* `scripts/discover-new-fields.sh` greps these lines, aggregates unique
+* field names per request shape, and diffs against the known-fields
+* list in `docs/copilot-compat-matrix.md` — surfacing anything new
+* that should get a probe row added.
+*
+* Format (single line, deterministic-ish key order):
+*   [fields] path=<P> body_keys=<csv> tool_field_keys=<csv> beta_values=<csv> agent=<id|->
+*
+* Where:
+*   - `body_keys` is the alphabetical union of top-level keys in the
+*     request body
+*   - `tool_field_keys` is the alphabetical union of all keys appearing
+*     across every entry of `body.tools[]` (or empty)
+*   - `beta_values` is the comma-split anthropic-beta header value as
+*     received (NOT filtered) — captures what the client sends, not
+*     what we forward
+*   - `agent` is Claude Code's `x-claude-code-agent-id` header, or `-` for
+*     main-loop traffic. Without it a capture cannot tell a subagent request
+*     from a main-loop one, which is exactly the question you need answered
+*     when reasoning about per-agent request shape (does a subagent send a
+*     `thinking` block?). The header value is opaque to us and is logged
+*     verbatim.
+*/
+function logRequestFields(opts) {
+	if (process.env.GH_ROUTER_LOG_FIELDS !== "1") return;
+	const bodyKeys = collectTopLevelKeys(opts.body);
+	const toolFieldKeys = collectToolFieldKeys(opts.body);
+	const betaValues = (opts.betaHeader ?? "").split(",").map((v) => v.trim()).filter(Boolean);
+	consola.info(`[fields] path=${opts.path} body_keys=${bodyKeys.join(",")} tool_field_keys=${toolFieldKeys.join(",")} beta_values=${betaValues.join(",")} agent=${opts.agentId && opts.agentId.length > 0 ? opts.agentId : "-"}`);
+}
+function collectTopLevelKeys(body) {
+	if (!body || typeof body !== "object" || Array.isArray(body)) return [];
+	return Object.keys(body).sort();
+}
+function collectToolFieldKeys(body) {
+	if (!body || typeof body !== "object") return [];
+	const tools = body.tools;
+	if (!Array.isArray(tools)) return [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const tool of tools) if (tool && typeof tool === "object" && !Array.isArray(tool)) for (const k of Object.keys(tool)) seen.add(k);
+	return [...seen].sort();
+}
+//#endregion
+//#region src/routes/chat-completions/handler.ts
+const ENCODER$1 = new TextEncoder();
+function formatSSE$1(chunk) {
+	const parts = [];
+	if (chunk.event) parts.push(`event: ${chunk.event}`);
+	if (chunk.data !== void 0) for (const line of String(chunk.data).split(/\r\n|\r|\n/)) parts.push(`data: ${line}`);
+	if (chunk.id !== void 0) parts.push(`id: ${String(chunk.id)}`);
+	return parts.join("\n") + "\n\n";
+}
+async function handleCompletion$1(c) {
+	const startTime = Date.now();
+	await checkRateLimit(state);
+	let payload = await c.req.json();
+	const debugEnabled = consola.level >= 4;
+	if (debugEnabled) consola.debug("Request payload:", JSON.stringify(payload).slice(-400));
+	if (state.manualApprove) await awaitApproval();
+	await injectWebSearchIfNeeded$1(payload);
+	const originalModel = payload.model;
+	const resolvedModel = resolveModel(payload.model);
+	if (resolvedModel !== payload.model) payload.model = resolvedModel;
+	const selectedModel = state.models?.data.find((model) => model.id === payload.model);
+	logEndpointMismatch(payload.model, "/chat/completions");
+	let inputTokens;
+	try {
+		if (selectedModel) inputTokens = (await getTokenCount(payload, selectedModel)).input;
+	} catch {}
+	if (isNullish(payload.max_tokens)) {
+		payload = {
+			...payload,
+			max_tokens: selectedModel?.capabilities?.limits?.max_output_tokens
+		};
+		if (debugEnabled) consola.debug("Set max_tokens to:", JSON.stringify(payload.max_tokens));
+	}
+	const response = await createChatCompletions(payload, selectedModel?.requestHeaders, void 0, true).catch(async (error) => {
+		if (error instanceof HTTPError) {
+			const errorBody = await error.response.clone().text().catch(() => "");
+			logRequest({
+				method: "POST",
+				path: c.req.path,
+				model: originalModel,
+				resolvedModel,
+				status: error.response.status,
+				errorBody
+			}, selectedModel, startTime);
+		}
+		throw error;
+	});
+	const isStreaming = !isNonStreaming$1(response);
+	const outputTokens = !isStreaming ? response.usage?.completion_tokens : void 0;
+	logRequest({
+		method: "POST",
+		path: c.req.path,
+		model: originalModel,
+		resolvedModel,
+		inputTokens,
+		outputTokens,
+		status: 200,
+		streaming: isStreaming
+	}, selectedModel, startTime);
+	if (!isStreaming) {
+		if (debugEnabled) consola.debug("Non-streaming response:", JSON.stringify(response));
+		return c.json(response);
+	}
+	const iterator = response[Symbol.asyncIterator]();
+	const firstResult = await readIteratorWithTimeout(iterator, UPSTREAM_INACTIVITY_TIMEOUT_MS);
+	if (firstResult.done) consola.warn(`Upstream /chat/completions returned an empty stream at ${c.req.path}`);
+	let pendingFirstChunk = firstResult.done ? void 0 : firstResult.value;
+	let upstreamFinished = firstResult.done;
+	let consumerCancelled = false;
+	const safeClose = (controller) => {
+		try {
+			controller.close();
+		} catch {}
+	};
+	const releaseUpstream = (reason) => {
+		if (typeof iterator.return === "function") iterator.return(reason).catch(() => {});
+	};
+	const safeEnqueue = (controller, bytes) => {
+		try {
+			controller.enqueue(bytes);
+			return true;
+		} catch (e) {
+			if (isControllerClosedError(e)) {
+				consumerCancelled = true;
+				releaseUpstream(e);
+				return false;
+			}
+			throw e;
+		}
+	};
+	return new Response(new ReadableStream({
+		async pull(controller) {
+			if (consumerCancelled || upstreamFinished) {
+				safeClose(controller);
+				return;
+			}
+			if (pendingFirstChunk !== void 0) {
+				const chunk = pendingFirstChunk;
+				pendingFirstChunk = void 0;
+				if (debugEnabled) consola.debug("Streaming chunk:", JSON.stringify(chunk));
+				safeEnqueue(controller, ENCODER$1.encode(formatSSE$1(chunk)));
+				return;
+			}
+			try {
+				const result = await readIteratorWithTimeout(iterator, UPSTREAM_INACTIVITY_TIMEOUT_MS);
+				if (consumerCancelled) {
+					safeClose(controller);
+					return;
+				}
+				if (result.done) {
+					upstreamFinished = true;
+					safeClose(controller);
+					return;
+				}
+				if (result.value === void 0 || result.value === null) return;
+				if (debugEnabled) consola.debug("Streaming chunk:", JSON.stringify(result.value));
+				safeEnqueue(controller, ENCODER$1.encode(formatSSE$1(result.value)));
+			} catch (error) {
+				upstreamFinished = true;
+				if (consumerCancelled) {
+					releaseUpstream(error);
+					safeClose(controller);
+					return;
+				}
+				const { errName, errMessage } = logStreamError(c.req.path, error);
+				safeEnqueue(controller, ENCODER$1.encode(buildOpenAIErrorEvent(errName, errMessage)));
+				releaseUpstream(error);
+				safeClose(controller);
+			}
+		},
+		cancel() {
+			consumerCancelled = true;
+			upstreamFinished = true;
+			releaseUpstream();
+		}
+	}), {
+		status: 200,
+		headers: {
+			"content-type": "text/event-stream",
+			"cache-control": "no-cache",
+			"transfer-encoding": "chunked",
+			connection: "keep-alive"
+		}
+	});
+}
+const isNonStreaming$1 = (response) => Object.hasOwn(response, "choices");
+async function injectWebSearchIfNeeded$1(payload) {
+	if (!payload.tools?.some((t) => "type" in t && t.type === "web_search" || t.function?.name === "web_search")) return;
+	const query = payload.messages.some((msg) => msg.role === "tool") ? void 0 : extractUserQuery$2(payload.messages);
+	if (query) try {
+		const results = await searchWeb(query);
+		const searchContext = [
+			"[Web Search Results]",
+			results.content,
+			"",
+			results.references.map((r) => `- [${r.title}](${r.url})`).join("\n"),
+			"[End Web Search Results]"
+		].join("\n");
+		const systemMsg = payload.messages.find((msg) => msg.role === "system");
+		if (systemMsg) systemMsg.content = `${searchContext}\n\n${typeof systemMsg.content === "string" ? systemMsg.content : Array.isArray(systemMsg.content) ? systemMsg.content.filter((p) => p.type === "text").map((p) => "text" in p ? p.text : "").join("\n") : ""}`;
+		else payload.messages.unshift({
+			role: "system",
+			content: searchContext
+		});
+	} catch (error) {
+		consola.warn("Web search failed, continuing without results:", error);
+	}
+	payload.tools = payload.tools?.filter((t) => !("type" in t && t.type === "web_search" || t.function?.name === "web_search"));
+	if (payload.tools?.length === 0) payload.tools = void 0;
+	if (!payload.tools) payload.tool_choice = void 0;
+	else if (payload.tool_choice && typeof payload.tool_choice === "object" && "type" in payload.tool_choice && payload.tool_choice.type === "function") {
+		const toolChoiceName = payload.tool_choice.function?.name;
+		if (toolChoiceName && !payload.tools.some((tool) => tool.function.name === toolChoiceName)) payload.tool_choice = void 0;
+	}
+}
+function extractUserQuery$2(messages) {
+	for (let i = messages.length - 1; i >= 0; i--) {
+		const msg = messages[i];
+		if (msg.role === "user") {
+			if (typeof msg.content === "string") return msg.content;
+			if (Array.isArray(msg.content)) {
+				const text = msg.content.find((p) => p.type === "text");
+				if (text && "text" in text) return text.text;
+			}
+		}
+	}
+}
+//#endregion
+//#region src/routes/chat-completions/route.ts
+const completionRoutes = new Hono();
+completionRoutes.post("/", async (c) => {
+	try {
+		return await handleCompletion$1(c);
+	} catch (error) {
+		return await forwardError(c, error);
+	}
+});
+//#endregion
+//#region src/services/copilot/create-embeddings.ts
+const createEmbeddings = async (payload) => {
+	if (!state.copilotToken) throw new Error("Copilot token not found");
+	const response = await fetch(`${copilotBaseUrl(state)}/embeddings`, {
+		method: "POST",
+		headers: copilotHeaders(state),
+		body: JSON.stringify(payload)
+	});
+	if (!response.ok) throw new HTTPError("Failed to create embeddings", response);
+	return await response.json();
+};
+//#endregion
+//#region src/routes/embeddings/route.ts
+const embeddingRoutes = new Hono();
+embeddingRoutes.post("/", async (c) => {
+	try {
+		const payload = await c.req.json();
+		const response = await createEmbeddings(payload);
+		return c.json(response);
+	} catch (error) {
+		return await forwardError(c, error);
+	}
+});
+//#endregion
+//#region src/routes/mcp/route.ts
+const mcpRoutes = new Hono();
+mcpRoutes.post("/", async (c) => {
+	try {
+		return await handleMcpPost(c, "all");
+	} catch (error) {
+		return await forwardError(c, error);
+	}
+});
+mcpRoutes.post("/:group", async (c) => {
+	try {
+		return await handleMcpPost(c, c.req.param("group"));
+	} catch (error) {
+		return await forwardError(c, error);
+	}
+});
+mcpRoutes.delete("/", (c) => {
+	try {
+		return handleMcpDelete(c);
+	} catch {
+		return c.body(null, 500);
+	}
+});
+mcpRoutes.delete("/:group", (c) => {
+	try {
+		return handleMcpDelete(c);
+	} catch {
+		return c.body(null, 500);
+	}
+});
+//#endregion
+//#region src/lib/sanitize-anthropic-body.ts
+/**
+* Inbound /v1/messages body sanitizer.
+*
+* Today this only handles ADVISOR-related corruption — the
+* proxy-generated `server_tool_use{name:"advisor"}` and paired
+* `advisor_tool_result` blocks may travel through Claude Code's
+* persisted conversation state with a malformed `id`/`tool_use_id`
+* (e.g., a leftover `toolu_*` value from before the round-5 fix).
+* Every replay of that history through `/v1/messages` would 400 at
+* Copilot's spec validator without rewriting them on inbound. This
+* module performs the rewrite.
+*
+* **Out of scope** (deliberate, per gemini-critic round 6 — the "ID
+* round-trip trap"): generic `tool_use.id` and `tool_result.tool_use_id`
+* are stateful references between requests; rewriting them statelessly
+* would break Claude Code's client-side tool tracker. Only advisor
+* blocks are touched here, because both sides of an advisor pair
+* (`server_tool_use` + `advisor_tool_result`) are proxy-generated and
+* round-trip together in the same request body — so a per-request
+* deterministic transformation preserves pairing without cross-request
+* state.
+*
+* **Round-7 holistic fix**: Copilot rejects `server_tool_use{name:
+* "advisor"}` outright (spec validator says only `web_search`,
+* `tool_search_tool_regex`, `tool_search_tool_bm25` are allowed), so
+* fixing the id format alone isn't enough. The sanitizer also
+* **translates** historical advisor pairs to the
+* `tool_use{__anthropic_advisor}` + `tool_result` shape Copilot
+* accepts (per user direction "Option C"). Multi-turn split is
+* required because `tool_result` must appear in a `user` role per
+* Anthropic spec. The `__anthropic_advisor` tool definition is
+* re-injected into `tools[]` so the `tool_use.name` reference
+* resolves.
+*/
+/**
+* Convert a `srvtoolu_*` id to the matching `toolu_*` id used in the
+* Copilot-replay shape (`tool_use.id` must match `^toolu_*$`). For
+* any other input shape, fall back to a synthesized `toolu_advisor_N`
+* id.
+*/
+function toCopilotToolUseId(srvId, fallbackIndex) {
+	if (srvId.startsWith("srvtoolu_")) {
+		const suffix = srvId.slice(9);
+		if (/^[a-zA-Z0-9_]+$/.test(suffix)) return `toolu_${suffix}`;
+	}
+	return `toolu_advisor_${fallbackIndex}`;
+}
+/**
+* Fast-path detector: returns true if the raw body has any chance of
+* needing sanitization. Avoids a full JSON parse for the common case
+* where the body is already spec-compliant.
+*
+* Looks for either an Anthropic-native advisor typed tool entry, or
+* any advisor-related block type that would need rewriting/
+* translating.
+*/
+function bodyMightNeedSanitize(rawBody) {
+	return rawBody.includes("\"server_tool_use\"") || rawBody.includes("\"advisor_tool_result\"") || /"type":"advisor_\d+"/.test(rawBody);
+}
+/**
+* Translate one assistant turn's content array, splitting at advisor
+* pairs into the multi-message structure Copilot accepts.
+*
+* Input shape (Claude Code stores everything in one assistant turn):
+*   [text*, server_tool_use{advisor}, advisor_tool_result, text*, ...]
+*
+* Output: array of {role, content[]} message objects, alternating
+* assistant→user→assistant for each advisor pair encountered.
+*/
+function splitAssistantTurnAtAdvisorPairs(originalContent, syntheticIndexRef) {
+	const messages = [];
+	let currentAssistantContent = [];
+	let translated = false;
+	let i = 0;
+	while (i < originalContent.length) {
+		const block = originalContent[i];
+		const b = typeof block === "object" && block !== null ? block : null;
+		if (b && b.type === "server_tool_use" && b.name === "__anthropic_advisor".replace(/^__anthropic_/, "")) {
+			const stuId = typeof b.id === "string" ? b.id : "";
+			const nextBlock = originalContent[i + 1];
+			const next = typeof nextBlock === "object" && nextBlock !== null ? nextBlock : null;
+			const copilotId = stuId.startsWith("srvtoolu_") ? toCopilotToolUseId(stuId, syntheticIndexRef.value++) : stuId.startsWith("toolu_") && /^toolu_[a-zA-Z0-9_]+$/.test(stuId) ? stuId : `toolu_advisor_${syntheticIndexRef.value++}`;
+			currentAssistantContent.push({
+				type: "tool_use",
+				id: copilotId,
+				name: ADVISOR_INTERNAL_TOOL_NAME,
+				input: {}
+			});
+			messages.push({
+				role: "assistant",
+				content: currentAssistantContent
+			});
+			translated = true;
+			let resultText = "";
+			if (next && next.type === "advisor_tool_result") {
+				const c = next.content;
+				if (typeof c === "string") resultText = c;
+				else if (typeof c === "object" && c !== null) {
+					const txt = c.text;
+					if (typeof txt === "string") resultText = txt;
+				}
+				i += 2;
+			} else {
+				resultText = "[Advisor result missing in conversation history.]";
+				i += 1;
+			}
+			messages.push({
+				role: "user",
+				content: [{
+					type: "tool_result",
+					tool_use_id: copilotId,
+					content: resultText
+				}]
+			});
+			currentAssistantContent = [];
+			continue;
+		}
+		if (b && b.type === "advisor_tool_result") {
+			translated = true;
+			i += 1;
+			continue;
+		}
+		currentAssistantContent.push(block);
+		i += 1;
+	}
+	if (currentAssistantContent.length > 0) messages.push({
+		role: "assistant",
+		content: currentAssistantContent
+	});
+	if (!translated) return {
+		messages: [{
+			role: "assistant",
+			content: originalContent
+		}],
+		translated: false
+	};
+	return {
+		messages,
+		translated: true
+	};
+}
+function sanitizeAnthropicBody(rawBody) {
+	if (!bodyMightNeedSanitize(rawBody)) return rawBody;
+	let parsed;
+	try {
+		parsed = JSON.parse(rawBody);
+	} catch {
+		return rawBody;
+	}
+	let mutated = false;
+	if (Array.isArray(parsed.tools)) {
+		const tools = parsed.tools;
+		const before = tools.length;
+		const filtered = tools.filter((t) => {
+			if (typeof t !== "object" || t === null) return true;
+			const type = t.type;
+			return typeof type !== "string" || !type.startsWith("advisor_");
+		});
+		if (filtered.length !== before) {
+			parsed.tools = filtered;
+			mutated = true;
+		}
+	}
+	if (Array.isArray(parsed.messages)) {
+		const original = parsed.messages;
+		const rebuilt = [];
+		let anyTranslated = false;
+		const syntheticIndexRef = { value: 0 };
+		for (const msg of original) {
+			if (typeof msg !== "object" || msg === null || msg.role !== "assistant") {
+				rebuilt.push(msg);
+				continue;
+			}
+			const content = msg.content;
+			if (!Array.isArray(content)) {
+				rebuilt.push(msg);
+				continue;
+			}
+			if (!content.some((b) => {
+				if (typeof b !== "object" || b === null) return false;
+				const type = b.type;
+				const name = b.name;
+				return type === "server_tool_use" && name === "advisor" || type === "advisor_tool_result";
+			})) {
+				rebuilt.push(msg);
+				continue;
+			}
+			const { messages: split, translated } = splitAssistantTurnAtAdvisorPairs(content, syntheticIndexRef);
+			if (translated) {
+				anyTranslated = true;
+				for (const m of split) rebuilt.push(m);
+			} else rebuilt.push(msg);
+		}
+		if (anyTranslated) {
+			parsed.messages = rebuilt;
+			mutated = true;
+			const existingTools = Array.isArray(parsed.tools) ? parsed.tools : [];
+			if (!existingTools.some((t) => {
+				if (typeof t !== "object" || t === null) return false;
+				return t.name === "__anthropic_advisor";
+			})) parsed.tools = [...existingTools, {
+				name: ADVISOR_INTERNAL_TOOL_NAME,
+				description: ADVISOR_TOOL_INSTRUCTIONS,
+				input_schema: {
+					type: "object",
+					properties: {},
+					required: []
+				}
+			}];
+		}
+	}
+	if (!mutated) return rawBody;
+	return JSON.stringify(parsed);
+}
+//#endregion
+//#region src/lib/anthropic-translate/anthropic-sse.ts
+/**
+* Anthropic Messages SSE egress: frame builders + a Bun-safe ReadableStream
+* adapter that serializes a generator of Anthropic stream events to wire bytes.
+*
+* The synthesizer (see `responses-egress.ts`) is source-specific and yields
+* plain event objects; these builders + adapter own the Anthropic wire shape
+* and the stream lifecycle so the synthesizer stays a pure state machine.
+*
+* Stream-lifecycle contract (repo mandate for any synthesized SSE surface):
+* the adapter is pull-based (backpressure-respecting), guards every
+* `controller.enqueue`/`close` against the consumer-cancel race
+* (`isControllerClosedError`), and on a mid-stream upstream error emits a
+* terminal Anthropic `event: error` frame before closing — mirroring
+* `relayAnthropicStream`. Verified against Bun's
+* `TypeError: Invalid state: Controller is already closed`.
+*/
+function makeMessageId() {
+	return `msg_${randomUUID().replace(/-/g, "")}`;
+}
+function makeMessageStart(id, model, usage = {}) {
+	return {
+		type: "message_start",
+		message: {
+			id,
+			type: "message",
+			role: "assistant",
+			model,
+			content: [],
+			stop_reason: null,
+			stop_sequence: null,
+			usage: {
+				input_tokens: usage.input_tokens ?? 0,
+				output_tokens: usage.output_tokens ?? 0,
+				cache_read_input_tokens: usage.cache_read_input_tokens ?? 0,
+				cache_creation_input_tokens: usage.cache_creation_input_tokens ?? 0
+			}
+		}
+	};
+}
+function makeContentBlockStart(index, block) {
+	return {
+		type: "content_block_start",
+		index,
+		content_block: block
+	};
+}
+function makeTextDelta(index, text) {
+	return {
+		type: "content_block_delta",
+		index,
+		delta: {
+			type: "text_delta",
+			text
+		}
+	};
+}
+function makeInputJsonDelta(index, partialJson) {
+	return {
+		type: "content_block_delta",
+		index,
+		delta: {
+			type: "input_json_delta",
+			partial_json: partialJson
+		}
+	};
+}
+function makeThinkingDelta(index, thinking) {
+	return {
+		type: "content_block_delta",
+		index,
+		delta: {
+			type: "thinking_delta",
+			thinking
+		}
+	};
+}
+function makeSignatureDelta(index, signature) {
+	return {
+		type: "content_block_delta",
+		index,
+		delta: {
+			type: "signature_delta",
+			signature
+		}
+	};
+}
+function makeContentBlockStop(index) {
+	return {
+		type: "content_block_stop",
+		index
+	};
+}
+function makeMessageDelta(stopReason, stopSequence, usage) {
+	return {
+		type: "message_delta",
+		delta: {
+			stop_reason: stopReason,
+			stop_sequence: stopSequence
+		},
+		usage: {
+			input_tokens: usage.input_tokens ?? 0,
+			output_tokens: usage.output_tokens ?? 0,
+			cache_read_input_tokens: usage.cache_read_input_tokens ?? 0,
+			cache_creation_input_tokens: usage.cache_creation_input_tokens ?? 0
+		}
+	};
+}
+function makeMessageStop() {
+	return { type: "message_stop" };
+}
+/** Serialize one event to the Anthropic SSE wire form (`event:` + `data:`). */
+function serializeAnthropicEvent(ev) {
+	return `event: ${ev.type}\ndata: ${JSON.stringify(ev)}\n\n`;
+}
+/**
+* Wrap a generator of Anthropic stream events into a byte `ReadableStream`.
+* Pull-based; guards the consumer-cancel race on both `enqueue` and `close`;
+* converts a mid-stream generator throw into a terminal `event: error` frame.
+* On consumer cancel it invokes `onCancel` (abort the upstream fetch) and
+* `return()`s the generator so its `finally` tears down the upstream reader.
+*/
+function anthropicSseStreamFromEvents(events, opts) {
+	const enc = new TextEncoder();
+	let consumerCancelled = false;
+	let finished = false;
+	const safeClose = (controller) => {
+		try {
+			controller.close();
+		} catch {}
+	};
+	return new ReadableStream({
+		async pull(controller) {
+			if (consumerCancelled || finished) {
+				safeClose(controller);
+				return;
+			}
+			let res;
+			try {
+				res = await events.next();
+			} catch (err) {
+				finished = true;
+				if (consumerCancelled) {
+					safeClose(controller);
+					return;
+				}
+				const name = err instanceof Error ? err.name : "Error";
+				const message = err instanceof Error ? err.message : String(err);
+				consola.error(`Anthropic-translate stream interrupted at ${opts.routePath}: ${name}: ${JSON.stringify(message)}`);
+				try {
+					controller.enqueue(enc.encode(buildAnthropicErrorEvent(name, message)));
+				} catch (enqueueError) {
+					if (!isControllerClosedError(enqueueError)) consola.warn(`Could not deliver error event to consumer at ${opts.routePath}: ${enqueueError instanceof Error ? enqueueError.message : String(enqueueError)}`);
+				}
+				safeClose(controller);
+				return;
+			}
+			if (consumerCancelled) {
+				safeClose(controller);
+				return;
+			}
+			if (res.done) {
+				finished = true;
+				safeClose(controller);
+				return;
+			}
+			try {
+				controller.enqueue(enc.encode(serializeAnthropicEvent(res.value)));
+			} catch (err) {
+				if (isControllerClosedError(err)) {
+					consumerCancelled = true;
+					return;
+				}
+				throw err;
+			}
+		},
+		cancel() {
+			consumerCancelled = true;
+			finished = true;
+			opts.onCancel?.();
+			events.return?.(void 0);
+		}
+	});
+}
+//#endregion
+//#region src/lib/reasoning-effort.ts
+/**
+* Reasoning-effort bucketing + clamping shared by the `/v1/messages` handler
+* (adaptive-thinking translation) and the Anthropic-translation shim
+* (thinking-budget → Responses `reasoning.effort`).
+*
+* Extracted from `src/routes/messages/handler.ts` so a `~/lib/*` module can
+* depend on it without importing route code (and without forming a
+* handler → shim → handler import cycle). `handler.ts` re-exports these for
+* backward compatibility with existing imports/tests.
+*/
+const EFFORT_ORDER = [
+	"low",
+	"medium",
+	"high",
+	"xhigh"
+];
+/**
+* Bucket a thinking budget into a Copilot reasoning-effort string.
+* `<2000`→low, `<8000`→medium, `<24000`→high, else→xhigh.
+* Defaults missing/non-numeric budgets to 8000 ("high").
+*/
+function bucketEffort(budget) {
+	const n = typeof budget === "number" && Number.isFinite(budget) ? budget : 8e3;
+	if (n < 2e3) return "low";
+	if (n < 8e3) return "medium";
+	if (n < 24e3) return "high";
+	return "xhigh";
+}
+/**
+* Clamp a bucketed effort to the closest value in `supported`. Ties resolve to
+* the lower-tier option (per EFFORT_ORDER).
+*
+* Iterates EFFORT_ORDER (canonical low→xhigh) so the first match on a given
+* distance is always the lower-tier value, regardless of input order in
+* `supported`.
+*/
+function clampEffort(bucketed, supported) {
+	if (supported.includes(bucketed)) return bucketed;
+	const targetIdx = EFFORT_ORDER.indexOf(bucketed);
+	let best;
+	let bestDist = Infinity;
+	for (let i = 0; i < EFFORT_ORDER.length; i++) {
+		const value = EFFORT_ORDER[i];
+		if (!supported.includes(value)) continue;
+		const dist = Math.abs(i - targetIdx);
+		if (dist < bestDist) {
+			bestDist = dist;
+			best = value;
+		}
+	}
+	return best ?? bucketed;
+}
+//#endregion
+//#region src/lib/anthropic-translate/anthropic-request.ts
+/**
+* Steering appended to `instructions` for shim-routed (non-Claude) models when
+* the request carries Claude Code's native file tools. gpt-5.5 and other
+* OpenAI/Gemini-lineage models receive the Edit/Write tool definitions verbatim
+* (the shim never mangles them), but their base prior is to script file ops in
+* Python/Bash rather than call the dedicated tools. Claude models never reach
+* this code path (they fall through to the /v1/messages passthrough), so this is
+* automatically scoped to the models that need the nudge. Strong PREFERENCE, not
+* a Bash ban — running builds/tests/git still belongs in Bash.
+*/
+const FILE_TOOL_GUIDANCE = `<file_tools>
+You have dedicated tools for files: use Read to read a file, Edit to modify an existing file, and Write to create one. Prefer them over shell for reading or editing. Do NOT shell out (cat, sed, awk, echo >, here-docs, or python/one-off scripts) to read, search, or rewrite file contents when a dedicated tool exists — the dedicated tools are safer and produce reviewable diffs. Use Grep/Glob to search rather than shell grep/find. Reserve Bash for commands that have no dedicated tool: builds, tests, git, package managers, and running programs.
+</file_tools>`;
+/**
+* Append `FILE_TOOL_GUIDANCE` to the flattened system `instructions` iff the
+* request carries Claude Code's canonical `Edit` or `Write` tool. The exact
+* capitalized-name match is deliberately precise: it fires for a Claude Code
+* editing session but not for arbitrary MCP tools like `write_file`, and not for
+* non-editing chats (so a plain gpt-5.5 conversation is not polluted). The block
+* is appended AFTER the existing instructions (end-of-prompt recency) and the
+* original system text is preserved, never replaced. Opt out with
+* `GH_ROUTER_DISABLE_SHIM_TOOL_STEERING=1`.
+*/
+function appendFileToolGuidance(instructions, tools) {
+	if (parseBoolEnv(process.env.GH_ROUTER_DISABLE_SHIM_TOOL_STEERING) === true) return instructions;
+	if (!tools?.some((t) => t.name === "Edit" || t.name === "Write")) return instructions;
+	return instructions && instructions.length > 0 ? `${instructions}\n\n${FILE_TOOL_GUIDANCE}` : FILE_TOOL_GUIDANCE;
+}
+/** Flatten Anthropic `system` (string | array of text blocks) into a string. */
+function flattenSystem(system) {
+	if (typeof system === "string") return system.length > 0 ? system : void 0;
+	if (Array.isArray(system)) {
+		let s = "";
+		for (const block of system) if (block && typeof block === "object" && block.type === "text") {
+			const t = block.text;
+			if (typeof t === "string") s += t;
+		}
+		return s.length > 0 ? s : void 0;
+	}
+}
+/**
+* Parse an Anthropic `tool_result.content` (string | block array) into the
+* plain-text `output` for the Responses `function_call_output` (a string-only
+* item) PLUS any image parts found in the content. A `function_call_output`
+* cannot carry images, so the caller emits the extracted images as a follow-up
+* user message (Claude Code browser screenshots/observations arrive this way).
+* `isError` (the tool_result `is_error` flag) is preserved by prefixing the
+* text so the model still learns the tool call failed.
+*/
+function parseToolResultContent(content, isError) {
+	const images = [];
+	let text = "";
+	if (typeof content === "string") text = content;
+	else if (Array.isArray(content)) for (const block of content) {
+		if (!block || typeof block !== "object") continue;
+		const b = block;
+		if (b.type === "text" && typeof b.text === "string") text += b.text;
+		else if (b.type === "image") {
+			const img = anthropicImageToNeutral(b.source);
+			if (img) images.push(img);
+		}
+	}
+	if (images.length > 0 && text.length === 0) text = "[image result below]";
+	if (isError) text = text.length > 0 ? `[tool error] ${text}` : "[tool error]";
+	return {
+		output: text,
+		images
+	};
+}
+/** Map an Anthropic `image` block source to a neutral image part. */
+function anthropicImageToNeutral(source) {
+	if (!source || typeof source !== "object") return null;
+	if (source.type === "url" && typeof source.url === "string") return {
+		type: "image",
+		url: source.url
+	};
+	if (source.type === "base64" && typeof source.data === "string") return {
+		type: "image",
+		mimeType: typeof source.media_type === "string" ? source.media_type : "image/png",
+		data: source.data
+	};
+	return null;
+}
+/** Concatenate the text of an Anthropic `document` `content`-source block array. */
+function joinDocumentContentText(content) {
+	if (!Array.isArray(content)) return "";
+	let text = "";
+	for (const block of content) if (block && typeof block === "object") {
+		const b = block;
+		if (b.type === "text" && typeof b.text === "string") text += b.text;
+	}
+	return text;
+}
+/**
+* Map an Anthropic `document` block to a neutral content part.
+*   - base64 source → neutral `document` (mimeType + data) → Responses
+*     `input_file` with `file_data`; on the chat path → an inline text note
+*     (Copilot's `/chat/completions` rejects file parts).
+*   - url source → neutral `document` (url) → Responses `input_file.file_url`.
+*   - text source (a plain-text document) → the doc's text folded into a `text`
+*     part, so the model sees it on BOTH paths.
+*   - content source (content-block document) → its text blocks folded into a
+*     `text` part.
+* Missing/invalid fields (unknown source type, `file`-id references Copilot has
+* no Files API for, empty text) yield null and are dropped.
+*/
+function anthropicDocumentToNeutral(b) {
+	const source = b.source;
+	if (!source || typeof source !== "object") return null;
+	const s = source;
+	const filename = typeof b.title === "string" && b.title.length > 0 ? b.title : "document.pdf";
+	if (s.type === "base64" && typeof s.data === "string") return {
+		type: "document",
+		mimeType: typeof s.media_type === "string" ? s.media_type : "application/pdf",
+		data: s.data,
+		filename
+	};
+	if (s.type === "url" && typeof s.url === "string") return {
+		type: "document",
+		url: s.url,
+		filename
+	};
+	if (s.type === "text" && typeof s.data === "string") return s.data.length > 0 ? {
+		type: "text",
+		text: s.data
+	} : null;
+	if (s.type === "content") {
+		const text = joinDocumentContentText(s.content);
+		return text.length > 0 ? {
+			type: "text",
+			text
+		} : null;
+	}
+	return null;
+}
+/**
+* Convert one Anthropic message into zero-or-more neutral messages. A user
+* message with `tool_result` blocks fans out: text/image content becomes a
+* user message and each tool_result becomes its own `toolResult` message,
+* emitted in wire order so a function_call_output never precedes its text.
+*/
+function anthropicMessageToNeutral(msg) {
+	const role = msg.role;
+	const content = msg.content;
+	if (role === "assistant") {
+		const parts = [];
+		if (typeof content === "string") {
+			if (content.length > 0) parts.push({
+				type: "text",
+				text: content
+			});
+		} else if (Array.isArray(content)) for (const block of content) {
+			if (!block || typeof block !== "object") continue;
+			const b = block;
+			if (b.type === "text" && typeof b.text === "string") parts.push({
+				type: "text",
+				text: b.text
+			});
+			else if (b.type === "tool_use") parts.push({
+				type: "toolCall",
+				id: typeof b.id === "string" ? b.id : "",
+				name: typeof b.name === "string" ? b.name : "",
+				arguments: b.input ?? {}
+			});
+		}
+		return [{
+			role: "assistant",
+			content: parts
+		}];
+	}
+	const out = [];
+	let userParts = [];
+	const flushUser = () => {
+		if (userParts.length === 0) return;
+		out.push({
+			role: "user",
+			content: userParts
+		});
+		userParts = [];
+	};
+	if (typeof content === "string") {
+		if (content.length > 0) out.push({
+			role: "user",
+			content
+		});
+		return out;
+	}
+	if (Array.isArray(content)) for (const block of content) {
+		if (!block || typeof block !== "object") continue;
+		const b = block;
+		if (b.type === "text" && typeof b.text === "string") userParts.push({
+			type: "text",
+			text: b.text
+		});
+		else if (b.type === "image") {
+			const img = anthropicImageToNeutral(b.source);
+			if (img) userParts.push(img);
+		} else if (b.type === "document") {
+			const doc = anthropicDocumentToNeutral(b);
+			if (doc) userParts.push(doc);
+		} else if (b.type === "tool_result") {
+			flushUser();
+			const { output, images } = parseToolResultContent(b.content, b.is_error === true);
+			out.push({
+				role: "toolResult",
+				toolCallId: typeof b.tool_use_id === "string" ? b.tool_use_id : "",
+				output
+			});
+			if (images.length > 0) out.push({
+				role: "user",
+				content: images
+			});
+		}
+	}
+	flushUser();
+	return out;
+}
+function parseTools(tools) {
+	if (!Array.isArray(tools) || tools.length === 0) return void 0;
+	const out = [];
+	for (const tool of tools) {
+		if (!tool || typeof tool !== "object") continue;
+		const t = tool;
+		if (typeof t.name !== "string" || t.name.length === 0) continue;
+		const schema = t.input_schema ?? t.parameters;
+		out.push({
+			name: t.name,
+			description: typeof t.description === "string" ? t.description : void 0,
+			parameters: schema && typeof schema === "object" ? schema : {
+				type: "object",
+				properties: {}
+			}
+		});
+	}
+	return out.length > 0 ? out : void 0;
+}
+function parseToolChoice(toolChoice) {
+	if (!toolChoice || typeof toolChoice !== "object") return void 0;
+	const tc = toolChoice;
+	switch (tc.type) {
+		case "auto": return "auto";
+		case "any": return "required";
+		case "none": return "none";
+		case "tool": return typeof tc.name === "string" && tc.name.length > 0 ? {
+			type: "function",
+			name: tc.name
+		} : void 0;
+		default: return;
+	}
+}
+/**
+* Anthropic carries `disable_parallel_tool_use` on the `tool_choice` object.
+* Returns `false` (the wire signal to disable parallel tool calls) only when it
+* is explicitly `true`; `undefined` otherwise, so the payload builders omit the
+* field rather than ever sending `parallel_tool_calls: true`.
+*/
+function parseDisableParallelToolUse(toolChoice) {
+	if (!toolChoice || typeof toolChoice !== "object") return void 0;
+	return toolChoice.disable_parallel_tool_use === true ? false : void 0;
+}
+/** Default absent Anthropic `thinking` to an effort, clamped by the model.
+*  Every shim model defaults to `high`, so a client level maps to the identical
+*  provider level (low→low, medium→medium, high→high, xhigh→xhigh) and `high` is
+*  the only value the router injects on its own. There is deliberately NO floor:
+*  an explicit client budget that buckets to `medium` yields `medium`, because a
+*  one-directional max() would mean the router silently overriding the level the
+*  user chose.
+*
+*  Opt in to the previous behavior (xhigh for the OpenAI frontier models when no
+*  thinking is sent) with `GH_ROUTER_FRONTIER_XHIGH_DEFAULT=1`. This replaces the
+*  old opt-OUT `GH_ROUTER_DISABLE_FRONTIER_XHIGH_DEFAULT`, whose meaning would
+*  have inverted under the new default.
+*
+*  Two honest limits, both pre-existing: the level is bucketed from a token
+*  budget so the mapping is lossy at the boundaries, and `clampEffort` moves a
+*  level the model does not advertise (gemini has no `xhigh`). Returns undefined
+*  for a model that advertises NO `reasoning_effort` allowlist, which leaves the
+*  provider's own default rather than `high` — forcing an effort there could 400.
+*  An explicit client `thinking` budget is handled by parseReasoningEffort and is
+*  NOT affected by this default. */
+function defaultReasoningEffort(model) {
+	const supported = model?.capabilities?.supports?.reasoning_effort;
+	if (!(Array.isArray(supported) && supported.length > 0)) return void 0;
+	return clampEffort(parseBoolEnv(process.env.GH_ROUTER_FRONTIER_XHIGH_DEFAULT) === true && model?.id != null && shimDefaultsToXhigh(model.id) && supported.includes("xhigh") ? "xhigh" : "high", supported);
+}
+/**
+* Map Anthropic `thinking` to a Responses reasoning effort, clamped to the
+* model's `reasoning_effort` allowlist. Returns undefined when thinking is
+* absent/disabled/non-enabled; the absent default is applied at the call site.
+*/
+function parseReasoningEffort(thinking, model) {
+	if (!thinking || typeof thinking !== "object") return void 0;
+	const t = thinking;
+	if (t.type !== "enabled") return void 0;
+	const bucketed = bucketEffort(t.budget_tokens);
+	const supported = model?.capabilities?.supports?.reasoning_effort;
+	return Array.isArray(supported) && supported.length > 0 ? clampEffort(bucketed, supported) : bucketed;
+}
+/**
+* Parse an already-JSON-parsed Anthropic Messages body into the neutral shape.
+* `resolvedModel` is the catalog id the request will run on; `model` its
+* catalog entry (for the reasoning-effort allowlist).
+*/
+function parseAnthropicRequest(body, resolvedModel, model) {
+	const messages = [];
+	if (Array.isArray(body.messages)) {
+		for (const msg of body.messages) if (msg && typeof msg === "object") for (const n of anthropicMessageToNeutral(msg)) messages.push(n);
+	}
+	const maxTokens = typeof body.max_tokens === "number" && body.max_tokens > 0 ? body.max_tokens : void 0;
+	const stopSequences = Array.isArray(body.stop_sequences) ? body.stop_sequences.filter((s) => typeof s === "string") : void 0;
+	const tools = parseTools(body.tools);
+	return {
+		model: resolvedModel,
+		instructions: appendFileToolGuidance(flattenSystem(body.system), tools),
+		messages,
+		tools,
+		toolChoice: parseToolChoice(body.tool_choice),
+		parallelToolCalls: parseDisableParallelToolUse(body.tool_choice),
+		reasoningEffort: body.thinking === void 0 ? defaultReasoningEffort(model) : parseReasoningEffort(body.thinking, model),
+		maxOutputTokens: maxTokens,
+		stopSequences: stopSequences && stopSequences.length > 0 ? stopSequences : void 0,
+		stream: body.stream === true
+	};
+}
+/** Build the Copilot `/responses` payload from a parsed Anthropic request. */
+function parsedToResponsesPayload(parsed) {
+	return assembleResponsesPayload({
+		model: parsed.model,
+		instructions: parsed.instructions,
+		messages: parsed.messages,
+		tools: parsed.tools,
+		toolChoice: parsed.toolChoice,
+		reasoningEffort: parsed.reasoningEffort,
+		maxOutputTokens: parsed.maxOutputTokens,
+		stopSequences: parsed.stopSequences,
+		parallelToolCalls: parsed.parallelToolCalls,
+		stream: parsed.stream
+	});
+}
+//#endregion
+//#region src/lib/anthropic-translate/chat-request.ts
+/** Build the `data:` URI (base64) or return the verbatim URL for an image part. */
+function imageUrlFor(part) {
+	if (typeof part.url === "string" && part.url.length > 0) return part.url;
+	return `data:${part.mimeType ?? "image/png"};base64,${part.data ?? ""}`;
+}
+/**
+* A brief inline note standing in for a document on the chat path. Copilot's
+* `/chat/completions` rejects file content parts (`type` must be `image_url` or
+* `text` → HTTP 400), so a document (PDF) can't be forwarded to a Gemini model;
+* the note keeps the document from being silently dropped and tells the model
+* one was provided but is unavailable, instead of 400ing the request.
+*
+* The note is wrapped in leading + trailing newlines so it is always DELIMITED
+* from adjacent user text — in the string-collapse branch it can't glue onto a
+* neighboring text run (`...[model]what is this?`), and in the content-parts
+* branch it stands as its own line. Regular text-to-text concatenation is left
+* untouched (only the note carries the delimiter), so wire order is preserved.
+*/
+function documentNote(part) {
+	return `\n[document "${part.filename ?? "document"}" attached but not supported for this model]\n`;
+}
+/**
+* A user turn: plain string when there are no images; otherwise OpenAI content
+* parts (`text` / `image_url`). Mirrors `neutralUserToResponses` so the two
+* shims encode a multimodal user turn the same way.
+*/
+function neutralUserToChat(m) {
+	if (typeof m.content === "string") return {
+		role: "user",
+		content: m.content
+	};
+	if (!m.content.some((c) => c.type === "image")) {
+		let text = "";
+		for (const c of m.content) if (c.type === "text") text += c.text;
+		else if (c.type === "document") text += documentNote(c);
+		return {
+			role: "user",
+			content: text
+		};
+	}
+	const parts = [];
+	for (const c of m.content) if (c.type === "text") parts.push({
+		type: "text",
+		text: c.text
+	});
+	else if (c.type === "image") parts.push({
+		type: "image_url",
+		image_url: { url: imageUrlFor(c) }
+	});
+	else if (c.type === "document") parts.push({
+		type: "text",
+		text: documentNote(c)
+	});
+	return {
+		role: "user",
+		content: parts
+	};
+}
+/**
+* An assistant turn: text parts collapse into `content`, tool_use parts become
+* OpenAI `tool_calls`. Unlike the Responses path (which flushes text before each
+* call to preserve interleaving), the chat wire shape carries all text on
+* `content` and all calls on `tool_calls`, so ordering within the turn is not
+* representable — matching how OpenAI itself echoes an assistant turn. When the
+* turn is tool-calls-only, `content` is `null` (OpenAI convention).
+*/
+function neutralAssistantToChat(m) {
+	let text = "";
+	const toolCalls = [];
+	for (const c of m.content) if (c.type === "text") text += c.text;
+	else if (c.type === "toolCall") toolCalls.push({
+		id: c.id,
+		type: "function",
+		function: {
+			name: c.name,
+			arguments: JSON.stringify(c.arguments ?? {})
+		}
+	});
+	const msg = {
+		role: "assistant",
+		content: text.length > 0 ? text : toolCalls.length > 0 ? null : ""
+	};
+	if (toolCalls.length > 0) msg.tool_calls = toolCalls;
+	return msg;
+}
+/** Translate one neutral message into a single chat/completions message. */
+function neutralMessageToChat(m) {
+	if (m.role === "user") return neutralUserToChat(m);
+	if (m.role === "assistant") return neutralAssistantToChat(m);
+	return {
+		role: "tool",
+		tool_call_id: m.toolCallId,
+		content: m.output
+	};
+}
+function neutralToolsToChat(tools) {
+	if (!tools || tools.length === 0) return void 0;
+	return tools.map((t) => ({
+		type: "function",
+		function: {
+			name: t.name,
+			description: t.description,
+			parameters: t.parameters ?? {
+				type: "object",
+				properties: {}
+			}
+		}
+	}));
+}
+/**
+* Convert the parsed (Responses-flat) `tool_choice` to the chat NESTED form.
+* A forced tool is `{type:"function", function:{name}}` on chat/completions —
+* distinct from the Responses flat `{type:"function", name}`. `"auto"` /
+* `"required"` / `"none"` pass through unchanged.
+*/
+function toolChoiceToChat(tc) {
+	if (tc === void 0) return void 0;
+	if (typeof tc === "string") return tc === "auto" || tc === "none" || tc === "required" ? tc : void 0;
+	if (tc.type === "function" && typeof tc.name === "string" && tc.name.length > 0) return {
+		type: "function",
+		function: { name: tc.name }
+	};
+}
+/** Assemble the `/chat/completions` payload from a parsed Anthropic request. */
+function parsedToChatPayload(parsed) {
+	const messages = [];
+	if (parsed.instructions) messages.push({
+		role: "system",
+		content: parsed.instructions
+	});
+	for (const m of parsed.messages) messages.push(neutralMessageToChat(m));
+	const payload = {
+		model: parsed.model,
+		messages,
+		stream: parsed.stream
+	};
+	const tools = neutralToolsToChat(parsed.tools);
+	if (tools && tools.length > 0) {
+		payload.tools = tools;
+		payload.tool_choice = toolChoiceToChat(parsed.toolChoice) ?? "auto";
+	}
+	if (parsed.reasoningEffort && parsed.reasoningEffort !== "off") payload.reasoning_effort = parsed.reasoningEffort;
+	if (typeof parsed.maxOutputTokens === "number" && parsed.maxOutputTokens > 0) payload.max_tokens = parsed.maxOutputTokens;
+	if (parsed.stopSequences && parsed.stopSequences.length > 0) payload.stop = parsed.stopSequences;
+	if (parsed.parallelToolCalls === false) payload.parallel_tool_calls = false;
+	return payload;
+}
+//#endregion
+//#region src/lib/anthropic-translate/chat-egress.ts
+/**
+* Copilot `/chat/completions` → Anthropic Messages egress (the Gemini path).
+*
+*  - `chatResponseToAnthropicMessage` maps a non-streaming chat/completions
+*    object to an Anthropic Messages object (text + tool_use blocks, usage,
+*    stop_reason).
+*  - `synthAnthropicFromChat` is the streaming state machine: it consumes
+*    Copilot's chat SSE (`choices[].delta`) and yields Anthropic stream events
+*    (message_start → content_block_* → message_delta → message_stop), reusing
+*    the shared `anthropic-sse.ts` frame builders.
+*
+* Chat streaming differs from the Responses path in one load-bearing way: there
+* is NO authoritative per-tool `.done` event carrying the full arguments — a
+* tool call's `id`/`name` arrive early (first delta for its array `index`) and
+* its `arguments` stream incrementally across later deltas keyed by that same
+* array `index`. So each tool is BUFFERED per OpenAI array index and its
+* Anthropic block is emitted ATOMICALLY at end-of-stream (content_block_start →
+* one input_json_delta with the full assembled args → content_block_stop). This
+* carries the Phase 1 C1 correctness lesson to the chat path: parallel/multiple
+* tools keep DISTINCT block indices and never lose their args to a clobbered
+* shared pointer. An open TEXT block is closed before any tool block opens (a
+* tool_use must not nest inside a text block on the wire). The Anthropic block
+* index is assigned at emit time so indices stay monotonic on the wire.
+*/
+/** Synthesize a matchable Anthropic tool_use id when the upstream id is absent. */
+function makeToolUseId$1() {
+	return `toolu_${randomUUID().replace(/-/g, "")}`;
+}
+function parseToolArgs$1(raw) {
+	if (typeof raw !== "string" || raw.trim().length === 0) return {};
+	try {
+		const parsed = JSON.parse(raw);
+		if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) return parsed;
+	} catch {}
+	return {};
+}
+function anthropicUsageFromChat(u) {
+	if (!u) return {};
+	return {
+		input_tokens: u.prompt_tokens ?? 0,
+		output_tokens: u.completion_tokens ?? 0,
+		cache_read_input_tokens: u.prompt_tokens_details?.cached_tokens ?? 0,
+		cache_creation_input_tokens: 0
+	};
+}
+/**
+* Map a chat/completions `finish_reason` to an Anthropic stop_reason. A
+* truncated (`length`) response is `max_tokens` even when a partial tool call
+* is present — the response was cut — mirroring the Responses egress precedence.
+* `tool_calls` (or any buffered tool) → `tool_use`.
+*
+* `content_filter` maps to Anthropic's `refusal`, NOT `end_turn`. It used to
+* collapse into `end_turn`, which made an upstream safety block indistinguishable
+* from a normal completion: the client saw a successful, usually empty, message
+* and had no way to tell that content had been withheld. `refusal` is the
+* documented Anthropic stop_reason for exactly this case.
+*/
+function chatStopReason(finishReason, sawTool) {
+	if (finishReason === "length") return "max_tokens";
+	if (finishReason === "tool_calls" || sawTool) return "tool_use";
+	if (finishReason === "content_filter") return "refusal";
+	return "end_turn";
+}
+/**
+* Map a non-streaming chat/completions object to an Anthropic Messages object.
+* The first choice's `message.content` becomes a text block (when non-empty)
+* and each `message.tool_calls[]` becomes a tool_use block.
+*/
+function chatResponseToAnthropicMessage(resp, modelId) {
+	const choice = resp.choices?.[0];
+	const content = [];
+	let sawTool = false;
+	const message = choice?.message;
+	if (message) {
+		if (typeof message.content === "string" && message.content.length > 0) content.push({
+			type: "text",
+			text: message.content
+		});
+		if (typeof message.refusal === "string" && message.refusal.length > 0) content.push({
+			type: "text",
+			text: message.refusal
+		});
+		if (Array.isArray(message.tool_calls)) for (const tc of message.tool_calls) {
+			sawTool = true;
+			const rawId = typeof tc.id === "string" ? tc.id : "";
+			content.push({
+				type: "tool_use",
+				id: rawId.length > 0 ? rawId : makeToolUseId$1(),
+				name: typeof tc.function?.name === "string" ? tc.function.name : "",
+				input: parseToolArgs$1(tc.function?.arguments)
+			});
+		}
+	}
+	const usage = anthropicUsageFromChat(resp.usage);
+	const stopReason = chatStopReason(choice?.finish_reason ?? null, sawTool);
+	return {
+		id: typeof resp.id === "string" && resp.id.length > 0 ? `msg_${resp.id}` : makeMessageId(),
+		type: "message",
+		role: "assistant",
+		model: modelId,
+		content,
+		stop_reason: stopReason,
+		stop_sequence: null,
+		usage: {
+			input_tokens: usage.input_tokens ?? 0,
+			output_tokens: usage.output_tokens ?? 0,
+			cache_read_input_tokens: usage.cache_read_input_tokens ?? 0,
+			cache_creation_input_tokens: usage.cache_creation_input_tokens ?? 0
+		}
+	};
+}
+/**
+* Streaming synthesizer: consume a chat/completions SSE iterable, yield the
+* Anthropic event sequence. Emits `message_start` first, streams text live,
+* buffers tool calls per OpenAI array index and flushes them atomically at
+* end-of-stream (in numeric index order), then a terminal `message_delta`
+* (accumulated usage + stop_reason) and `message_stop`. The `[DONE]` sentinel
+* is the authoritative clean-end marker: a stream that ends WITHOUT it is
+* treated as truncated and throws so the stream adapter can emit a terminal
+* `event: error`. A clean `[DONE]` carrying no chunk-level `finish_reason`
+* still completes cleanly (stop_reason from any buffered tool, else `end_turn`).
+*/
+async function* synthAnthropicFromChat(upstream, opts) {
+	const messageId = opts.messageId ?? makeMessageId();
+	let nextIndex = 0;
+	let activeTextIndex = null;
+	const toolByIndex = /* @__PURE__ */ new Map();
+	let usageIn = 0;
+	let usageOut = 0;
+	let usageCacheRead = 0;
+	let finishReason = null;
+	let sawDone = false;
+	yield makeMessageStart(messageId, opts.modelId);
+	for await (const evt of upstream) {
+		const data = evt?.data;
+		if (data == null) continue;
+		if (data === "[DONE]") {
+			sawDone = true;
+			break;
+		}
+		let chunk;
+		try {
+			chunk = JSON.parse(data);
+		} catch {
+			continue;
+		}
+		if (chunk.usage) {
+			usageIn = Math.max(usageIn, chunk.usage.prompt_tokens ?? 0);
+			usageOut = Math.max(usageOut, chunk.usage.completion_tokens ?? 0);
+			usageCacheRead = Math.max(usageCacheRead, chunk.usage.prompt_tokens_details?.cached_tokens ?? 0);
+		}
+		const choice = chunk.choices?.[0];
+		if (!choice) continue;
+		const delta = choice.delta;
+		if (delta && typeof delta.content === "string" && delta.content.length > 0) {
+			if (activeTextIndex == null) {
+				activeTextIndex = nextIndex++;
+				yield makeContentBlockStart(activeTextIndex, {
+					type: "text",
+					text: ""
+				});
+			}
+			yield makeTextDelta(activeTextIndex, delta.content);
+		}
+		if (delta && typeof delta.refusal === "string" && delta.refusal.length > 0) {
+			if (activeTextIndex == null) {
+				activeTextIndex = nextIndex++;
+				yield makeContentBlockStart(activeTextIndex, {
+					type: "text",
+					text: ""
+				});
+			}
+			yield makeTextDelta(activeTextIndex, delta.refusal);
+		}
+		if (delta && Array.isArray(delta.tool_calls) && delta.tool_calls.length > 0) {
+			if (activeTextIndex != null) {
+				yield makeContentBlockStop(activeTextIndex);
+				activeTextIndex = null;
+			}
+			for (const tcd of delta.tool_calls) {
+				if (tcd == null || typeof tcd.index !== "number") continue;
+				let entry = toolByIndex.get(tcd.index);
+				if (!entry) {
+					entry = {
+						id: "",
+						name: "",
+						args: ""
+					};
+					toolByIndex.set(tcd.index, entry);
+				}
+				if (typeof tcd.id === "string" && tcd.id.length > 0) entry.id = tcd.id;
+				const name = tcd.function?.name;
+				if (typeof name === "string" && name.length > 0) entry.name = name;
+				const argDelta = tcd.function?.arguments;
+				if (typeof argDelta === "string" && argDelta.length > 0) entry.args += argDelta;
+			}
+		}
+		if (choice.finish_reason != null) finishReason = choice.finish_reason;
+	}
+	if (!sawDone) throw new Error("chat stream ended without a [DONE] sentinel (truncated)");
+	if (activeTextIndex != null) yield makeContentBlockStop(activeTextIndex);
+	let sawTool = false;
+	const orderedTools = [...toolByIndex.entries()].sort((a, b) => a[0] - b[0]);
+	for (const [, entry] of orderedTools) {
+		sawTool = true;
+		const index = nextIndex++;
+		yield makeContentBlockStart(index, {
+			type: "tool_use",
+			id: entry.id.length > 0 ? entry.id : makeToolUseId$1(),
+			name: entry.name,
+			input: {}
+		});
+		yield makeInputJsonDelta(index, JSON.stringify(parseToolArgs$1(entry.args)));
+		yield makeContentBlockStop(index);
+	}
+	yield makeMessageDelta(chatStopReason(finishReason, sawTool), null, {
+		input_tokens: usageIn,
+		output_tokens: usageOut,
+		cache_read_input_tokens: usageCacheRead,
+		cache_creation_input_tokens: 0
+	});
+	yield makeMessageStop();
+}
+//#endregion
+//#region src/lib/anthropic-translate/responses-egress.ts
+/**
+* OpenAI `/responses` → Anthropic Messages egress.
+*
+*  - `responsesResponseToAnthropicMessage` maps a non-streaming Responses object
+*    to an Anthropic Messages object (content blocks, tool_use, usage,
+*    stop_reason).
+*  - `synthAnthropicFromResponses` is the streaming state machine: it consumes
+*    Copilot's `/responses` SSE and yields Anthropic stream events
+*    (message_start → content_block_* → message_delta → message_stop).
+*
+* The decode follows our own empirically-verified `/responses` handling
+* (`src/lib/worker-agent/stream-fn.ts`): the tool/reasoning block key is the
+* STABLE `output_index`, never the per-event `item_id` — Copilot re-encrypts
+* `item_id` on every event, so an id key makes every delta lookup miss and the
+* tool args drop to `{}`.
+*
+* Block lifecycle (mirrors stream-fn.ts): every output item is tracked
+* independently by its `output_index` key. Parallel/interleaved tool calls
+* never force-close a sibling — Responses emits ALL `output_item.added` for
+* parallel tools BEFORE the first `function_call_arguments.delta`, so opening (and
+* emitting) a tool at `added` time would ship it with empty args and drop the
+* later deltas. Instead a tool's args are BUFFERED and its Anthropic block is
+* emitted ATOMICALLY (content_block_start → single input_json_delta with the
+* full assembled args → content_block_stop) at that tool's OWN
+* `output_item.done` (or flushed at end-of-stream if the item was left
+* dangling). Only an open TEXT or THINKING block is closed on a type switch —
+* never a sibling tool. The Anthropic block index is assigned at emit time, so
+* indices stay monotonic on the wire regardless of item interleaving.
+*/
+/**
+* Stable map key for a `/responses` output item: prefer `output_index`
+* (constant per item), fall back to the opaque id only when absent. Namespaced
+* so a numeric index and a string id can never collide.
+*/
+function responsesKey(outputIndex, fallbackId) {
+	if (typeof outputIndex === "number") return `oi:${outputIndex}`;
+	if (typeof fallbackId === "string" && fallbackId.length > 0) return `id:${fallbackId}`;
+}
+/** Synthesize a matchable Anthropic tool_use id when the upstream id is absent. */
+function makeToolUseId() {
+	return `toolu_${randomUUID().replace(/-/g, "")}`;
+}
+/** First non-empty string among the candidates, or "" when none qualifies. */
+function firstNonEmpty(...vals) {
+	for (const v of vals) if (typeof v === "string" && v.length > 0) return v;
+	return "";
+}
+function anthropicUsageFromResponses(u) {
+	if (!u) return {};
+	return {
+		input_tokens: u.input_tokens ?? 0,
+		output_tokens: u.output_tokens ?? 0,
+		cache_read_input_tokens: u.input_tokens_details?.cached_tokens ?? 0,
+		cache_creation_input_tokens: 0
+	};
+}
+function parseToolArgs(raw) {
+	if (typeof raw !== "string" || raw.trim().length === 0) return {};
+	try {
+		const parsed = JSON.parse(raw);
+		if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) return parsed;
+	} catch {}
+	return {};
+}
+/**
+* Map a non-streaming Responses object to an Anthropic Messages object.
+*
+* stop_reason precedence for a completed non-streaming response:
+* an incomplete/max-output response is `max_tokens` even if a partial tool call
+* is present (the response was truncated), else a function_call → `tool_use`,
+* else `end_turn`.
+*/
+function responsesResponseToAnthropicMessage(resp, modelId) {
+	const output = Array.isArray(resp.output) ? resp.output : [];
+	const content = [];
+	let sawToolUse = false;
+	for (const rawItem of output) {
+		if (!rawItem || typeof rawItem !== "object") continue;
+		const item = rawItem;
+		if (item.type === "message") {
+			let text = "";
+			if (Array.isArray(item.content)) {
+				for (const part of item.content) if (part && typeof part === "object" && part.type === "output_text" && typeof part.text === "string") text += part.text;
+			}
+			if (text.length > 0) content.push({
+				type: "text",
+				text
+			});
+		} else if (item.type === "function_call") {
+			sawToolUse = true;
+			const rawId = typeof item.call_id === "string" && item.call_id.length > 0 ? item.call_id : typeof item.id === "string" && item.id.length > 0 ? item.id : "";
+			content.push({
+				type: "tool_use",
+				id: rawId.length > 0 ? rawId : makeToolUseId(),
+				name: typeof item.name === "string" ? item.name : "",
+				input: parseToolArgs(item.arguments)
+			});
+		} else if (item.type === "reasoning") {
+			let thinking = "";
+			if (Array.isArray(item.summary)) {
+				for (const part of item.summary) if (part && typeof part === "object" && typeof part.text === "string") thinking += part.text;
+			}
+			if (thinking.length > 0) content.push({
+				type: "thinking",
+				thinking,
+				signature: typeof item.encrypted_content === "string" ? item.encrypted_content : ""
+			});
+		}
+	}
+	const usage = anthropicUsageFromResponses(resp.usage);
+	const stopReason = resp.status === "incomplete" && resp.incomplete_details?.reason === "max_output_tokens" ? "max_tokens" : sawToolUse ? "tool_use" : "end_turn";
+	return {
+		id: typeof resp.id === "string" && resp.id.length > 0 ? `msg_${resp.id}` : makeMessageId(),
+		type: "message",
+		role: "assistant",
+		model: modelId,
+		content,
+		stop_reason: stopReason,
+		stop_sequence: null,
+		usage: {
+			input_tokens: usage.input_tokens ?? 0,
+			output_tokens: usage.output_tokens ?? 0,
+			cache_read_input_tokens: usage.cache_read_input_tokens ?? 0,
+			cache_creation_input_tokens: usage.cache_creation_input_tokens ?? 0
+		}
+	};
+}
+/**
+* Streaming synthesizer: consume a `/responses` SSE iterable, yield the
+* Anthropic event sequence. Emits `message_start` first, then content blocks in
+* item order, then a terminal `message_delta` (accumulated usage + stop_reason)
+* and `message_stop`. A `response.failed` throws so the stream adapter can emit
+* a terminal `event: error`; a stream that ends WITHOUT a terminal event
+* (`completed`/`incomplete`/`failed`) is treated as truncated and throws too.
+*/
+async function* synthAnthropicFromResponses(upstream, opts) {
+	const messageId = opts.messageId ?? makeMessageId();
+	const q = [];
+	let nextIndex = 0;
+	let current = null;
+	const toolByKey = /* @__PURE__ */ new Map();
+	const thinkingByKey = /* @__PURE__ */ new Map();
+	const textByKey = /* @__PURE__ */ new Map();
+	let usageIn = 0;
+	let usageOut = 0;
+	let usageCacheRead = 0;
+	let sawTool = false;
+	let hitMaxTokens = false;
+	let sawTerminal = false;
+	const closeCurrent = () => {
+		if (!current) return;
+		q.push(makeContentBlockStop(current.index));
+		current = null;
+	};
+	const currentKind = () => current ? current.kind : null;
+	const currentIndex = () => current ? current.index : null;
+	const ensureTextState = (key) => {
+		const existing = textByKey.get(key);
+		if (existing != null && current?.kind === "text" && current.index === existing.index) return existing;
+		closeCurrent();
+		const index = nextIndex++;
+		const state = {
+			index,
+			emitted: ""
+		};
+		textByKey.set(key, state);
+		current = {
+			index,
+			kind: "text"
+		};
+		q.push(makeContentBlockStart(index, {
+			type: "text",
+			text: ""
+		}));
+		return state;
+	};
+	const ensureThinking = (key) => {
+		if (current?.kind === "thinking" && thinkingByKey.get(key) === current.index) return current.index;
+		closeCurrent();
+		const index = nextIndex++;
+		current = {
+			index,
+			kind: "thinking"
+		};
+		thinkingByKey.set(key, index);
+		q.push(makeContentBlockStart(index, {
+			type: "thinking",
+			thinking: ""
+		}));
+		return index;
+	};
+	const emitTool = (t) => {
+		if (t.emitted) return;
+		closeCurrent();
+		const index = nextIndex++;
+		q.push(makeContentBlockStart(index, {
+			type: "tool_use",
+			id: t.id,
+			name: t.name,
+			input: {}
+		}));
+		const args = t.argsBuffer.length > 0 ? t.argsBuffer : "{}";
+		q.push(makeInputJsonDelta(index, args));
+		q.push(makeContentBlockStop(index));
+		t.emitted = true;
+		sawTool = true;
+	};
+	q.push(makeMessageStart(messageId, opts.modelId));
+	for (const e of q) yield e;
+	q.length = 0;
+	for await (const evt of upstream) {
+		const data = evt?.data;
+		if (data == null) continue;
+		if (data === "[DONE]") break;
+		let ev;
+		try {
+			ev = JSON.parse(data);
+		} catch {
+			continue;
+		}
+		switch (ev.type) {
+			case "response.output_text.delta": {
+				const d = ev.delta;
+				if (typeof d !== "string" || d.length === 0) break;
+				const state = ensureTextState(responsesKey(ev.output_index, ev.item_id) ?? "text");
+				state.emitted += d;
+				q.push(makeTextDelta(state.index, d));
+				break;
+			}
+			case "response.output_text.done": {
+				const key = responsesKey(ev.output_index, ev.item_id) ?? "text";
+				const fullText = typeof ev.text === "string" ? ev.text : "";
+				const existing = textByKey.get(key);
+				if (existing == null) {
+					if (fullText.length > 0) {
+						const state = ensureTextState(key);
+						state.emitted = fullText;
+						q.push(makeTextDelta(state.index, fullText));
+						closeCurrent();
+					}
+				} else if (currentKind() === "text" && currentIndex() === existing.index) {
+					if (fullText.length > existing.emitted.length && fullText.startsWith(existing.emitted)) {
+						q.push(makeTextDelta(existing.index, fullText.slice(existing.emitted.length)));
+						existing.emitted = fullText;
+					}
+					closeCurrent();
+				}
+				break;
+			}
+			case "response.reasoning_summary_text.delta":
+			case "response.reasoning_text.delta": {
+				const d = ev.delta;
+				if (typeof d !== "string" || d.length === 0) break;
+				const key = responsesKey(ev.output_index, ev.item_id) ?? "reasoning";
+				q.push(makeThinkingDelta(ensureThinking(key), d));
+				break;
+			}
+			case "response.reasoning_summary_text.done":
+			case "response.reasoning_text.done": break;
+			case "response.output_item.added": {
+				const item = ev.item;
+				if (item?.type === "function_call") {
+					const key = responsesKey(ev.output_index, item.id);
+					if (key == null || toolByKey.has(key)) break;
+					const toolId = firstNonEmpty(item.call_id, item.id);
+					toolByKey.set(key, {
+						id: toolId.length > 0 ? toolId : makeToolUseId(),
+						name: item.name ?? "",
+						argsBuffer: "",
+						emitted: false
+					});
+					sawTool = true;
+				}
+				break;
+			}
+			case "response.function_call_arguments.delta": {
+				const key = responsesKey(ev.output_index, ev.item_id);
+				if (key == null) break;
+				const t = toolByKey.get(key);
+				if (!t || t.emitted) break;
+				const d = ev.delta;
+				if (typeof d !== "string" || d.length === 0) break;
+				t.argsBuffer += d;
+				break;
+			}
+			case "response.function_call_arguments.done": {
+				const key = responsesKey(ev.output_index, ev.item_id);
+				if (key == null) break;
+				const t = toolByKey.get(key);
+				if (!t || t.emitted) break;
+				if (typeof ev.arguments === "string") t.argsBuffer = ev.arguments;
+				break;
+			}
+			case "response.output_item.done": {
+				const item = ev.item;
+				if (item?.type === "function_call") {
+					const key = responsesKey(ev.output_index, item.id);
+					if (key == null) break;
+					const t = toolByKey.get(key);
+					if (!t || t.emitted) break;
+					const doneId = firstNonEmpty(item.call_id, item.id);
+					if (doneId.length > 0) t.id = doneId;
+					if (typeof item.name === "string" && item.name.length > 0) t.name = item.name;
+					if (typeof item.arguments === "string") t.argsBuffer = item.arguments;
+					emitTool(t);
+				} else if (item?.type === "reasoning") {
+					const key = responsesKey(ev.output_index, item.id);
+					const idx = key != null ? thinkingByKey.get(key) : void 0;
+					if (idx != null && currentKind() === "thinking" && currentIndex() === idx) {
+						if (typeof item.encrypted_content === "string" && item.encrypted_content.length > 0) q.push(makeSignatureDelta(idx, item.encrypted_content));
+						closeCurrent();
+					}
+				}
+				break;
+			}
+			case "response.completed":
+			case "response.incomplete": {
+				sawTerminal = true;
+				const u = ev.response?.usage;
+				if (u) {
+					usageIn = Math.max(usageIn, u.input_tokens ?? 0);
+					usageOut = Math.max(usageOut, u.output_tokens ?? 0);
+					usageCacheRead = Math.max(usageCacheRead, u.input_tokens_details?.cached_tokens ?? 0);
+				}
+				if (ev.type === "response.incomplete" && ev.response?.incomplete_details?.reason === "max_output_tokens") hitMaxTokens = true;
+				break;
+			}
+			case "response.failed": throw new Error(ev.response?.error?.message ?? "response.failed");
+		}
+		for (const e of q) yield e;
+		q.length = 0;
+	}
+	if (!sawTerminal) throw new Error("responses stream ended without a terminal event (truncated)");
+	closeCurrent();
+	for (const t of toolByKey.values()) if (!t.emitted) emitTool(t);
+	const stopReason = hitMaxTokens ? "max_tokens" : sawTool ? "tool_use" : "end_turn";
+	q.push(makeMessageDelta(stopReason, null, {
+		input_tokens: usageIn,
+		output_tokens: usageOut,
+		cache_read_input_tokens: usageCacheRead,
+		cache_creation_input_tokens: 0
+	}));
+	q.push(makeMessageStop());
+	for (const e of q) yield e;
+	q.length = 0;
+}
+//#endregion
+//#region src/lib/anthropic-translate/classifier.ts
+/**
+* Routing classifier for `POST /v1/messages`.
+*
+* Claude Code speaks the Anthropic Messages wire format. Copilot only serves
+* Claude models on its native `/v1/messages` endpoint; a gpt/gemini request
+* sent there 400s. This classifier decides, from the RESOLVED model id and its
+* catalog metadata, whether a request stays on the native passthrough
+* (`createMessages`) or is diverted to the translation shim.
+*
+* Non-regression is the whole point — every Claude model (opus / sonnet / haiku /
+* any `claude-*` or Anthropic-vendored id) MUST return "claude-passthrough" so
+* its bytes reach `createMessages` unchanged — even if future catalog metadata
+* were to (wrongly) advertise a `/responses` endpoint for it. The Claude check
+* is therefore keyed off identity (id / vendor / family), NOT the endpoint.
+*
+* Non-Claude models are diverted to the translation shim by the endpoint the
+* catalog says they serve: `/responses` models (gpt-5.5, gpt-5.3-codex, …) take
+* the Responses path (`responses-shim`), `/chat/completions` models (gemini,
+* and any chat-default model) take the chat path (`chat-shim`). The decision is
+* derived from `pickEndpoint` (catalog `supported_endpoints`), never a
+* hardcoded slug list, so it generalizes. Copilot only serves Claude models on
+* its native `/v1/messages`, so diverting every non-Claude model to a shim is
+* correct — a non-Claude request sent to `/v1/messages` would 400.
+*/
+/**
+* Match "claude"/"anthropic" as a delimiter-bounded segment anywhere in a model
+* id: at the start, or after a `/ _ . : -` path/version delimiter, and followed
+* by end-of-string, another such delimiter, or a digit. This catches catalog
+* aliases like `github/claude-3-7-sonnet` or `anthropic/…` whose vendor is
+* "github" and whose family is empty — where the token only surfaces mid-id —
+* while NOT firing on incidental substrings like `notclaude`. Deliberately
+* over-inclusive at the boundaries: we fail CLOSED toward Claude (→ passthrough)
+* so a real Claude model can never be diverted to the non-Claude shim.
+*/
+const CLAUDE_ID_RE = /(^|[/_.:-])(claude|anthropic)(?=$|[/_.:-]|\d)/i;
+/**
+* True when the target is a Claude / Anthropic model. Matches on any of:
+* catalog vendor containing "anthropic", capability family containing "claude",
+* or a Claude/anthropic path-segment (see `CLAUDE_ID_RE`) in ANY id we hold —
+* the resolved id (`modelId`), the pre-resolution request id (`originalModelId`),
+* or the catalog entry's own id (`model.id`). Conservative by design: when in
+* doubt it returns true so a Claude request can never be diverted to the shim.
+*/
+function isClaudeModel(modelId, model, originalModelId) {
+	if (model) {
+		if ((model.vendor?.toLowerCase() ?? "").includes("anthropic")) return true;
+		if ((model.capabilities?.family?.toLowerCase() ?? "").includes("claude")) return true;
+	}
+	return [
+		modelId,
+		originalModelId,
+		model?.id
+	].some((id) => typeof id === "string" && CLAUDE_ID_RE.test(id));
+}
+/**
+* Decide the route for a resolved model id + its catalog entry.
+*
+* - No model id, or a Claude model → "claude-passthrough" (existing behaviour).
+* - A non-Claude model whose catalog endpoint is `/responses` → "responses-shim".
+* - A non-Claude model whose catalog endpoint is `/chat/completions` (gemini and
+*   any chat-default model) → "chat-shim".
+* - A non-Claude model absent from the catalog (so we can't confirm an endpoint)
+*   → "claude-passthrough" (unchanged; we don't divert what we can't classify).
+* - A non-Claude model that IS in the catalog and serves NEITHER of the two shim
+*   endpoints (`pickEndpoint` → undefined) → "claude-passthrough" as well.
+*
+* Those last two land on the same route but are NOT the same answer, and the
+* coincidence is deliberate rather than a collapsed default (contrast
+* `resolveEndpointForModelId`, whose callers must tell them apart because
+* guessing there produces an opaque upstream 400). Here neither shim is even a
+* candidate: a shim can only speak `/responses` or `/chat/completions`, so
+* diverting a model that serves neither would 400 just as surely. Passthrough
+* is the better default because it is sometimes RIGHT — a non-Claude catalog
+* model advertising `/v1/messages` is served by exactly the endpoint
+* passthrough uses. It also preserves this module's fail-CLOSED-toward-Claude
+* invariant: an unclassifiable model is never diverted.
+*
+* KNOWN GAP (audited, deliberately not fixed here): a non-Claude model serving
+* only something we cannot speak at all (say `/embeddings`) also lands on
+* passthrough and will still 400 upstream — `logEndpointMismatch(modelId,
+* "/v1/messages")` logs it at the passthrough seam, but no local error is
+* raised. Closing that needs a change in `src/routes/messages/handler.ts`,
+* which this seam does not own. It is strictly narrower than the defect fixed
+* in `resolveEndpointForModelId`: no such model is reachable as a Claude Code
+* `/v1/messages` target today, whereas the plan worker's `claude-opus-5`
+* default is.
+*
+* `originalModelId` is the optional pre-resolution request id; when supplied it
+* is checked for Claude-likeness alongside the resolved id so an alias that
+* resolves to a non-Claude-looking id can't slip past.
+*/
+function classifyMessagesRoute(modelId, model, originalModelId) {
+	if (!modelId) return "claude-passthrough";
+	if (isClaudeModel(modelId, model, originalModelId)) return "claude-passthrough";
+	if (!model) return "claude-passthrough";
+	const endpoint = pickEndpoint(model);
+	if (endpoint === "responses") return "responses-shim";
+	if (endpoint === "chat") return "chat-shim";
+	return "claude-passthrough";
+}
+//#endregion
+//#region src/lib/anthropic-translate/index.ts
+const STREAM_HEADERS = {
+	"content-type": "text/event-stream",
+	"cache-control": "no-cache",
+	"transfer-encoding": "chunked",
+	connection: "keep-alive"
+};
+function isAsyncIterable(x) {
+	return x != null && typeof x[Symbol.asyncIterator] === "function";
+}
+/**
+* Handle a `/v1/messages` request targeting a non-Claude `/responses` model.
+* Returns a streaming or non-streaming Anthropic-format Response. Upstream
+* non-2xx / abort errors are thrown (as HTTPError) and handled by the route's
+* `forwardError`, exactly like the passthrough path.
+*/
+async function handleNonClaudeResponses(c, opts) {
+	const routePath = c.req.path;
+	let body;
+	try {
+		body = JSON.parse(opts.rawBody);
+	} catch {
+		return c.json({
+			type: "error",
+			error: {
+				type: "invalid_request_error",
+				message: "Request body is not valid JSON"
+			}
+		}, 400);
+	}
+	const parsed = parseAnthropicRequest(body, opts.modelId, opts.model);
+	const payload = parsedToResponsesPayload(parsed);
+	if (consola.level >= 4) consola.debug(`Anthropic-translate → /responses model=${opts.modelId} stream=${parsed.stream} tools=${parsed.tools?.length ?? 0} effort=${parsed.reasoningEffort ?? "none"}`);
+	if (parsed.stream) {
+		const aborter = new AbortController();
+		const result = await createResponses(payload, opts.model?.requestHeaders, aborter.signal, true);
+		if (!isAsyncIterable(result)) throw new Error("Upstream /responses did not return an SSE stream (stream: true expected)");
+		logRequest({
+			method: "POST",
+			path: routePath,
+			model: opts.originalModel,
+			resolvedModel: opts.modelId,
+			status: 200,
+			streaming: true
+		}, opts.model, opts.startTime);
+		const stream = anthropicSseStreamFromEvents(synthAnthropicFromResponses(result, { modelId: opts.modelId }), {
+			routePath,
+			onCancel: () => aborter.abort()
+		});
+		return new Response(stream, {
+			status: 200,
+			headers: STREAM_HEADERS
+		});
+	}
+	const anthropic = responsesResponseToAnthropicMessage(await createResponses(payload, opts.model?.requestHeaders, void 0, true), opts.modelId);
+	logRequest({
+		method: "POST",
+		path: routePath,
+		model: opts.originalModel,
+		resolvedModel: opts.modelId,
+		inputTokens: anthropic.usage.input_tokens,
+		outputTokens: anthropic.usage.output_tokens,
+		status: 200
+	}, opts.model, opts.startTime);
+	return c.json(anthropic, 200);
+}
+/**
+* Handle a `/v1/messages` request targeting a non-Claude `/chat/completions`
+* model (gemini). Twin of `handleNonClaudeResponses` — same lifecycle, abort,
+* and logging contract, but assembles a chat/completions payload and translates
+* the chat response (object or SSE) back to the Anthropic wire shape.
+*/
+async function handleNonClaudeChat(c, opts) {
+	const routePath = c.req.path;
+	let body;
+	try {
+		body = JSON.parse(opts.rawBody);
+	} catch {
+		return c.json({
+			type: "error",
+			error: {
+				type: "invalid_request_error",
+				message: "Request body is not valid JSON"
+			}
+		}, 400);
+	}
+	const parsed = parseAnthropicRequest(body, opts.modelId, opts.model);
+	const payload = parsedToChatPayload(parsed);
+	if (consola.level >= 4) consola.debug(`Anthropic-translate → /chat/completions model=${opts.modelId} stream=${parsed.stream} tools=${parsed.tools?.length ?? 0} effort=${parsed.reasoningEffort ?? "none"}`);
+	if (parsed.stream) {
+		const aborter = new AbortController();
+		const result = await createChatCompletions(payload, opts.model?.requestHeaders, aborter.signal, true);
+		if (!isAsyncIterable(result)) throw new Error("Upstream /chat/completions did not return an SSE stream (stream: true expected)");
+		logRequest({
+			method: "POST",
+			path: routePath,
+			model: opts.originalModel,
+			resolvedModel: opts.modelId,
+			status: 200,
+			streaming: true
+		}, opts.model, opts.startTime);
+		const stream = anthropicSseStreamFromEvents(synthAnthropicFromChat(result, { modelId: opts.modelId }), {
+			routePath,
+			onCancel: () => aborter.abort()
+		});
+		return new Response(stream, {
+			status: 200,
+			headers: STREAM_HEADERS
+		});
+	}
+	const anthropic = chatResponseToAnthropicMessage(await createChatCompletions(payload, opts.model?.requestHeaders, void 0, true), opts.modelId);
+	logRequest({
+		method: "POST",
+		path: routePath,
+		model: opts.originalModel,
+		resolvedModel: opts.modelId,
+		inputTokens: anthropic.usage.input_tokens,
+		outputTokens: anthropic.usage.output_tokens,
+		status: 200
+	}, opts.model, opts.startTime);
+	return c.json(anthropic, 200);
+}
+//#endregion
+//#region src/routes/messages/handler.ts
+const isWebSearchTool$1 = (tool) => !!tool && typeof tool === "object" && (typeof tool.type === "string" && tool.type.startsWith("web_search") || tool.name === "web_search");
+/**
+* Extract whitelisted beta headers from the incoming request to forward
+* to the Copilot API. VS Code sends these to enable extended features
+* like thinking, context management, and advanced tool use.
+*/
+function extractBetaHeaders(c) {
+	const headers = {};
+	const anthropicBeta = c.req.header("anthropic-beta");
+	if (anthropicBeta) {
+		const filtered = filterBetaHeader(anthropicBeta);
+		if (filtered) headers["anthropic-beta"] = filtered;
+	}
+	return headers;
+}
+/**
+* Extract the text content from the last user message for web search.
+* Handles both string content and content block arrays (multimodal).
+*/
+function extractUserQuery$1(messages) {
+	for (let i = messages.length - 1; i >= 0; i--) {
+		const msg = messages[i];
+		if (msg.role === "user") {
+			if (typeof msg.content === "string") return msg.content;
+			if (Array.isArray(msg.content)) {
+				const textBlock = msg.content.find((block) => block.type === "text");
+				if (textBlock?.text) return textBlock.text;
+			}
+		}
+	}
+}
+/**
+* Check if any user message contains tool_result content blocks,
+* indicating a follow-up turn where we should skip web search.
+* In Anthropic format, tool results are content blocks inside user messages,
+* NOT separate role: "tool" messages like in OpenAI format.
+*/
+function hasToolResultContent(messages) {
+	return messages.some((msg) => Array.isArray(msg.content) && msg.content.some((block) => block.type === "tool_result"));
+}
+/**
+* Inject web search results into the Anthropic system field.
+* Handles three cases: absent, string, or array of content blocks.
+* When array, prepends without cache_control to preserve existing directives.
+*/
+function injectSearchResults(body, searchContext) {
+	if (body.system === void 0 || body.system === null) body.system = searchContext;
+	else if (typeof body.system === "string") body.system = `${searchContext}\n\n${body.system}`;
+	else if (Array.isArray(body.system)) body.system = [{
+		type: "text",
+		text: searchContext
+	}, ...body.system];
+}
+/**
+* Strip web_search tools from the request and clean up tool_choice.
+* Returns the modified body object.
+*/
+function stripWebSearchTool(body) {
+	if (!body.tools) return;
+	const tools = body.tools.filter((tool) => !isWebSearchTool$1(tool));
+	body.tools = tools;
+	if (tools.length === 0) {
+		body.tools = void 0;
+		body.tool_choice = void 0;
+	} else if (body.tool_choice && typeof body.tool_choice === "object" && body.tool_choice.type === "tool") {
+		const choiceName = body.tool_choice.name;
+		if (choiceName && !tools.some((tool) => tool && typeof tool === "object" && tool.name === choiceName)) body.tool_choice = { type: "auto" };
+	}
+}
+/**
+* Strip the injected `__anthropic_advisor` tool (and any Anthropic-native
+* `advisor_*` typed tool) from a request body. Used ONLY on the non-Claude
+* shim path: ADVISOR's server-side translate-loop (buildAdvisorStream) lives
+* on the native /v1/messages route, so a non-Claude model has no handler for
+* the tool and it must be removed before forwarding — otherwise the model
+* could emit a tool_use that nothing fulfils. Mirrors stripWebSearchTool's
+* tool_choice cleanup. Returns the original string (same reference) when
+* nothing was removed.
+*/
+function stripAdvisorTool(rawBody) {
+	let body;
+	try {
+		body = JSON.parse(rawBody);
+	} catch {
+		return rawBody;
+	}
+	if (!Array.isArray(body.tools)) return rawBody;
+	const original = body.tools;
+	const tools = original.filter((tool) => {
+		if (typeof tool !== "object" || tool === null) return true;
+		if (tool.name === "__anthropic_advisor") return false;
+		const type = tool.type;
+		return typeof type !== "string" || !type.startsWith("advisor_");
+	});
+	if (tools.length === original.length) return rawBody;
+	if (tools.length === 0) {
+		body.tools = void 0;
+		body.tool_choice = void 0;
+	} else {
+		body.tools = tools;
+		if (body.tool_choice && typeof body.tool_choice === "object" && body.tool_choice.type === "tool") {
+			const choiceName = body.tool_choice.name;
+			if (choiceName && !tools.some((tool) => tool && typeof tool === "object" && tool.name === choiceName)) body.tool_choice = { type: "auto" };
+		}
+	}
+	return JSON.stringify(body);
+}
+/**
+* Process web search if the request contains a web_search tool.
+* Performs the search, injects results into system, and strips the tool.
+* Returns the (possibly modified) body string to forward.
+*/
+async function processWebSearch(rawBody) {
+	if (!rawBody.includes("web_search")) return rawBody;
+	let body;
+	try {
+		body = JSON.parse(rawBody);
+	} catch {
+		return rawBody;
+	}
+	if (!body.tools?.some((tool) => isWebSearchTool$1(tool))) return rawBody;
+	const messages = body.messages ?? [];
+	const query = hasToolResultContent(messages) ? void 0 : extractUserQuery$1(messages);
+	if (query) try {
+		const results = await searchWeb(query);
+		const searchContext = [
+			"[Web Search Results]",
+			results.content,
+			"",
+			results.references.map((r) => `- [${r.title}](${r.url})`).join("\n"),
+			"[End Web Search Results]"
+		].join("\n");
+		injectSearchResults(body, searchContext);
+	} catch (error) {
+		consola.warn("Web search failed, continuing without results:", error);
+	}
+	stripWebSearchTool(body);
+	return JSON.stringify(body);
+}
+async function handleCompletion(c) {
+	const startTime = Date.now();
+	await checkRateLimit(state);
+	const rawBody = await c.req.text();
+	const debugEnabled = consola.level >= 4;
+	if (debugEnabled) consola.debug("Anthropic request body:", rawBody.slice(0, 2e3));
+	if (process.env.GH_ROUTER_LOG_FIELDS === "1") {
+		let parsedForLog = void 0;
+		try {
+			parsedForLog = JSON.parse(rawBody);
+		} catch {}
+		logRequestFields({
+			path: c.req.path,
+			body: parsedForLog,
+			betaHeader: c.req.header("anthropic-beta"),
+			agentId: c.req.header("x-claude-code-agent-id")
+		});
+	}
+	if (state.manualApprove) await awaitApproval();
+	const betaHeaders = extractBetaHeaders(c);
+	const incomingBeta = c.req.header("anthropic-beta");
+	const advisorEnabled = isAdvisorRequested(incomingBeta);
+	let finalBody = await processWebSearch(rawBody);
+	finalBody = sanitizeAnthropicBody(finalBody);
+	if (advisorEnabled) {
+		finalBody = injectAdvisorTool(finalBody);
+		consola.info("ADVISOR enabled for this request — injecting __anthropic_advisor tool; will translate tool_use → server_tool_use{advisor} on the SSE stream");
+	}
+	if (finalBody.includes("\"mcp_servers\"")) try {
+		const probe = JSON.parse(finalBody);
+		if (Array.isArray(probe.mcp_servers) && probe.mcp_servers.length > 0) return c.json({
+			type: "error",
+			error: {
+				type: "invalid_request_error",
+				message: "Inline `mcp_servers` body field is not supported by github-router. Configure remote MCP servers as local stdio entries in `~/.claude/mcp.json` instead — Claude Code will spawn them locally and the proxy passes their tool calls through transparently. (https://docs.claude.com/en/docs/claude-code/mcp)"
+			}
+		}, 400);
+	} catch {}
+	const { body: resolvedBody, originalModel, resolvedModel, selectedModel } = resolveModelInBody$1(finalBody);
+	const modelId = resolvedModel ?? originalModel;
+	const messagesRoute = classifyMessagesRoute(modelId, selectedModel, originalModel);
+	if (messagesRoute !== "claude-passthrough") {
+		const shimBody = stripAdvisorTool(resolvedBody);
+		if (advisorEnabled) consola.info("ADVISOR requested with a non-Claude model — stripping the injected __anthropic_advisor tool and proceeding without advisor (Claude-only feature; gracefully degraded).");
+		const shimOpts = {
+			rawBody: shimBody,
+			modelId,
+			model: selectedModel,
+			originalModel,
+			startTime
+		};
+		return messagesRoute === "chat-shim" ? handleNonClaudeChat(c, shimOpts) : handleNonClaudeResponses(c, shimOpts);
+	}
+	if (modelId) logEndpointMismatch(modelId, "/v1/messages");
+	const effectiveBetas = applyDefaultBetas(betaHeaders, resolvedModel ?? originalModel);
+	const advisorAborter = advisorEnabled ? new AbortController() : void 0;
+	let response;
+	try {
+		response = await createMessages(resolvedBody, {
+			...selectedModel?.requestHeaders,
+			...effectiveBetas
+		}, advisorAborter?.signal, true);
+	} catch (error) {
+		if (error instanceof HTTPError) {
+			const errorBody = await error.response.clone().text().catch(() => "");
+			logRequest({
+				method: "POST",
+				path: c.req.path,
+				model: originalModel,
+				resolvedModel,
+				status: error.response.status,
+				errorBody
+			}, selectedModel, startTime);
+		}
+		throw error;
+	}
+	const contentType = response.headers.get("content-type") ?? "";
+	const clientAcceptsSSE = (c.req.header("accept") ?? "").includes("text/event-stream");
+	let isStreaming = contentType.includes("text/event-stream");
+	if (!isStreaming && clientAcceptsSSE) {
+		if (contentType === "" || contentType === "application/octet-stream") {
+			consola.warn(`Upstream /v1/messages returned status=${response.status} content-type=${JSON.stringify(contentType)} but client requested streaming; treating response body as SSE`);
+			isStreaming = true;
+		}
+	}
+	if (debugEnabled) consola.debug(`Upstream /v1/messages: status=${response.status} content-type="${contentType}" isStreaming=${isStreaming}`);
+	if (isStreaming) {
+		logRequest({
+			method: "POST",
+			path: c.req.path,
+			model: originalModel,
+			resolvedModel,
+			status: response.status,
+			streaming: true
+		}, selectedModel, startTime);
+		if (debugEnabled) consola.debug("Streaming response from Copilot /v1/messages");
+		const streamHeaders = {
+			"content-type": "text/event-stream",
+			"cache-control": "no-cache",
+			"transfer-encoding": "chunked",
+			connection: "keep-alive"
+		};
+		const requestId = response.headers.get("x-request-id");
+		if (requestId) streamHeaders["x-request-id"] = requestId;
+		const reqId = response.headers.get("request-id");
+		if (reqId) streamHeaders["request-id"] = reqId;
+		if (advisorEnabled && response.body) {
+			let parsedBase = {};
+			try {
+				parsedBase = JSON.parse(resolvedBody);
+			} catch {}
+			const initialConversation = Array.isArray(parsedBase.messages) ? parsedBase.messages : [];
+			return new Response(buildAdvisorStream({
+				firstResponse: response,
+				initialConversation,
+				baseBody: parsedBase,
+				requestHeaders: {
+					...selectedModel?.requestHeaders,
+					...effectiveBetas
+				},
+				externalAborter: advisorAborter
+			}), {
+				status: response.status,
+				headers: streamHeaders
+			});
+		}
+		return new Response(response.body ? relayAnthropicStream(response.body, { routePath: c.req.path }) : null, {
+			status: response.status,
+			headers: streamHeaders
+		});
+	}
+	const cappedResult = await readResponseBodyCapped(response, c.req.path, MAX_RESPONSE_BODY_BYTES);
+	if (!cappedResult.ok) return c.json(cappedResult.errorResponse, cappedResult.status);
+	const responseBody = cappedResult.value;
+	const usage = responseBody.usage;
+	logRequest({
+		method: "POST",
+		path: c.req.path,
+		model: originalModel,
+		resolvedModel,
+		inputTokens: usage?.input_tokens,
+		outputTokens: usage?.output_tokens,
+		status: response.status
+	}, selectedModel, startTime);
+	if (debugEnabled) consola.debug("Non-streaming response from Copilot /v1/messages:", JSON.stringify(responseBody).slice(0, 2e3));
+	const xRequestId = response.headers.get("x-request-id");
+	if (xRequestId) c.header("x-request-id", xRequestId);
+	const requestIdHeader = response.headers.get("request-id");
+	if (requestIdHeader) c.header("request-id", requestIdHeader);
+	return c.json(responseBody, response.status);
+}
+/**
+* Parse the JSON body, resolve the model name, sanitize cache_control
+* fields, translate thinking-mode shape for adaptive-thinking models,
+* and re-serialize. Returns the body string, original/resolved model
+* names, and the matching model metadata (if any).
+*
+* Re-serialization is skipped when no modifications are needed.
+*/
+function resolveModelInBody$1(rawBody) {
+	let parsed;
+	try {
+		parsed = JSON.parse(rawBody);
+	} catch {
+		return { body: rawBody };
+	}
+	const originalModel = typeof parsed.model === "string" ? parsed.model : void 0;
+	let modified = false;
+	if (originalModel) {
+		const resolved = resolveModel(originalModel);
+		if (resolved !== originalModel) {
+			parsed.model = resolved;
+			modified = true;
+		}
+	}
+	const resolvedModel = typeof parsed.model === "string" ? parsed.model : originalModel;
+	const selectedModel = resolvedModel ? state.models?.data.find((m) => m.id === resolvedModel) : void 0;
+	if (translateThinking(parsed, selectedModel)) modified = true;
+	if (clampOutputConfigEffortInPlace(parsed, selectedModel)) modified = true;
+	if (rawBody.includes("\"scope\"") && sanitizeCacheControl$1(parsed)) modified = true;
+	if ((rawBody.includes("\"budget\"") || rawBody.includes("\"output_config\"") || rawBody.includes("\"betas\"") || rawBody.includes("\"eager_input_streaming\"")) && stripAnthropicOnlyFields$1(parsed)) modified = true;
+	return {
+		body: modified ? JSON.stringify(parsed) : rawBody,
+		originalModel,
+		resolvedModel,
+		selectedModel
+	};
+}
+/**
+* Clamp `body.output_config.effort` to the model's
+* `capabilities.supports.reasoning_effort` allowlist. Mutates `body`
+* in place. Returns true iff a clamp was applied.
+*
+* Sibling to `translateThinking`'s internal clamp — that one only fires
+* when the request arrives in the Anthropic `thinking:{type:"enabled"}`
+* shape (which the translator converts into `output_config.effort`).
+* Requests that arrive ALREADY in Copilot shape (`output_config.effort`
+* set by the client) would otherwise pass through unclamped and 400 at
+* upstream — the failure mode is exactly the one Claude Code agent-teams
+* teammates hit on opus-4.8 with `xhigh` effort (Copilot rejects with
+* "output_config.effort 'xhigh' is not supported by model
+* claude-opus-4.8; supported values: [medium]").
+*
+* Generic policy: the proxy does not forward a value upstream rejects.
+* If the model declares a `reasoning_effort` allowlist and the
+* client-supplied `output_config.effort` is not in it, clamp via
+* `clampEffort` (using `EFFORT_ORDER` bucketing). Unknown effort
+* values fall through to `clampEffort`'s "no closer tier" branch
+* (returns the original); the model would then 400 at upstream, which
+* is the right behaviour for genuinely invalid input.
+*
+* No-ops when:
+*   - The model has no `reasoning_effort` allowlist (some models
+*     accept arbitrary efforts; treat absent allowlist as "any
+*     accepted")
+*   - `body.output_config` is missing or not a plain object
+*   - `body.output_config.effort` is missing or not a string
+*   - The current effort is already in the allowlist (no-op clamp)
+*/
+function clampOutputConfigEffortInPlace(body, model) {
+	if (!model?.capabilities?.supports?.reasoning_effort) return false;
+	const supported = model.capabilities.supports.reasoning_effort;
+	if (!Array.isArray(supported) || supported.length === 0) return false;
+	if (!body.output_config || typeof body.output_config !== "object") return false;
+	const oc = body.output_config;
+	const current = oc.effort;
+	if (typeof current !== "string") return false;
+	if (supported.includes(current)) return false;
+	const clamped = clampEffort(EFFORT_ORDER.includes(current) ? current : "xhigh", supported);
+	if (clamped === current) return false;
+	oc.effort = clamped;
+	return true;
+}
+/**
+* Translate Anthropic-shape `thinking:{type:"enabled", budget_tokens}` to
+* Copilot-shape `thinking:{type:"adaptive"}` + `output_config.effort`
+* when the resolved model declares `adaptive_thinking: true`.
+*
+* Returns true if the body was modified. No-op when the model doesn't
+* support adaptive thinking, when thinking is missing/disabled/already
+* adaptive, or when `body` isn't a plain object. Client-supplied
+* `output_config.effort` always wins over the bucketed value.
+*/
+function translateThinking(body, model) {
+	if (!model?.capabilities?.supports?.adaptive_thinking) return false;
+	const thinking = body.thinking;
+	if (!thinking || typeof thinking !== "object") return false;
+	const t = thinking;
+	if (t.type !== "enabled") return false;
+	const bucketed = bucketEffort(t.budget_tokens);
+	const supported = model.capabilities.supports.reasoning_effort;
+	const effort = Array.isArray(supported) && supported.length > 0 ? clampEffort(bucketed, supported) : bucketed;
+	body.thinking = { type: "adaptive" };
+	const existing = body.output_config && typeof body.output_config === "object" ? body.output_config : {};
+	body.output_config = {
+		...existing,
+		effort: existing.effort ?? effort
+	};
+	return true;
+}
+/**
+* Strip the `scope` field from all `cache_control` objects in the body.
+* Claude CLI 2.1.88+ sends {"type":"ephemeral","scope":"global"} which
+* Copilot rejects. Mutates the parsed object in place.
+*
+* Covers: system blocks, message content blocks (including nested
+* tool_result content), and tool definitions.
+*/
+function sanitizeCacheControl$1(body) {
+	let stripped = false;
+	function stripScope(block) {
+		const cc = block.cache_control;
+		if (cc?.scope !== void 0) {
+			delete cc.scope;
+			if (Object.keys(cc).length === 0) delete block.cache_control;
+			stripped = true;
+		}
+	}
+	if (Array.isArray(body.system)) for (const block of body.system) stripScope(block);
+	if (Array.isArray(body.messages)) {
+		for (const msg of body.messages) if (Array.isArray(msg.content)) for (const block of msg.content) {
+			stripScope(block);
+			if (Array.isArray(block.content)) for (const nested of block.content) stripScope(nested);
+		}
+	}
+	if (Array.isArray(body.tools)) for (const tool of body.tools) stripScope(tool);
+	return stripped;
+}
+/**
+* Apply default anthropic-beta values for Claude models when the client
+* (e.g. curl) sends no beta headers. Claude CLI sends its own betas,
+* so this only fires as a safety net for bare clients.
+*/
+function applyDefaultBetas(betaHeaders, modelId) {
+	if (betaHeaders["anthropic-beta"]) return betaHeaders;
+	if (!modelId || !modelId.startsWith("claude-")) return betaHeaders;
+	return {
+		...betaHeaders,
+		"anthropic-beta": ["interleaved-thinking-2025-05-14", "context-management-2025-06-27"].join(",")
+	};
+}
+/**
+* Strip top-level body fields that Anthropic's Messages API accepts but
+* Copilot rejects with HTTP 400 "Extra inputs are not permitted". Mutates
+* `body` in place; returns true if anything was stripped.
+*
+* Empirical verification (2026-05-11):
+*   POST /v1/messages?beta=true { ..., budget: {total_tokens: 10000} } → 400
+*   POST /v1/messages?beta=true { ..., output_config: {schema: {...}} }  → 400
+*   POST /v1/messages?beta=true { ..., betas: ["..."] }                  → 400
+*
+* Each strip emits a one-line consola.warn so users running with these
+* features (e.g. `claude --max-budget-usd`, `--json-schema`) understand
+* the request succeeds with the *body field* dropped — semantics may
+* differ from upstream Anthropic. The corresponding `anthropic-beta`
+* header is preserved (Phase A allowlist) so the *intent* still flows
+* to Copilot, even if the per-request enforcement field is gone.
+*
+* NOT stripped here:
+*   - `mcp_servers` (Phase G translate path — silent strip causes LLM
+*     to hallucinate tools per gemini-critic finding)
+*   - `metadata` (Copilot 200s, ignores harmlessly)
+*/
+function stripAnthropicOnlyFields$1(body) {
+	let stripped = false;
+	if (body.budget !== void 0) {
+		consola.warn("Stripping body-level `budget` field (Copilot 400s; the `task-budgets-` beta header is preserved but cost ceiling is not enforced server-side)");
+		delete body.budget;
+		stripped = true;
+	}
+	if (body.output_config !== void 0) {
+		if (body.output_config && typeof body.output_config === "object") {
+			const oc = body.output_config;
+			const PROXY_OWNED_FIELDS = /* @__PURE__ */ new Set(["effort"]);
+			const schema = oc.schema;
+			const ocType = oc.type;
+			let strippedAny = false;
+			for (const key of Object.keys(oc)) if (!PROXY_OWNED_FIELDS.has(key)) {
+				delete oc[key];
+				strippedAny = true;
+			}
+			if (strippedAny) {
+				consola.warn("Stripping client-set `output_config` Structured-Outputs fields (Copilot 400s on `output_config.*` other than `effort`; injecting schema as system-prompt instruction so the model still produces JSON conforming to the structured-outputs schema, since server-side enforcement is gone)");
+				if (Object.keys(oc).length === 0) delete body.output_config;
+				if (schema !== void 0 || ocType === "json_object") appendStructuredOutputInstruction(body, schema, ocType);
+				stripped = true;
+			}
+		}
+	}
+	if (Array.isArray(body.betas)) {
+		consola.warn("Stripping body-level `betas` array (Copilot 400s; the betas are conveyed via the `anthropic-beta` header instead)");
+		delete body.betas;
+		stripped = true;
+	}
+	if (Array.isArray(body.tools)) {
+		let warnedFGTS = false;
+		for (const tool of body.tools) if (typeof tool === "object" && tool !== null) {
+			const t = tool;
+			if (t.eager_input_streaming !== void 0) {
+				delete t.eager_input_streaming;
+				stripped = true;
+				if (!warnedFGTS) {
+					consola.warn("Stripping per-tool `eager_input_streaming` field (Copilot 400s on `tools.*.custom.eager_input_streaming`; FGTS chunk-size optimization disabled, but streaming correctness is unaffected — `input_json_delta` events still flow normally)");
+					warnedFGTS = true;
+				}
+			}
+		}
+	}
+	return stripped;
+}
+/**
+* Append a system-prompt instruction telling the model to produce JSON
+* conforming to a Structured Outputs schema. Used after the proxy
+* strips `output_config` to preserve the schema enforcement intent
+* via prompt engineering instead of server-side validation.
+*
+* Mutates `body.system` in place. Handles both string and array shapes
+* (Anthropic spec allows either).
+*/
+function appendStructuredOutputInstruction(body, schema, ocType) {
+	let instruction = "\n\nIMPORTANT: Your response MUST be a single valid JSON object. Do not wrap it in markdown code fences. Do not include any text before or after the JSON object.";
+	if (schema !== void 0) instruction += ` The JSON object MUST conform to this JSON Schema:\n${JSON.stringify(schema)}`;
+	else if (typeof ocType === "string") instruction += ` Output type requested: ${ocType}.`;
+	if (typeof body.system === "string") body.system = body.system + instruction;
+	else if (Array.isArray(body.system)) body.system = [...body.system, {
+		type: "text",
+		text: instruction.trimStart()
+	}];
+	else body.system = instruction.trimStart();
+}
+//#endregion
+//#region src/routes/messages/count-tokens-handler.ts
+const isWebSearchTool = (tool) => typeof tool.type === "string" && tool.type.startsWith("web_search") || tool.name === "web_search";
+/**
+* Strip web_search tools from the request body before forwarding
+* to Copilot's count_tokens endpoint, which rejects unknown tool types.
+* Returns the original raw body if no web_search tools are present.
+*/
+function stripWebSearchFromBody(rawBody) {
+	if (!rawBody.includes("web_search")) return rawBody;
+	let body;
+	try {
+		body = JSON.parse(rawBody);
+	} catch {
+		return rawBody;
+	}
+	if (!body.tools?.some((tool) => isWebSearchTool(tool))) return rawBody;
+	body.tools = body.tools.filter((tool) => !isWebSearchTool(tool));
+	if (body.tools.length === 0) {
+		body.tools = void 0;
+		body.tool_choice = void 0;
+	} else if (body.tool_choice && typeof body.tool_choice === "object" && body.tool_choice.type === "tool") {
+		const choiceName = body.tool_choice.name;
+		if (choiceName && !body.tools.some((tool) => tool.name === choiceName)) body.tool_choice = { type: "auto" };
+	}
+	return JSON.stringify(body);
+}
+/**
+* Passthrough handler for Anthropic token counting.
+* Strips web_search tools and forwards beta headers to Copilot's
+* native /v1/messages/count_tokens endpoint.
+*/
+async function handleCountTokens(c) {
+	const startTime = Date.now();
+	const strippedBody = stripWebSearchFromBody(sanitizeAnthropicBody(await c.req.text()));
+	if (strippedBody.includes("\"mcp_servers\"")) try {
+		const probe = JSON.parse(strippedBody);
+		if (Array.isArray(probe.mcp_servers) && probe.mcp_servers.length > 0) return c.json({
+			type: "error",
+			error: {
+				type: "invalid_request_error",
+				message: "Inline `mcp_servers` body field is not supported by github-router. Configure remote MCP servers as local stdio entries in `~/.claude/mcp.json` instead."
+			}
+		}, 400);
+	} catch {}
+	const { body: finalBody, originalModel, resolvedModel } = resolveModelInBody(strippedBody);
+	const extraHeaders = {};
+	const anthropicBeta = c.req.header("anthropic-beta");
+	if (anthropicBeta) {
+		const filtered = filterBetaHeader(anthropicBeta);
+		if (filtered) extraHeaders["anthropic-beta"] = filtered;
+	}
+	const modelId = resolvedModel ?? originalModel;
+	const selectedModel = state.models?.data.find((m) => m.id === modelId);
+	const response = await countTokens(finalBody, {
+		...selectedModel?.requestHeaders,
+		...extraHeaders
+	}, void 0, true);
+	const responseBody = await parseJsonOrDiagnose(response, c.req.path);
+	logRequest({
+		method: "POST",
+		path: c.req.path,
+		model: originalModel,
+		resolvedModel,
+		inputTokens: responseBody.input_tokens,
+		status: response.status
+	}, selectedModel, startTime);
+	return c.json(responseBody);
+}
+/**
+* Parse the JSON body, resolve the model name, sanitize cache_control, and re-serialize.
+*/
+function resolveModelInBody(rawBody) {
+	let parsed;
+	try {
+		parsed = JSON.parse(rawBody);
+	} catch {
+		return { body: rawBody };
+	}
+	const originalModel = typeof parsed.model === "string" ? parsed.model : void 0;
+	let modified = false;
+	if (originalModel) {
+		const resolved = resolveModel(originalModel);
+		if (resolved !== originalModel) {
+			parsed.model = resolved;
+			modified = true;
+		}
+	}
+	if (rawBody.includes("\"scope\"") && sanitizeCacheControl(parsed)) modified = true;
+	if ((rawBody.includes("\"budget\"") || rawBody.includes("\"output_config\"") || rawBody.includes("\"betas\"") || rawBody.includes("\"eager_input_streaming\"")) && stripAnthropicOnlyFields(parsed)) modified = true;
+	const resolvedModel = typeof parsed.model === "string" ? parsed.model : originalModel;
+	const selectedModel = resolvedModel ? state.models?.data.find((m) => m.id === resolvedModel) : void 0;
+	if (selectedModel && clampOutputConfigEffortInPlace(parsed, selectedModel)) modified = true;
+	return {
+		body: modified ? JSON.stringify(parsed) : rawBody,
+		originalModel,
+		resolvedModel
+	};
+}
+function sanitizeCacheControl(body) {
+	let stripped = false;
+	function stripScope(block) {
+		if (block.cache_control?.scope !== void 0) {
+			delete block.cache_control.scope;
+			if (Object.keys(block.cache_control).length === 0) delete block.cache_control;
+			stripped = true;
+		}
+	}
+	if (Array.isArray(body.system)) for (const block of body.system) stripScope(block);
+	if (Array.isArray(body.messages)) {
+		for (const msg of body.messages) if (Array.isArray(msg.content)) for (const block of msg.content) {
+			stripScope(block);
+			if (Array.isArray(block.content)) for (const nested of block.content) stripScope(nested);
+		}
+	}
+	if (Array.isArray(body.tools)) for (const tool of body.tools) stripScope(tool);
+	return stripped;
+}
+/**
+* Strip top-level body fields Copilot 400s on (budget, output_config.schema,
+* betas). Duplicated structurally from handler.ts because count_tokens uses
+* its own JSON-pass; the bodies are independent. Behavior must stay in lock-
+* step with handler.ts's stripAnthropicOnlyFields — covered by integration
+* tests (Phase F P2.4).
+*/
+function stripAnthropicOnlyFields(body) {
+	let stripped = false;
+	if (body.budget !== void 0) {
+		consola.warn("[count_tokens] Stripping body-level `budget` field (Copilot 400s)");
+		delete body.budget;
+		stripped = true;
+	}
+	if (body.output_config !== void 0) {
+		if (body.output_config && typeof body.output_config === "object") {
+			const oc = body.output_config;
+			const PROXY_OWNED_FIELDS = /* @__PURE__ */ new Set(["effort"]);
+			let strippedAny = false;
+			for (const key of Object.keys(oc)) if (!PROXY_OWNED_FIELDS.has(key)) {
+				delete oc[key];
+				strippedAny = true;
+			}
+			if (strippedAny) {
+				consola.warn("[count_tokens] Stripping client-set `output_config` Structured-Outputs fields (Copilot 400s on `output_config.*` other than `effort`)");
+				if (Object.keys(oc).length === 0) delete body.output_config;
+				stripped = true;
+			}
+		}
+	}
+	if (Array.isArray(body.betas)) {
+		consola.warn("[count_tokens] Stripping body-level `betas` array (Copilot 400s; conveyed via header)");
+		delete body.betas;
+		stripped = true;
+	}
+	if (Array.isArray(body.tools)) {
+		let warnedFGTS = false;
+		for (const tool of body.tools) if (typeof tool === "object" && tool !== null) {
+			const t = tool;
+			if (t.eager_input_streaming !== void 0) {
+				delete t.eager_input_streaming;
+				stripped = true;
+				if (!warnedFGTS) {
+					consola.warn("[count_tokens] Stripping per-tool `eager_input_streaming` (Copilot 400s on `tools.*.custom.eager_input_streaming`)");
+					warnedFGTS = true;
+				}
+			}
+		}
+	}
+	return stripped;
+}
+//#endregion
+//#region src/routes/messages/route.ts
+const messageRoutes = new Hono();
+messageRoutes.post("/", async (c) => {
+	try {
+		return await handleCompletion(c);
+	} catch (error) {
+		return await forwardError(c, error);
+	}
+});
+messageRoutes.post("/count_tokens", async (c) => {
+	try {
+		return await handleCountTokens(c);
+	} catch (error) {
+		return await forwardError(c, error);
+	}
+});
+//#endregion
+//#region src/routes/models/route.ts
+const modelRoutes = new Hono();
+modelRoutes.get("/", async (c) => {
+	try {
+		if (!state.models) await cacheModels();
+		const models = state.models?.data.map((model) => {
+			const { requestHeaders, ...rest } = model;
+			return {
+				...rest,
+				object: "model",
+				type: model.capabilities?.type ?? "model",
+				created: 0,
+				created_at: (/* @__PURE__ */ new Date(0)).toISOString(),
+				owned_by: model.vendor,
+				display_name: model.name
+			};
+		});
+		return c.json({
+			object: "list",
+			data: models,
+			has_more: false
+		});
+	} catch (error) {
+		return await forwardError(c, error);
+	}
+});
+//#endregion
+//#region src/routes/responses/handler.ts
+const ENCODER = new TextEncoder();
+function formatSSE(chunk) {
+	const parts = [];
+	if (chunk.event) parts.push(`event: ${chunk.event}`);
+	if (chunk.data !== void 0) for (const line of String(chunk.data).split(/\r\n|\r|\n/)) parts.push(`data: ${line}`);
+	if (chunk.id !== void 0) parts.push(`id: ${String(chunk.id)}`);
+	return parts.join("\n") + "\n\n";
+}
+async function handleResponses(c) {
+	const startTime = Date.now();
+	await checkRateLimit(state);
+	const payload = await c.req.json();
+	const debugEnabled = consola.level >= 4;
+	if (debugEnabled) consola.debug("Responses request payload:", JSON.stringify(payload).slice(-400));
+	const originalModel = payload.model;
+	const resolvedModel = resolveModel(payload.model);
+	if (resolvedModel !== payload.model) payload.model = resolvedModel;
+	const selectedModel = state.models?.data.find((model) => model.id === payload.model);
+	logEndpointMismatch(payload.model, "/responses");
+	if (state.manualApprove) await awaitApproval();
+	await injectWebSearchIfNeeded(payload);
+	const response = await createResponses(payload, selectedModel?.requestHeaders, void 0, true).catch(async (error) => {
+		if (error instanceof HTTPError) {
+			const errorBody = await error.response.clone().text().catch(() => "");
+			logRequest({
+				method: "POST",
+				path: c.req.path,
+				model: originalModel,
+				resolvedModel,
+				status: error.response.status,
+				errorBody
+			}, selectedModel, startTime);
+		}
+		throw error;
+	});
+	const isStreaming = !isNonStreaming(response);
+	logRequest({
+		method: "POST",
+		path: c.req.path,
+		model: originalModel,
+		resolvedModel,
+		status: 200,
+		streaming: isStreaming
+	}, selectedModel, startTime);
+	if (!isStreaming) {
+		if (debugEnabled) consola.debug("Non-streaming response:", JSON.stringify(response));
+		return c.json(response);
+	}
+	const iterator = response[Symbol.asyncIterator]();
+	let firstChunk;
+	let upstreamFinished = false;
+	while (true) {
+		const r = await readIteratorWithTimeout(iterator, UPSTREAM_INACTIVITY_TIMEOUT_MS);
+		if (r.done) {
+			upstreamFinished = true;
+			break;
+		}
+		if (r.value === void 0 || r.value === null) continue;
+		if (r.value.data === "[DONE]") {
+			upstreamFinished = true;
+			break;
+		}
+		if (!r.value.data) continue;
+		firstChunk = r.value;
+		break;
+	}
+	if (firstChunk === void 0) consola.warn(`Upstream /responses returned no payload events at ${c.req.path}`);
+	let pendingFirstChunk = firstChunk;
+	let consumerCancelled = false;
+	const safeClose = (controller) => {
+		try {
+			controller.close();
+		} catch {}
+	};
+	const releaseUpstream = (reason) => {
+		if (typeof iterator.return === "function") iterator.return(reason).catch(() => {});
+	};
+	const safeEnqueue = (controller, bytes) => {
+		try {
+			controller.enqueue(bytes);
+			return true;
+		} catch (e) {
+			if (isControllerClosedError(e)) {
+				consumerCancelled = true;
+				releaseUpstream(e);
+				return false;
+			}
+			throw e;
+		}
+	};
+	return new Response(new ReadableStream({
+		async pull(controller) {
+			if (consumerCancelled || upstreamFinished) {
+				safeClose(controller);
+				return;
+			}
+			if (pendingFirstChunk !== void 0) {
+				const chunk = pendingFirstChunk;
+				pendingFirstChunk = void 0;
+				if (debugEnabled) consola.debug("Streaming chunk:", JSON.stringify(chunk));
+				safeEnqueue(controller, ENCODER.encode(formatSSE(chunk)));
+				return;
+			}
+			try {
+				const result = await readIteratorWithTimeout(iterator, UPSTREAM_INACTIVITY_TIMEOUT_MS);
+				if (consumerCancelled) {
+					safeClose(controller);
+					return;
+				}
+				if (result.done) {
+					upstreamFinished = true;
+					safeClose(controller);
+					return;
+				}
+				if (result.value === void 0 || result.value === null) return;
+				if (result.value.data === "[DONE]") {
+					upstreamFinished = true;
+					safeClose(controller);
+					return;
+				}
+				if (!result.value.data) return;
+				if (debugEnabled) consola.debug("Streaming chunk:", JSON.stringify(result.value));
+				safeEnqueue(controller, ENCODER.encode(formatSSE(result.value)));
+			} catch (error) {
+				upstreamFinished = true;
+				if (consumerCancelled) {
+					releaseUpstream(error);
+					safeClose(controller);
+					return;
+				}
+				const { errName, errMessage } = logStreamError(c.req.path, error);
+				safeEnqueue(controller, ENCODER.encode(buildOpenAIErrorEvent(errName, errMessage)));
+				releaseUpstream(error);
+				safeClose(controller);
+			}
+		},
+		cancel() {
+			consumerCancelled = true;
+			upstreamFinished = true;
+			releaseUpstream();
+		}
+	}), {
+		status: 200,
+		headers: {
+			"content-type": "text/event-stream",
+			"cache-control": "no-cache",
+			"transfer-encoding": "chunked",
+			connection: "keep-alive"
+		}
+	});
+}
+const isNonStreaming = (response) => Object.hasOwn(response, "output");
+async function injectWebSearchIfNeeded(payload) {
+	if (!payload.tools?.some((t) => t.type === "web_search")) return;
+	if (Array.isArray(payload.input)) {
+		if (payload.input.some((item) => item.type === "function_call_output")) return;
+	}
+	const query = extractUserQuery(payload.input);
+	if (query) try {
+		const results = await searchWeb(query);
+		const searchContext = [
+			"[Web Search Results]",
+			results.content,
+			"",
+			results.references.map((r) => `- [${r.title}](${r.url})`).join("\n"),
+			"[End Web Search Results]"
+		].join("\n");
+		payload.instructions = payload.instructions ? `${searchContext}\n\n${payload.instructions}` : searchContext;
+	} catch (error) {
+		consola.warn("Web search failed, continuing without results:", error);
+	}
+	payload.tools = payload.tools?.filter((t) => t.type !== "web_search");
+	if (payload.tools && payload.tools.length === 0) payload.tools = void 0;
+	if (!payload.tools) payload.tool_choice = void 0;
+	else if (payload.tool_choice && typeof payload.tool_choice === "object") {
+		const choice = payload.tool_choice;
+		if ((choice.function?.name ?? choice.name) === "web_search") payload.tool_choice = void 0;
+	}
+}
+function extractUserQuery(input) {
+	if (typeof input === "string") return input;
+	if (!Array.isArray(input)) return void 0;
+	for (let i = input.length - 1; i >= 0; i--) {
+		const item = input[i];
+		if ("role" in item && item.role === "user") {
+			if (typeof item.content === "string") return item.content;
+			if (Array.isArray(item.content)) {
+				const text = item.content.find((p) => p.type === "input_text");
+				if (text && "text" in text) return text.text;
+			}
+		}
+	}
+}
+/**
+* Compaction prompt used when GitHub Copilot API does not support
+* /responses/compact natively. Matches the prompt Codex CLI uses for
+* local (non-OpenAI) compaction.
+*/
+const COMPACTION_PROMPT = `You are performing a CONTEXT CHECKPOINT COMPACTION. Create a handoff summary for another LLM that will resume the task.
+
+Include:
+- Current progress and key decisions made
+- Important context, constraints, or user preferences
+- What remains to be done (clear next steps)
+- Any critical data, examples, or references needed to continue
+
+Be concise, structured, and focused on helping the next LLM seamlessly continue the work.`;
+async function handleResponsesCompact(c) {
+	const startTime = Date.now();
+	await checkRateLimit(state);
+	if (!state.copilotToken) throw new Error("Copilot token not found");
+	if (state.manualApprove) await awaitApproval();
+	const body = await c.req.json();
+	const compactUrl = `${copilotBaseUrl(state)}/responses/compact`;
+	const doFetch = () => fetch(compactUrl, {
+		method: "POST",
+		headers: copilotHeaders(state),
+		body: JSON.stringify(body),
+		signal: AbortSignal.timeout(UPSTREAM_FETCH_TIMEOUT_MS || 3e5)
+	});
+	const response = await fetchWithTransientRetry(() => tryRefreshAndRetry(doFetch, "/responses/compact"), { label: "/responses/compact" });
+	if (response.ok) {
+		logRequest({
+			method: "POST",
+			path: c.req.path,
+			status: 200
+		}, void 0, startTime);
+		return c.json(await response.json());
+	}
+	if (response.status === 404) {
+		consola.debug("Copilot API does not support /responses/compact, using synthetic compaction");
+		await response.body?.cancel().catch(() => {});
+		return await syntheticCompact(c, body, startTime);
+	}
+	logRequest({
+		method: "POST",
+		path: c.req.path,
+		status: response.status
+	}, void 0, startTime);
+	throw new HTTPError("Copilot responses/compact request failed", response);
+}
+/**
+* Synthetic compaction: sends the conversation history to Copilot's
+* regular /responses endpoint with a compaction prompt appended,
+* then returns the model's summary in the compact response format.
+*/
+async function syntheticCompact(c, body, startTime) {
+	const input = Array.isArray(body.input) ? [...body.input] : [];
+	input.push({
+		type: "message",
+		role: "user",
+		content: [{
+			type: "input_text",
+			text: COMPACTION_PROMPT
+		}]
+	});
+	const payload = {
+		model: body.model,
+		input,
+		instructions: body.instructions,
+		stream: false,
+		store: false
+	};
+	let result;
+	try {
+		result = await createResponses(payload, void 0, void 0, true);
+	} catch (error) {
+		if (error instanceof HTTPError) logRequest({
+			method: "POST",
+			path: c.req.path,
+			status: error.response.status
+		}, void 0, startTime);
+		throw error;
+	}
+	logRequest({
+		method: "POST",
+		path: c.req.path,
+		status: 200
+	}, void 0, startTime);
+	return c.json({
+		id: `resp_compact_${randomUUID().replace(/-/g, "").slice(0, 24)}`,
+		object: "response.compaction",
+		created_at: Math.floor(Date.now() / 1e3),
+		output: result.output,
+		usage: result.usage ?? {
+			input_tokens: 0,
+			output_tokens: 0,
+			total_tokens: 0
+		}
+	});
+}
+//#endregion
+//#region src/routes/responses/route.ts
+const responsesRoutes = new Hono();
+responsesRoutes.post("/", async (c) => {
+	try {
+		return await handleResponses(c);
+	} catch (error) {
+		return await forwardError(c, error);
+	}
+});
+responsesRoutes.post("/compact", async (c) => {
+	try {
+		return await handleResponsesCompact(c);
+	} catch (error) {
+		return await forwardError(c, error);
+	}
+});
+//#endregion
+//#region src/routes/search/route.ts
+const searchRoutes = new Hono();
+searchRoutes.post("/", async (c) => {
+	try {
+		const { query } = await c.req.json();
+		if (!query || typeof query !== "string") return c.json({ error: { message: "Missing required field: query" } }, 400);
+		const results = await searchWeb(query);
+		return c.json({ results });
+	} catch (error) {
+		return await forwardError(c, error);
+	}
+});
+//#endregion
+//#region src/routes/token/route.ts
+const tokenRoute = new Hono();
+tokenRoute.get("/", (c) => {
+	if (!state.showToken) return c.json({ error: {
+		message: "Token endpoint disabled",
+		type: "error"
+	} }, 403);
+	return c.json({ token: state.copilotToken });
+});
+//#endregion
+//#region src/routes/usage/route.ts
+const usageRoute = new Hono();
+usageRoute.get("/", async (c) => {
+	try {
+		const usage = await getCopilotUsage();
+		return c.json(usage);
+	} catch (error) {
+		consola.error("Error fetching Copilot usage:", error);
+		return await forwardError(c, error);
+	}
+});
+//#endregion
+//#region src/server.ts
+assertMcpToolSurfaceConsistent();
+const server = new Hono();
+server.use(cors());
+server.get("/", (c) => c.text("Server running"));
+server.get("/version", (c) => c.json({
+	name,
+	version,
+	gitSha: process.env.GITHUB_SHA ?? "unknown"
+}));
+server.on("HEAD", ["/"], (c) => c.body(null, 200));
+server.route("/chat/completions", completionRoutes);
+server.route("/responses", responsesRoutes);
+server.route("/models", modelRoutes);
+server.route("/embeddings", embeddingRoutes);
+server.route("/search", searchRoutes);
+server.route("/usage", usageRoute);
+server.route("/token", tokenRoute);
+server.route("/v1/chat/completions", completionRoutes);
+server.route("/v1/responses", responsesRoutes);
+server.route("/v1/models", modelRoutes);
+server.route("/v1/embeddings", embeddingRoutes);
+server.route("/v1/search", searchRoutes);
+server.route("/v1/messages", messageRoutes);
+server.route("/mcp", mcpRoutes);
+server.post("/api/event_logging/batch", (c) => c.body(null, 200));
+server.all("/v1/files/*", (c) => c.json({
+	type: "error",
+	error: {
+		type: "not_found_error",
+		message: "Files API is not supported by github-router (Copilot has no equivalent storage backend). Use the Anthropic API directly for file uploads/downloads."
+	}
+}, 404));
+server.notFound((c) => c.json({
+	type: "error",
+	error: {
+		type: "not_found_error",
+		message: `${c.req.method} ${c.req.path} not found`
+	}
+}, 404));
+//#endregion
+//#region src/lib/server-setup.ts
+const MAX_PORT_RETRIES = 10;
+/**
+* Maximum request body the proxy will accept, in bytes.
+*
+* Pinned EXPLICITLY because the runtimes disagree by default: bun's `serve`
+* defaults `maxRequestBodySize` to 128 MB and rejects past it, while
+* `node:http` (the srvx node adapter) has no body limit at all. Left
+* unset, the same request succeeds under node and 413s under bun, with
+* nothing in the response explaining that the runtime is the variable.
+* Same class of defect as the `idleTimeout` divergence below.
+*
+* Note which side that leaves exposed: `dist/main.js` ships
+* `#!/usr/bin/env node`, so npm-installed users are on the runtime with NO
+* limit, and bun is mostly the dev/`bun run start` path. The uncapped case
+* was the shipped one.
+*
+* 128 MB — i.e. bun's default, adopted as the intended value on BOTH
+* runtimes rather than inherited on one:
+*
+* - It sits above the traffic this proxy is built for, with margin. A
+*   full 1M-token Claude Code context is on the order of 4-5 MB of JSON
+*   text; base64 inline images inflate 4/3 and are re-sent every turn, so
+*   an image-heavy session runs to tens of MB. That is an estimate, not a
+*   measurement, which is part of why the cap is set well clear of it
+*   rather than snugly above it.
+* - Removing the limit to "match node" is not free even on loopback. The
+*   app mounts permissive `cors()`, so any web page the user visits can
+*   POST to 127.0.0.1:<port> (CORS gates reading the response, not sending
+*   the request); so can any local process. An unbounded body lets either
+*   stream the proxy to death.
+* - Raising it above 128 MB buys nothing and costs safety: the proxy
+*   BUFFERS the whole body (`c.req.json()`), parses it into a JS object
+*   (multiples of the text size in heap), then re-serializes it upstream.
+*   Past ~512 MB V8's max string length makes `JSON.stringify` fail
+*   opaquely — a cap well under that keeps the failure explainable.
+*
+* A body over this ceiling means something is wrong (runaway loop,
+* corrupted context), not a workload that needs a bigger buffer, so
+* there is deliberately no env override to raise it.
+*/
+const MAX_REQUEST_BODY_BYTES = 134217728;
+/**
+* Where the RUNTIME's own body check sits. Not the policy.
+*
+* The policy is `MAX_REQUEST_BODY_BYTES`, enforced by `withBodyLimit` in
+* this process, identically on every runtime. This value exists only to
+* displace the 128 MB default bun's `serve` applies, which would otherwise pre-empt
+* that gate — bun enforces its limit at header-parse time by replying and
+* closing while the client is still uploading, so a client that has not
+* finished writing never reads the reply. Measured with a real client
+* posting 64 MB over a limit: `The socket connection was closed
+* unexpectedly`, i.e. exactly the opaque failure this change removes, and
+* exactly what bun does TODAY at its default. An early response from our
+* own handler, by contrast, is delivered cleanly (413 with the JSON body,
+* ~50ms, no memory growth; draining the body first was strictly worse at
+* 155ms and +50 MB, so we do not drain).
+*
+* Set as ONE top-level srvx option, so bun and node get the same number.
+* A bun-only override would put the two runtimes back on different
+* thresholds, which is the defect being fixed, not a fix for it.
+*
+* Deliberately far above the policy so the policy always decides first:
+* everything a client can realistically send is answered by the explained
+* 413, and this is reached only by a body that is both undeclared and
+* absurd. It stays finite so "no limit at all" is never the state. It
+* bounds nothing the gate does not already bound — an unread body is
+* discarded by both runtimes rather than buffered — so a high value costs
+* no memory, and buys message quality across the whole realistic range.
+*/
+const TRANSPORT_BODY_CEILING_BYTES = 1073741824;
+/**
+* The 413 the user sees when a request body is over the ceiling.
+*
+* Anthropic error envelope (`request_too_large` is Anthropic's own 413
+* category), so a client that parses our error shape on every other path
+* parses this one too, and the message says what to actually do about it.
+*
+* `declaredBytes` is present only when the request declared a length. A
+* body caught mid-stream has no known size, and saying so beats inventing
+* one. Byte counts are exact, with the MB figure only as a gloss:
+* rounding alone reads as a contradiction at the boundary, where a body
+* one byte over renders as "128.0 MB, over the 128.0 MB limit".
+*/
+function bodyTooLargeResponse(declaredBytes) {
+	const mb = (n) => `${(n / 1048576).toFixed(1)} MB`;
+	const actual = declaredBytes === void 0 ? `Request body exceeds the size github-router accepts` : `Request body is ${declaredBytes} bytes (${mb(declaredBytes)}), over the size github-router accepts`;
+	return new Response(JSON.stringify({
+		type: "error",
+		error: {
+			type: "request_too_large",
+			message: `${actual}: at most ${MAX_REQUEST_BODY_BYTES} bytes (${mb(MAX_REQUEST_BODY_BYTES)}), the same limit under bun and node. This is usually an accumulated conversation or inline images (base64 attachments are re-sent every turn) rather than one large message — start a new session or drop the attachments.`
+		}
+	}), {
+		status: 413,
+		headers: { "content-type": "application/json" }
+	});
+}
+/** srvx's canonical over-limit error, however it reaches us. */
+function isBodyTooLarge(error) {
+	return typeof error === "object" && error !== null && error.code === "ERR_BODY_TOO_LARGE";
+}
+/**
+* Enforce `MAX_REQUEST_BODY_BYTES` in-process, so the limit and the
+* rejection are the same on every runtime.
+*
+* Leaving it to the runtimes is what produced the divergence in the first
+* place, and their rejections are not interchangeable:
+*
+* - bun rejects at header-parse time and closes the connection while the
+*   client is still uploading, so the client sees a dead socket rather
+*   than the 413 (measured; see `TRANSPORT_BODY_CEILING_BYTES`).
+* - node lets the handler run and rejects the body READ with an
+*   `ERR_BODY_TOO_LARGE` error. The app installs no Hono `onError`, so
+*   that becomes `500 Internal Server Error` — indistinguishable from a
+*   real proxy fault.
+*
+* Two layers, one threshold, applied uniformly:
+*
+* 1. A declared `Content-Length` over the limit is answered before the
+*    body is read at all. This is the path every real client takes
+*    (Claude Code / undici / curl all declare a length on a JSON body).
+* 2. Anything else — chunked, or a length that understates the body — is
+*    caught mid-stream by srvx's own `limitRequestBody`, the same helper
+*    its node and deno adapters use. Overflow is surfaced as the SAME
+*    explained 413 rather than leaking out as a 500.
+*
+* So a body that declares no length is no longer a hole in the message
+* quality OR in the bound, and neither depends on which runtime is
+* serving. Verified end to end against both adapters with a real client:
+* declared-over and chunked-over each return an identical 413.
+*/
+function withBodyLimit(fetchHandler) {
+	return async (request) => {
+		const declared = request.headers.get("content-length");
+		if (declared !== null && /^\d+$/.test(declared)) {
+			const bytes = Number(declared);
+			if (bytes > 134217728) return bodyTooLargeResponse(bytes);
+		}
+		let overflowed = false;
+		const limited = limitRequestBody(request, MAX_REQUEST_BODY_BYTES, { createError: (max) => {
+			overflowed = true;
+			return createBodyTooLargeError(max);
+		} });
+		try {
+			const response = await fetchHandler(limited);
+			if (overflowed) {
+				response.body?.cancel().catch(() => {});
+				return bodyTooLargeResponse();
+			}
+			return response;
+		} catch (error) {
+			if (overflowed || isBodyTooLarge(error)) return bodyTooLargeResponse();
+			throw error;
+		}
+	};
+}
+/**
+* Build the srvx `serve()` options shared by the explicit-port and
+* random-port paths.
+*
+* Extracted and exported so the per-runtime overrides below are
+* assertable. `setupAndServe` itself performs auth and network I/O, so the
+* only way to pin this behaviour in a test is to make the options object
+* reachable on its own — and it needs pinning, because deleting either
+* override reintroduces a failure that looks like an upstream/network
+* problem rather than a config one.
+*/
+function buildServeOptions(fetchHandler, silent) {
+	return {
+		fetch: withBodyLimit(fetchHandler),
+		hostname: "127.0.0.1",
+		silent,
+		maxRequestBodySize: TRANSPORT_BODY_CEILING_BYTES,
+		bun: { idleTimeout: 0 }
+	};
+}
+async function setupAndServe(options) {
+	if (options.proxyEnv) initProxyFromEnv();
+	if (options.verbose) {
+		consola.level = 5;
+		consola.info("Verbose logging enabled");
+	}
+	state.accountType = options.accountType;
+	if (options.accountType !== "individual") consola.info(`Using ${options.accountType} plan GitHub account`);
+	state.manualApprove = options.manual;
+	state.rateLimitSeconds = options.rateLimit;
+	state.rateLimitWait = options.rateLimitWait;
+	state.showToken = options.showToken;
+	state.extendedBetas = options.extendedBetas;
+	state.browseEnabled = options.browseEnabled || process.env.GH_ROUTER_ENABLE_BROWSE === "1";
+	state.fleetEnabled = options.fleetEnabled || process.env.GH_ROUTER_ENABLE_FLEET === "1";
+	state.agentsEnabled = options.agentsEnabled || process.env.GH_ROUTER_ENABLE_AGENTS === "1";
+	state.powerBrowseEnabled = options.powerBrowseEnabled || process.env.GH_ROUTER_ENABLE_POWER_BROWSE === "1";
+	if (state.powerBrowseEnabled) state.browseEnabled = true;
+	if (process.env.GH_ROUTER_BROWSER_NO_HUMANLIKE === "1") state.humanlikeForce = "off";
+	else if (options.humanlikeEnabled || process.env.GH_ROUTER_HUMANLIKE === "1") state.humanlikeForce = "on";
+	else state.humanlikeForce = "auto";
+	if (process.env.COPILOT_API_URL) state.copilotApiUrl = process.env.COPILOT_API_URL;
+	await ensurePaths();
+	await Promise.all([cacheVSCodeVersion(), cacheCopilotVersion()]);
+	if (options.githubToken) {
+		state.githubToken = options.githubToken;
+		consola.info("Using provided GitHub token");
+	} else await setupGitHubToken();
+	if (state.agentsEnabled) await setupGitHubAgentToken();
+	await setupCopilotToken();
+	await cacheModels();
+	consola.debug(`Available models: \n${state.models?.data.map((model) => `- ${model.id}`).join("\n")}`);
+	const serveOptions = buildServeOptions(server.fetch, options.silent);
+	let srvxServer;
+	if (options.port !== void 0) srvxServer = serve({
+		...serveOptions,
+		port: options.port
+	});
+	else {
+		let lastError;
+		for (let attempt = 0; attempt < MAX_PORT_RETRIES; attempt++) {
+			const candidatePort = generateRandomPort();
+			try {
+				srvxServer = serve({
+					...serveOptions,
+					port: candidatePort
+				});
+				break;
+			} catch (error) {
+				lastError = error;
+				if (!(error instanceof Error && (error.message.includes("EADDRINUSE") || error.message.includes("address already in use") || "code" in error && error.code === "EADDRINUSE"))) throw error;
+				consola.debug(`Port ${candidatePort} in use, trying another...`);
+			}
+		}
+		if (srvxServer === void 0) throw new Error(`Failed to find an available port after ${MAX_PORT_RETRIES} attempts. Specify a port with --port or free some ports. Last error: ${lastError}`);
+	}
+	await srvxServer.ready();
+	const url = srvxServer.url;
+	if (!url) throw new Error("Server started but URL is not available");
+	const serverUrl = url.replace(/\/$/, "");
+	try {
+		const handle = maybeSpawnDaemon({ agentsEnabled: agentToolsEnabled() });
+		if (handle) {
+			wireDaemonTeardown(handle);
+			consola.debug(`first-mate daemon spawn attempted (pid ${handle.pid ?? "?"}).`);
+		}
+	} catch (err) {
+		consola.debug("first-mate daemon auto-spawn skipped:", err);
+	}
+	return {
+		server: srvxServer,
+		serverUrl
+	};
+}
+/** Shared CLI arg definitions for all server commands. */
+const sharedServerArgs = {
+	port: {
+		alias: "p",
+		type: "string",
+		description: "Port to listen on"
+	},
+	verbose: {
+		alias: "v",
+		type: "boolean",
+		default: false,
+		description: "Enable verbose logging"
+	},
+	"account-type": {
+		alias: "a",
+		type: "string",
+		default: "enterprise",
+		description: "Account type to use (individual, business, enterprise)"
+	},
+	manual: {
+		type: "boolean",
+		default: false,
+		description: "Enable manual request approval"
+	},
+	"rate-limit": {
+		alias: "r",
+		type: "string",
+		description: "Rate limit in seconds between requests"
+	},
+	wait: {
+		alias: "w",
+		type: "boolean",
+		default: false,
+		description: "Wait instead of error when rate limit is hit. Has no effect if rate limit is not set"
+	},
+	"github-token": {
+		alias: "g",
+		type: "string",
+		description: "Provide GitHub token directly (must be generated using the `auth` subcommand)"
+	},
+	"show-token": {
+		type: "boolean",
+		default: false,
+		description: "Show GitHub and Copilot tokens on fetch and refresh"
+	},
+	"proxy-env": {
+		type: "boolean",
+		default: false,
+		description: "Initialize proxy from environment variables"
+	},
+	"extended-betas": {
+		type: "boolean",
+		default: false,
+		description: "Forward extended beta headers for Claude CLI compatibility (default: VS Code-only)"
+	},
+	browse: {
+		type: "boolean",
+		default: false,
+		description: "Enable the browser-control MCP tools (browser_open_tab, browser_screenshot, browser_click, etc.) on /mcp. Requires Chrome or Edge installed; the bundled extension must be loaded on first tool call (the proxy returns install_required with a Load Unpacked path and the expected extension ID). Off by default; can also be enabled with GH_ROUTER_ENABLE_BROWSE=1."
+	},
+	fleet: {
+		type: "boolean",
+		default: false,
+		description: "Enable the fleet session-control MCP tools (mcp__fleet__*) on /mcp for driving sessions across remote ai-or-die instances over their tunnels. Off by default; also enabled with GH_ROUTER_ENABLE_FLEET=1."
+	},
+	agents: {
+		type: "boolean",
+		default: false,
+		description: "Enable the first-mate cloud-agent orchestration surface (mcp__first-mate__*): a durable controller that drives GitHub cloud coding agents (Copilot/Anthropic/OpenAI) across research/plan/implement/test/merge. Triggers a second GitHub device-login for a write-capable token (repo, workflow, read:org). Off by default; also enabled with GH_ROUTER_ENABLE_AGENTS=1."
+	},
+	"power-browse": {
+		type: "boolean",
+		default: false,
+		description: "Expose the full ~18-tool browser MCP surface (raw read_page, mouse / drag / scroll / keyboard / type primitives, eval_js, diagnostics, find, locate). Default --browse exposes only the 6 lead-model tools (act, observe, extract, navigate, screenshot, open_tab) that hide DOM details behind intent. Implies --browse. Off by default; can also be enabled with GH_ROUTER_ENABLE_POWER_BROWSE=1."
+	},
+	humanlike: {
+		type: "boolean",
+		default: false,
+		description: "Force humanlike pacing on ALL browser tool dispatches: Beta-distributed inter-action delays (800-4600 ms), Bezier mouse trajectories with overshoot-and-correct, per-keystroke jitter with word-end pauses, scroll chunking. Use for known anti-bot sites (Cloudflare, Datadome). Off by default (auto mode); GH_ROUTER_HUMANLIKE=1 is the env equivalent. GH_ROUTER_BROWSER_NO_HUMANLIKE=1 hard-disables (wins over --humanlike, for tests)."
+	},
+	"self-update": {
+		type: "boolean",
+		default: true,
+		description: "Update github-router itself to the latest npm version on launch (throttled once/hour). Best-effort and non-blocking: the proxy serves immediately and a detached updater applies the new version after this process exits (it takes effect on the NEXT launch; the running process keeps its current build). Disable with --no-self-update or GH_ROUTER_NO_SELF_UPDATE=1. Skipped silently if npm/network unavailable."
+	}
+};
+const allowedAccountTypes = /* @__PURE__ */ new Set([
+	"individual",
+	"business",
+	"enterprise"
+]);
+/** Parse shared server args into ServerSetupOptions fields. */
+function parseSharedArgs(args) {
+	const portRaw = args.port;
+	let port;
+	if (portRaw !== void 0) {
+		port = Number.parseInt(portRaw, 10);
+		if (Number.isNaN(port) || port <= 0 || port > 65535) throw new Error("Invalid port. Must be between 1 and 65535.");
+	}
+	const accountType = args["account-type"] ?? "enterprise";
+	if (!allowedAccountTypes.has(accountType)) throw new Error("Invalid account type. Must be individual, business, or enterprise.");
+	const rateLimitRaw = args["rate-limit"];
+	let rateLimit;
+	if (rateLimitRaw !== void 0) {
+		rateLimit = Number.parseInt(rateLimitRaw, 10);
+		if (Number.isNaN(rateLimit) || rateLimit <= 0) throw new Error("Invalid rate limit. Must be a positive integer.");
+	}
+	const rateLimitWait = args.wait && rateLimit !== void 0;
+	if (args.wait && rateLimit === void 0) consola.warn("Rate limit wait ignored because no rate limit was set.");
+	const githubToken = args["github-token"] ?? process.env.GH_TOKEN;
+	return {
+		port,
+		verbose: args.verbose,
+		accountType,
+		manual: args.manual,
+		rateLimit,
+		rateLimitWait,
+		githubToken,
+		showToken: args["show-token"],
+		proxyEnv: args["proxy-env"],
+		extendedBetas: args["extended-betas"],
+		browseEnabled: args.browse,
+		fleetEnabled: args.fleet,
+		agentsEnabled: args.agents,
+		powerBrowseEnabled: args["power-browse"],
+		humanlikeEnabled: args.humanlike
+	};
+}
+/**
+* Non-Claude models we surface as first-class, selectable rows in Claude
+* Code's model picker (Phase 3 of native-non-claude-models). The main
+* agent loop runs on them through the `/v1/messages` translation shim
+* (`src/lib/anthropic-translate/*`, branched in `routes/messages/handler.ts`)
+* that forwards non-Claude targets to Copilot `/responses` (gpt) or
+* `/chat/completions` (gemini). The exact gemini id is
+* `gemini-3.1-pro-preview` (preview slug — NOT `gemini-3.1-pro`).
+*
+* Display labels only: the gateway-model cache schema Claude Code reads is
+* `{id, display_name?}` per model — there is NO per-model context-window
+* field, so context accounting for a selected row uses Claude Code's
+* default window (safe under-accounting: it compacts earlier than the real
+* 1M/400k window, never overflows). See `seedGatewayModelCache`.
+*/
+const NATIVE_NON_CLAUDE_MODELS = [
+	{
+		id: "gpt-5.6-sol",
+		displayName: "GPT-5.6 Sol"
+	},
+	{
+		id: "gpt-5.5",
+		displayName: "GPT-5.5"
+	},
+	{
+		id: "gpt-5.3-codex",
+		displayName: "GPT-5.3 Codex"
+	},
+	{
+		id: "gemini-3.5-flash",
+		displayName: "Gemini 3.5 Flash"
+	},
+	{
+		id: "gemini-3.1-pro-preview",
+		displayName: "Gemini 3.1 Pro (preview)"
+	}
+];
+/**
+* The subset of `NATIVE_NON_CLAUDE_MODELS` actually present in the live
+* Copilot catalog. License tiers differ (gpt-5.5 needs
+* pro_plus/business/enterprise/max; gemini-3.5-flash is absent on
+* edu/individual_trial), so a model missing from the catalog is silently
+* dropped — the caller then neither enables discovery nor writes a cache
+* for it, and lesser tiers see the unchanged picker. Pure (reads
+* `state.models`), so it is unit-testable without side effects.
+*/
+function nativeSelectableModelsInCatalog() {
+	const catalog = state.models?.data;
+	if (!catalog || catalog.length === 0) return [];
+	const present = new Set(catalog.map((m) => m.id));
+	return NATIVE_NON_CLAUDE_MODELS.filter((m) => present.has(m.id)).map((m) => ({
+		id: m.id,
+		display_name: m.displayName
+	}));
+}
+/**
+* Pre-seed Claude Code's gateway-model discovery cache so the non-Claude
+* models appear as selectable picker rows WITHOUT the network fetch.
+*
+* Verified against the installed Claude Code build (2.1.201): the picker
+* builder reads `<CLAUDE_CONFIG_DIR>/cache/gateway-models.json`
+* (schema `{baseUrl: string, fetchedAt: number, models: [{id, display_name?}]}`)
+* and — when gateway discovery is enabled (first-party auth mode +
+* `CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY` set + a non-`api.anthropic.com`
+* `ANTHROPIC_BASE_URL`, all true for the proxy) — maps each cached model to
+* a picker row `{value: id, label: display_name}`. Critically, the
+* cache-READ path applies NO id filter; the `/^(claude|anthropic)/i` filter
+* lives ONLY in the network-FETCH path. So a pre-seeded cache can carry the
+* real Copilot ids (`gpt-5.5`, `gemini-3.1-pro-preview`, …) — no `claude-*`
+* alias needed — and selecting a row sends that real id, which
+* `resolveModel()` exact-matches and the `/v1/messages` shim routes.
+*
+* The network fetch never overwrites this seed: it bails when nonessential
+* traffic is disabled, and the proxy ALWAYS sets
+* `CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=1`, so the fetch returns before
+* it can write. The seed is therefore authoritative for the session.
+*
+* `baseUrl` MUST equal the `ANTHROPIC_BASE_URL` Claude Code sees
+* (`serverUrl`) or the cache is discarded. `configDir` defaults to
+* `PATHS.CLAUDE_CONFIG_DIR` — the same dir the proxy points
+* `CLAUDE_CONFIG_DIR` at — so the write target and Claude Code's read
+* target are identical by construction.
+*
+* Best-effort: every failure is swallowed — a missing picker row must never
+* break launch. This is coupled to Claude Code's internal cache path/schema;
+* if a future build changes them the read simply ignores the seed and the
+* rows don't appear (graceful degradation). Returns whether a file was
+* written (for tests/observability).
+*
+* The write is atomic (temp file in the same dir + rename) so a Claude Code
+* read can never observe a torn/partial JSON (which its safeParse would
+* reject, dropping the rows). Rename-over-existing is atomic on POSIX and
+* Windows (libuv MoveFileEx REPLACE_EXISTING).
+*/
+function seedGatewayModelCache(serverUrl, models, configDir = PATHS.CLAUDE_CONFIG_DIR) {
+	if (models.length === 0) return false;
+	const cacheDir = nodePath.join(configDir, "cache");
+	const target = nodePath.join(cacheDir, "gateway-models.json");
+	const tmp = nodePath.join(cacheDir, `gateway-models.json.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`);
+	try {
+		fs$2.mkdirSync(cacheDir, { recursive: true });
+		const payload = {
+			baseUrl: serverUrl,
+			fetchedAt: Date.now(),
+			models: models.map((m) => ({
+				id: m.id,
+				display_name: m.display_name
+			}))
+		};
+		fs$2.writeFileSync(tmp, JSON.stringify(payload), "utf-8");
+		fs$2.renameSync(tmp, target);
+		return true;
+	} catch {
+		try {
+			fs$2.rmSync(tmp, { force: true });
+		} catch {}
+		return false;
+	}
+}
+/**
+* Remove any seeded gateway-model cache. Called when the current catalog
+* carries none of the target models, so a user who has pinned
+* `CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY` on cannot surface rows for
+* models that are no longer available. Best-effort (per-launch config dirs
+* make a stale file rare, but this closes the pinned-port + catalog-change
+* seam). Never throws.
+*/
+function clearGatewayModelCache(configDir = PATHS.CLAUDE_CONFIG_DIR) {
+	try {
+		fs$2.rmSync(nodePath.join(configDir, "cache", "gateway-models.json"), { force: true });
+	} catch {}
+}
+/**
+* Build environment variables for Claude Code.
+*
+* The parent env is sanitized of every key in `STRIPPED_PARENT_ENV_KEYS`
+* (see `src/lib/launch.ts`) BEFORE these overrides are merged in, so we
+* only need to provide the positive values.
+*
+* Auth precedence in Claude Code (https://code.claude.com/docs/en/iam),
+* after the github-router substrate fix:
+*   1. Cloud provider (CLAUDE_CODE_USE_BEDROCK / VERTEX / FOUNDRY) — stripped at parent.
+*   2. ANTHROPIC_AUTH_TOKEN — NOT set by the proxy. Stripped at parent
+*      (no env-source auth in the spawned child at all).
+*   3. ANTHROPIC_API_KEY — stripped at parent.
+*   4. apiKeyHelper in settings.json — copied into our config dir as
+*      part of the mirror; if the user defined one, it still fires
+*      and may mint an `x-api-key` header. Copilot ignores `x-api-key`,
+*      so behavior is unchanged from before this fix.
+*   5. CLAUDE_CODE_OAUTH_TOKEN — stripped at parent.
+*   6. Subscription OAuth (Keychain / `<CLAUDE_CONFIG_DIR>/.credentials.json`)
+*      — the credentials file is OURS (synthetic blob, written by
+*      `ensureClaudeConfigMirror`). Claude Code reads accessToken from
+*      it and sends as `Authorization: Bearer <accessToken>`. The
+*      teammate-spawn allowlist propagates `CLAUDE_CONFIG_DIR` to
+*      children, so spawned teammates find the same synthetic credential
+*      and authenticate (the bug this whole fix addresses).
+*
+* `CLAUDE_CONFIG_DIR` activates Claude Code's per-config-dir keychain
+* isolation (per binary-grep of v2.1.126's `iN()` function: when set,
+* the keychain service name becomes `Claude Code-<sha256(path)[0..8]>`,
+* missing the user's real `Claude Code` entry). Pointing it at our
+* snapshot-copied `PATHS.CLAUDE_CONFIG_DIR` preserves user customization
+* (mirrored settings.json, skills, MCP, hooks, CLAUDE.md, custom
+* agents) while giving teammates a credential they can find on disk.
+*
+* No-401 invariant: Claude Code's reactive refresh path (`SZ1` →
+* `D3(0,true,...)`) fires on any 401 from upstream. The synthetic
+* refreshToken would fail any real refresh attempt, so the proxy
+* MUST NOT return 401 on the Anthropic-shape boundary even when
+* upstream Copilot returns 401. See `src/routes/messages/handler.ts`.
+*/
+function getClaudeCodeEnvVars(serverUrl, model) {
+	const vars = {
+		ANTHROPIC_BASE_URL: serverUrl,
+		CLAUDE_CONFIG_DIR: PATHS.CLAUDE_CONFIG_DIR,
+		DISABLE_NON_ESSENTIAL_MODEL_CALLS: "1",
+		CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: "1",
+		DISABLE_TELEMETRY: "1"
+	};
+	if (model) vars.ANTHROPIC_MODEL = model;
+	const mcpToolTimeoutMs = String(resolveMcpToolTimeoutMs());
+	if (process.env.MCP_TIMEOUT === void 0) vars.MCP_TIMEOUT = mcpToolTimeoutMs;
+	if (process.env.MCP_TOOL_TIMEOUT === void 0) vars.MCP_TOOL_TIMEOUT = mcpToolTimeoutMs;
+	if (process.env.ANTHROPIC_SMALL_FAST_MODEL === void 0) vars.ANTHROPIC_SMALL_FAST_MODEL = "claude-sonnet-5";
+	if (process.env.ANTHROPIC_DEFAULT_SONNET_MODEL === void 0) vars.ANTHROPIC_DEFAULT_SONNET_MODEL = "claude-sonnet-5";
+	if (process.env.ANTHROPIC_DEFAULT_HAIKU_MODEL === void 0) vars.ANTHROPIC_DEFAULT_HAIKU_MODEL = "claude-sonnet-5";
+	if (process.env.ANTHROPIC_DEFAULT_OPUS_MODEL === void 0) vars.ANTHROPIC_DEFAULT_OPUS_MODEL = "claude-opus-5";
+	if (process.env.CLAUDE_CODE_PLAN_V2_AGENT_COUNT === void 0) vars.CLAUDE_CODE_PLAN_V2_AGENT_COUNT = "7";
+	for (const key of [
+		"CLAUDE_CODE_ENABLE_EXPERIMENTAL_ADVISOR_TOOL",
+		"CLAUDE_CODE_FORK_SUBAGENT",
+		"CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS",
+		"CLAUDE_CODE_ENABLE_FINE_GRAINED_TOOL_STREAMING",
+		"CLAUDE_CODE_ENABLE_TASKS"
+	]) if (process.env[key] === void 0) vars[key] = "1";
+	const nativeModels = nativeSelectableModelsInCatalog();
+	if (nativeModels.length > 0) {
+		if (seedGatewayModelCache(serverUrl, nativeModels) && process.env.CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY === void 0 && vars.CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY === void 0) vars.CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY = "1";
+	} else clearGatewayModelCache();
+	if (toolbeltEnabled()) Object.assign(vars, toolbeltPathOverride(process.env, PATHS.TOOLBELT_BIN_DIR));
+	return vars;
+}
+/**
+* Build environment variables for Codex CLI.
+*
+* Like `getClaudeCodeEnvVars`, the parent env is sanitized of
+* `OPENAI_API_KEY` / `OPENAI_BASE_URL` / `CODEX_HOME` (see
+* `STRIPPED_PARENT_ENV_KEYS` in `src/lib/launch.ts`) before these
+* overrides are merged, so a stale shell `OPENAI_API_KEY` can't leak
+* through. Codex caches a ChatGPT subscription login under
+* `$CODEX_HOME/auth.json` which can override `OPENAI_API_KEY` per
+* openai/codex#2733; pointing `CODEX_HOME` at an isolated directory
+* masks any cached login.
+*/
+function getCodexEnvVars(serverUrl) {
+	const vars = {
+		OPENAI_BASE_URL: `${serverUrl}/v1`,
+		OPENAI_API_KEY: "dummy",
+		CODEX_HOME: PATHS.CODEX_HOME
+	};
+	if (toolbeltEnabled()) Object.assign(vars, toolbeltPathOverride(process.env, PATHS.TOOLBELT_BIN_DIR));
+	return vars;
+}
+//#endregion
+export { sharedServerArgs as a, listModelsForEndpoint as c, updateClaude as d, setupAndServe as i, runSelfUpdate as l, getCodexEnvVars as n, startKeepAwake as o, parseSharedArgs as r, stopKeepAwake as s, getClaudeCodeEnvVars as t, checkClaudeVersion as u };
+
+//# sourceMappingURL=server-setup-DcO9qvN3.js.map