@dianshuv/copilot-api 0.9.0 → 0.10.0

package/dist/main.mjs

@@ -6,18 +6,17 @@ import os from "node:os";
 import path, { dirname, join } from "node:path";
 import { getProxyForUrl } from "proxy-from-env";
 import { Agent, ProxyAgent, setGlobalDispatcher } from "undici";
-import { createHash, randomUUID } from "node:crypto";
+import { createHash, randomUUID, timingSafeEqual } from "node:crypto";
 import { existsSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
 import clipboard from "clipboardy";
 import { serve } from "srvx";
-import invariant from "tiny-invariant";
 import { PostHog } from "posthog-node";
 import { execSync } from "node:child_process";
 import process$1 from "node:process";
 import pc from "picocolors";
 import { Hono } from "hono";
 import { cors } from "hono/cors";
-import { stream, streamSSE } from "hono/streaming";
+import { streamSSE } from "hono/streaming";
 import { events } from "fetch-event-stream";
 
 //#region src/lib/paths.ts
@@ -125,6 +124,7 @@ const state = {
 	accountType: "individual",
 	manualApprove: false,
 	showToken: false,
+	showAllModels: false,
 	verbose: false,
 	autoTruncate: true,
 	compressToolResults: false,
@@ -1348,7 +1348,7 @@ const patchClaude = defineCommand({
 
 //#endregion
 //#region package.json
-var version = "0.9.0";
+var version = "0.10.0";
 
 //#endregion
 //#region src/lib/adaptive-rate-limiter.ts
@@ -1657,6 +1657,315 @@ async function executeWithAdaptiveRateLimit(fn) {
 	return rateLimiterInstance.execute(fn);
 }
 
+//#endregion
+//#region src/lib/auth-gate.ts
+/**
+* Auth gate — the inbound authentication decision point for the proxy.
+*
+* Protects this proxy's *inbound* surface with a configured **Proxy API key**
+* (NOT the outbound GitHub OAuth token or Copilot token). The decision logic
+* is expressed as pure functions so it can be unit-tested without booting the
+* server or reaching upstream.
+*/
+/**
+* Extract candidate presented credential values from request headers.
+*
+* Two header shapes are read, and **both** contribute candidates when present
+* (compare-all-present) so neither is silently ignored in favor of the other —
+* a later any-match over the candidates decides acceptance:
+*  - `Authorization`: the scheme prefix is stripped case-insensitively
+*    (`Bearer ` / `bearer ` …) because the scheme is case-insensitive per
+*    RFC 7235, while the secret itself is case-sensitive. A bare value with no
+*    scheme prefix is tolerated and returned verbatim.
+*  - `x-api-key` (Issue 02): the Anthropic-native header. Taken verbatim — no
+*    scheme stripping (a value that happens to start with `Bearer ` is kept
+*    as-is).
+*
+* Order is `[Authorization, x-api-key]` for any present header; absent headers
+* contribute nothing.
+*/
+function extractCredentials(headers) {
+	const candidates = [];
+	const authorization = headers.get("authorization");
+	if (authorization !== null) candidates.push(authorization.replace(/^Bearer\s+/i, ""));
+	const apiKey = headers.get("x-api-key");
+	if (apiKey !== null) candidates.push(apiKey);
+	return candidates;
+}
+/**
+* Hard-coded exemption set: the liveness (`/`) and readiness (`/health`)
+* endpoints are reachable without a key so container orchestration probes are
+* never blocked. Everything else is protected (fail-closed) — unknown / future
+* routes default to protected.
+*
+* Matching is by **exact path**, with a trailing slash tolerated (so `/health/`
+* is exempt too) and `/` itself handled explicitly. Prefix matching is
+* deliberately avoided: `/healthz` or `/health/extra` must NOT be exempt. The
+* server registers a matching `/health/` route, so an exempt `/health/` request
+* resolves to the readiness handler rather than 404ing.
+*/
+function isExemptPath(path) {
+	if (path === "/") return true;
+	return (path.length > 1 && path.endsWith("/") ? path.slice(0, -1) : path) === "/health";
+}
+/**
+* Compute the fixed-length sha256 digest (32 bytes) of the configured key.
+* The configured key is trimmed before hashing (config-side trim).
+*/
+function digestConfiguredKey(configuredKey) {
+	return createHash("sha256").update(configuredKey.trim()).digest();
+}
+/**
+* Constant-time membership test: does any presented candidate match the
+* configured key?
+*
+* Each candidate is sha256'd to a fixed 32-byte digest and compared against the
+* configured digest. Hashing to a fixed length sidesteps the `RangeError` that
+* `crypto.timingSafeEqual` throws on length-mismatched buffers, so a
+* wrong-length presented value yields `false` rather than throwing.
+*/
+function matchesConfiguredKey(configuredDigest, candidates) {
+	return candidates.some((candidate) => {
+		return timingSafeEqual(createHash("sha256").update(candidate).digest(), configuredDigest);
+	});
+}
+/**
+* Resolve the inbound Proxy API key from its two operator-facing sources,
+* applying the precedence + normalization contract (Issue 03):
+*
+*  - `--api-key` flag (`flag`) and `COPILOT_API_KEY` env (`env`) are each
+*    **trimmed first**; a trimmed-empty source (`""`, whitespace, or
+*    `undefined`) counts as **not provided**.
+*  - When both provide a non-empty value, the **flag wins** (env ignored).
+*  - When only one provides a non-empty value, that one is used.
+*  - When neither does, `key` is `undefined` and `source` is `"none"` → auth
+*    stays disabled (same as the no-`--api-key` default).
+*
+* Pure: it reads nothing from `process.env` itself (the caller passes the env
+* value in), so it is fully unit-testable and the precedence logic is decoupled
+* from how the values are sourced.
+*/
+function resolveProxyApiKey(sources) {
+	const flag = sources.flag?.trim() ?? "";
+	if (flag !== "") return {
+		key: flag,
+		source: "flag"
+	};
+	const env = sources.env?.trim() ?? "";
+	if (env !== "") return {
+		key: env,
+		source: "env"
+	};
+	return {
+		key: void 0,
+		source: "none"
+	};
+}
+/**
+* Resolve the address the server will *actually* bind to for the startup banner
+* (Issue 04).
+*
+* Mirrors srvx's own host resolution EXACTLY so the banner reports the TRUE bind
+* rather than a guess that could diverge from what srvx passes to the runtime.
+* srvx computes `hostname = opts.hostname ?? process.env.HOST` (a raw nullish
+* coalesce — no trimming, no empty-string special-casing), and start.ts passes
+* `hostname: options.host`. So:
+*   - an explicit `--host` (even `""` / whitespace) is what srvx uses verbatim —
+*     it does NOT fall back to HOST once `opts.hostname` is a non-null string;
+*   - only an absent (`undefined`) `--host` lets srvx fall back to `HOST`;
+*   - when the coalesced value is `undefined` or empty, the runtime binds all
+*     interfaces, which we report as the explicit `0.0.0.0` so a wide-open bind
+*     is unmistakable (srvx renders the same bind as "localhost (all
+*     interfaces)").
+*
+* Critically, the resolved non-empty value is returned VERBATIM (not trimmed):
+* srvx hands the runtime exactly that string, so the banner must report exactly
+* that string — trimming here would make the banner claim a different address
+* than the one actually bound. `env` is passed in (not read) to keep the
+* function pure and unit-testable.
+*/
+function resolveBindAddress(host, env) {
+	const resolved = host ?? env;
+	if (resolved === void 0 || resolved === "") return "0.0.0.0";
+	return resolved;
+}
+/**
+* Resolve the CLIENT-FACING host for generated configs and viewer links
+* (Issue 04), derived from the SAME srvx host resolution as the banner so the
+* two never disagree about what was bound — and formatted as a valid URL
+* authority so the links actually parse.
+*
+* Two differences from {@link resolveBindAddress}:
+*  - All-interfaces rendering: a wildcard bind (`0.0.0.0` / `::` / `[::]` /
+*    empty) is not a connectable target, so it maps to `localhost` for URLs a
+*    client will actually dial (matching srvx's "localhost (all interfaces)"
+*    presentation). A narrowed bind (e.g. `127.0.0.1`, `192.168.1.10`, an IPv6
+*    address) is kept so generated links point at the real interface — fixing
+*    the prior bug where setting `HOST` (with `--host` omitted) yielded
+*    `http://localhost:<port>` links the narrowed bind wasn't listening on.
+*  - IPv6 bracketing: a literal IPv6 host (contains `:`) is wrapped in `[...]`,
+*    exactly as srvx's own `fmtURL` does, so `http://[2001:db8::1]:<port>` is a
+*    valid authority rather than the unparseable `http://2001:db8::1:<port>`.
+*
+* Returns a host token ready to drop into `http://<token>:<port>`.
+*/
+function resolveClientHost(host, env) {
+	const bind = resolveBindAddress(host, env);
+	if (bind === "0.0.0.0" || bind === "::" || bind === "[::]") return "localhost";
+	if (bind.includes(":") && !bind.startsWith("[")) return `[${bind}]`;
+	return bind;
+}
+/**
+* Build the inbound-auth startup banner lines (Issue 04).
+*
+* Returns the human-readable lines the proxy prints at boot so operators can see,
+* at a glance, the security posture of *this* instance:
+*  - auth ON  → `认证开启`, plus the key's origin (`flag` / `env`), plus the real
+*    bind address.
+*  - auth OFF → `认证关闭`, plus the real bind address (so a careless all-
+*    interfaces bind without auth is visible).
+*
+* The configured key value is **never** an input here, so it can never leak into
+* the banner — the function only knows the *source* tag, not the secret. Pure
+* (string in → strings out) so the banner copy is pinned by unit tests.
+*/
+function buildStartupAuthLines(params) {
+	const { source, bindAddress } = params;
+	return [source === "none" ? `Inbound auth: 认证关闭 (no proxy API key configured)` : `Inbound auth: 认证开启 (source: ${source})`, `Binding to: ${bindAddress}`];
+}
+/**
+* The env var Claude Code reads for its inbound credential, and the placeholder
+* value the `--claude-code` setup always embeds for it. Exported so the
+* generated env script (src/start.ts) and the auth hint below reference the SAME
+* literals — changing the placeholder or the var name in one place can't silently
+* desync the other (the hint would otherwise keep naming a string the generated
+* command no longer contains).
+*/
+const CLAUDE_CODE_AUTH_TOKEN_ENV = "ANTHROPIC_AUTH_TOKEN";
+const CLAUDE_CODE_AUTH_TOKEN_PLACEHOLDER = "dummy";
+/**
+* Build the auth-aware hint lines for the `--claude-code` setup (Issue 05).
+*
+* The generated env script ALWAYS sets `ANTHROPIC_AUTH_TOKEN="dummy"` — a real
+* key is deliberately never embedded, so the secret can't land in the clipboard
+* or shell history. When inbound auth is ON, that placeholder won't authenticate
+* against this proxy, so the operator must replace it. This builder returns the
+* visible hint that tells them which variable to change:
+*  - auth OFF (`source === "none"`) → no hint (today's behavior, unchanged).
+*  - auth ON  (`flag` / `env`)      → a one-line hint naming
+*    `ANTHROPIC_AUTH_TOKEN` as the field to set to the proxy API key value.
+*
+* Like {@link buildStartupAuthLines}, the key value is **never** an input here —
+* the builder only knows the `source` tag — so it is structurally impossible for
+* the secret to leak into the hint. Pure (tag in → strings out) so the copy is
+* pinned by unit tests.
+*/
+function buildClaudeCodeAuthHint(source) {
+	if (source === "none") return [];
+	return [`Inbound auth is ON: replace ${CLAUDE_CODE_AUTH_TOKEN_ENV}="${CLAUDE_CODE_AUTH_TOKEN_PLACEHOLDER}" with your proxy API key value before using Claude Code.`];
+}
+/**
+* Configure the proxy API key on global state from a raw configured value.
+*
+* The value is trimmed; a trimmed-empty value (or `undefined`) is treated as
+* "not provided" → auth stays disabled. Otherwise the precomputed digest is
+* stored on state (presence === enabled). Returns whether auth is enabled.
+*
+* The `--api-key` flag and `COPILOT_API_KEY` env source are reconciled upstream
+* by `resolveProxyApiKey` (flag-over-env precedence, Issue 03); this function
+* receives only the already-resolved value.
+*/
+function configureProxyApiKey(rawKey) {
+	const trimmed = rawKey?.trim() ?? "";
+	if (trimmed === "") {
+		state.proxyApiKeyDigest = void 0;
+		return false;
+	}
+	state.proxyApiKeyDigest = digestConfiguredKey(trimmed);
+	return true;
+}
+/**
+* Path → auth-family selector (Issue 02).
+*
+* The Anthropic-native surface is `/v1/messages` and its `count_tokens`
+* subpath; both map to the Anthropic family so a native Anthropic client gets
+* the `authentication_error` body. Everything else — including every other
+* `/v1/…` endpoint and any unknown / future route — defaults to the OpenAI
+* family.
+*
+* Matching is by **exact path** (a trailing slash tolerated), deliberately not
+* a prefix test: the shared `/v1/` prefix must not sweep OpenAI-style endpoints
+* into the Anthropic family, and `/v1/messages-extra` or a deeper unexpected
+* subpath must not be misclassified either. This mirrors `isExemptPath`'s
+* exact-with-trailing-slash convention.
+*/
+function selectFamily(path) {
+	const normalized = path.length > 1 && path.endsWith("/") ? path.slice(0, -1) : path;
+	if (normalized === "/v1/messages" || normalized === "/v1/messages/count_tokens") return "anthropic";
+	return "openai";
+}
+/**
+* OpenAI-family 401 response body. The literal field values are pinned by the
+* ADR so OpenAI-compatible SDKs recognize the failure as an auth error. The
+* same body is returned whether credentials were missing or wrong (no oracle).
+*/
+function unauthorizedOpenAIBody() {
+	return { error: {
+		message: "Invalid API key provided.",
+		type: "invalid_request_error",
+		code: "invalid_api_key",
+		param: null
+	} };
+}
+/**
+* Anthropic-family 401 response body (Issue 02). Shape is pinned so Anthropic
+* SDKs (and Claude Code via `/v1/messages`) recognize the failure as an auth
+* error: a top-level `{type:"error", error:{type:"authentication_error",
+* message}}`. As with the OpenAI body, missing and wrong credentials return the
+* identical body (no oracle).
+*/
+function unauthorizedAnthropicBody() {
+	return {
+		type: "error",
+		error: {
+			type: "authentication_error",
+			message: "Invalid API key provided."
+		}
+	};
+}
+/**
+* Global fail-closed authentication middleware.
+*
+* Registered after the request logger and CORS but before route dispatch.
+* Behavior:
+*  - Disabled (no configured digest) → pass through unchanged (default).
+*  - Exempt path (`/`, `/health`) → pass through.
+*  - CORS preflight `OPTIONS` on a protected path → pass through so browser
+*    preflight isn't mistaken for a 401 (blocking it surfaces as an opaque CORS
+*    error, very hard to diagnose). Scoped to *actual* preflights — an
+*    `OPTIONS` carrying `Access-Control-Request-Method` — rather than any
+*    `OPTIONS`, so the bypass surface can't silently widen. Preflights carry no
+*    protected payload, so this doesn't weaken fail-closed.
+*  - Otherwise require a valid Proxy API key; on failure return 401 with a
+*    `WWW-Authenticate: Bearer` header and a **family-appropriate** body —
+*    Anthropic-family (`/v1/messages*`) gets the `authentication_error` shape,
+*    everything else the OpenAI `invalid_api_key` shape (Issue 02). The family
+*    only selects the body shape; it does not change what is protected. Missing
+*    and wrong credentials return the field-identical body for that family.
+*/
+function authGate() {
+	return async (c, next) => {
+		const configuredDigest = state.proxyApiKeyDigest;
+		if (!configuredDigest) return next();
+		if (isExemptPath(c.req.path)) return next();
+		if (c.req.method === "OPTIONS" && c.req.raw.headers.get("access-control-request-method") !== null) return next();
+		if (matchesConfiguredKey(configuredDigest, extractCredentials(c.req.raw.headers))) return next();
+		c.header("WWW-Authenticate", "Bearer");
+		if (selectFamily(c.req.path) === "anthropic") return c.json(unauthorizedAnthropicBody(), 401);
+		return c.json(unauthorizedOpenAIBody(), 401);
+	};
+}
+
 //#endregion
 //#region src/lib/context/request.ts
 let idCounter = 0;
@@ -1876,6 +2185,56 @@ function createRequestContextManager(staleMaxAgeSec) {
 	};
 }
 
+//#endregion
+//#region src/lib/hidden-models.ts
+/**
+* Hardcoded list of GitHub Copilot model ids that are hidden from listing
+* endpoints (the /v1/models response, the startup ASCII banner, and the
+* --claude-code interactive prompts), unless `--show-all-models` is passed.
+*
+* Note: this is a DISPLAY filter only. Explicit POSTs to handler endpoints
+* with a hidden id are NOT rejected — they pass through to upstream verbatim.
+*
+* Bumping the list requires a code change + release. No env var, no config
+* file, no CLI append interface.
+*/
+const HIDDEN_MODEL_IDS = new Set([
+	"gpt-3.5-turbo",
+	"gpt-3.5-turbo-0613",
+	"gpt-4",
+	"gpt-4-0613",
+	"gpt-4-0125-preview",
+	"gpt-4o",
+	"gpt-4o-mini",
+	"gpt-4-o-preview",
+	"gpt-4o-2024-05-13",
+	"gpt-4o-2024-08-06",
+	"gpt-4o-2024-11-20",
+	"gpt-4o-mini-2024-07-18",
+	"gpt-4.1",
+	"gpt-4.1-2025-04-14",
+	"gpt-41-copilot",
+	"gpt-5-mini",
+	"gpt-5.3-codex",
+	"gpt-5.4",
+	"text-embedding-ada-002",
+	"text-embedding-3-small",
+	"text-embedding-3-small-inference",
+	"gemini-2.5-pro",
+	"gemini-3-flash-preview",
+	"claude-opus-4.5",
+	"claude-opus-4.6",
+	"claude-opus-4.7-high",
+	"claude-opus-4.7-xhigh",
+	"claude-sonnet-4.5",
+	"mai-code-1-flash-internal",
+	"trajectory-compaction"
+]);
+function isHiddenModel(id, showAll) {
+	if (showAll) return false;
+	return HIDDEN_MODEL_IDS.has(id);
+}
+
 //#endregion
 //#region src/lib/history-ws.ts
 /**
@@ -1883,6 +2242,18 @@ function createRequestContextManager(staleMaxAgeSec) {
 * Enables real-time updates when new requests are recorded.
 */
 const clients = /* @__PURE__ */ new Set();
+function addClient(ws) {
+	clients.add(ws);
+	const msg = {
+		type: "connected",
+		data: { clientCount: clients.size },
+		timestamp: Date.now()
+	};
+	ws.send(JSON.stringify(msg));
+}
+function removeClient(ws) {
+	clients.delete(ws);
+}
 function getClientCount() {
 	return clients.size;
 }
@@ -3042,158 +3413,6 @@ const awaitApproval = async () => {
 	if (!await consola.prompt(`Accept incoming request?`, { type: "confirm" })) throw new HTTPError("Request rejected", 403, JSON.stringify({ message: "Request rejected" }));
 };
 
-//#endregion
-//#region src/lib/echo-model.ts
-/**
-* Capture the requested model id from a raw request `model` value, classifying
-* it into the three-state contract. `undefined`/missing → `absent`; `""` →
-* `empty`; any other string → `present`.
-*/
-function captureRequestedModel(rawModel) {
-	if (rawModel === void 0 || rawModel === null) return { kind: "absent" };
-	if (typeof rawModel !== "string") return { kind: "absent" };
-	if (rawModel === "") return { kind: "empty" };
-	return {
-		kind: "present",
-		value: rawModel
-	};
-}
-/**
-* Resolve a {@link RequestedModel} into the action to take on a model field:
-*  - `{ write: true, value }` → set the field to `value`.
-*  - `{ write: false, omit: true }` → remove the field (absent case).
-*  - `null` → leave the field untouched (context-missing case).
-*/
-function resolveFieldAction(requested) {
-	if (requested.kind === "present") return { value: requested.value };
-	if (requested.kind === "empty") return { value: "" };
-	if (requested.kind === "absent") return { omit: true };
-	return null;
-}
-/**
-* Apply the requested-model action to a single `model`-like key on a shallow
-* clone of `obj`. Returns a new object; never mutates `obj`. If `obj` does not
-* own `key`, it is returned (cloned) unchanged regardless of the action — we
-* only ever rewrite a field the upstream payload actually carries (supports
-* AC-MALFORMED-SSE: no model field → original passthrough).
-*/
-function rewriteKey(obj, key, requested) {
-	if (!Object.hasOwn(obj, key)) return obj;
-	const action = resolveFieldAction(requested);
-	if (action === null) return obj;
-	if ("omit" in action) {
-		const { [key]: _omitted, ...rest } = obj;
-		return rest;
-	}
-	return {
-		...obj,
-		[key]: action.value
-	};
-}
-/**
-* Core rewrite over a plain record. Rewrites the documented model fields:
-*  - top-level `model`, top-level `modelVersion` (Gemini),
-*  - nested `message.model` (Anthropic message_start),
-*  - nested `response.model` (OpenAI Responses event).
-* Returns a shallow clone; never mutates the input.
-*/
-function echoRecord(body, requested) {
-	let out = rewriteKey(body, "model", requested);
-	out = rewriteKey(out, "modelVersion", requested);
-	if (isRecord$1(out.message) && Object.hasOwn(out.message, "model")) {
-		const newMessage = rewriteKey(out.message, "model", requested);
-		if (newMessage !== out.message) out = {
-			...out,
-			message: newMessage
-		};
-	}
-	if (isRecord$1(out.response) && Object.hasOwn(out.response, "model")) {
-		const newResponse = rewriteKey(out.response, "model", requested);
-		if (newResponse !== out.response) out = {
-			...out,
-			response: newResponse
-		};
-	}
-	return out;
-}
-/**
-* Rewrite the documented client-facing model field(s) of a JSON response body
-* to the requested model id. Handles every supported non-stream/body shape:
-*  - top-level `model` (OpenAI chat/completions & Responses bodies, Anthropic
-*    messages body, embeddings),
-*  - nested `message.model` (Anthropic `message_start` event object),
-*  - nested `response.model` (OpenAI Responses streaming event object),
-*  - top-level `modelVersion` (Gemini body & chunk).
-*
-* Returns a shallow-cloned object; the input is never mutated. Fields that are
-* not present are left as-is (a payload with no model field round-trips
-* unchanged), supporting AC-MALFORMED-SSE.
-*
-* The generic is constrained to `object` (not an index-signature shape) so it
-* accepts the project's domain interfaces (`AnthropicResponse`,
-* `ChatCompletionChunk`, …) directly without forcing callers to widen them.
-*/
-function echoModelInResponseBody(body, requested) {
-	return echoRecord(body, requested);
-}
-/**
-* Ensure a response body's top-level `model` field equals the requested model
-* id — **setting it even when the body omits it**. This differs from
-* {@link echoModelInResponseBody}, which only rewrites a `model` field the
-* payload already carries (the passthrough rule that protects malformed-SSE /
-* model-less events). Some upstreams omit `model` from an otherwise-valid
-* response body (notably the Copilot embeddings endpoint, whose 200 body carries
-* only `data` + `usage`); for those, the documented client-facing contract is
-* still "`response.model` == R", so the field must be added, not skipped.
-*
-* Three-state per AC-MISSING-MODEL, keyed on the REQUESTER's model (not the
-* upstream's):
-*  - `present` → set `model` to R (added if absent, overwritten if present).
-*  - `empty`   → set `model` to "" (the client sent an empty string).
-*  - `absent`  → omit `model` (client sent no model → never invent one); if the
-*               body happened to carry an upstream `model`, drop it.
-*  - `context-missing` → leave the body untouched (defensive passthrough).
-*
-* Only the documented client's own string R is ever written — never the upstream
-* id — so this introduces no side channel (AC-NO-SIDECHANNEL). Returns a shallow
-* clone; the input is never mutated (protects the AC-OBS data source).
-*/
-function echoTopLevelModel(body, requested) {
-	if (requested.kind === "context-missing") return body;
-	const rec = body;
-	if (requested.kind === "absent") {
-		if (!Object.hasOwn(rec, "model")) return body;
-		const { model: _dropped, ...rest } = rec;
-		return rest;
-	}
-	const value = requested.kind === "present" ? requested.value : "";
-	return {
-		...rec,
-		model: value
-	};
-}
-function isRecord$1(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-/**
-* Rewrite the model field of an already-parsed SSE event payload to the
-* requested model id, dispatched by protocol shape:
-*  - Anthropic `message_start` → `message.model`,
-*  - OpenAI chunk → top-level `model`,
-*  - OpenAI Responses event → nested `response.model`,
-*  - Gemini chunk → `modelVersion`.
-*
-* The field dispatch is identical to {@link echoModelInResponseBody} (both
-* operate on the same documented model fields), so this delegates to the same
-* core rather than duplicating the shape logic — the two exports exist to name
-* the two responsibilities (body vs parsed-event) at call sites, per the PRD's
-* single-policy-point design. Events with no model field round-trip unchanged
-* (AC-MALFORMED-SSE); the input is never mutated.
-*/
-function echoModelInParsedEvent(event, requested) {
-	return echoRecord(event, requested);
-}
-
 //#endregion
 //#region src/lib/message-sanitizer.ts
 const startPattern = /^\s*<system-reminder>[\s\S]*?<\/system-reminder>\n*/;
@@ -3215,144 +3434,23 @@ function removeSystemReminderTags(text) {
 }
 
 //#endregion
-//#region src/lib/repetition-detector.ts
+//#region src/lib/tokenizer.ts
+const ENCODING_MAP = {
+	o200k_base: () => import("gpt-tokenizer/encoding/o200k_base"),
+	cl100k_base: () => import("gpt-tokenizer/encoding/cl100k_base"),
+	p50k_base: () => import("gpt-tokenizer/encoding/p50k_base"),
+	p50k_edit: () => import("gpt-tokenizer/encoding/p50k_edit"),
+	r50k_base: () => import("gpt-tokenizer/encoding/r50k_base")
+};
+const encodingCache = /* @__PURE__ */ new Map();
 /**
-* Stream repetition detector.
-*
-* Uses the KMP failure function (prefix function) to detect repeated patterns
-* in streaming text output. When a model gets stuck in a repetitive loop,
-* it wastes tokens producing the same content over and over. This detector
-* identifies such loops early so the caller can take action (log warning,
-* abort stream, etc.).
-*
-* The algorithm works by maintaining a sliding buffer of recent text and
-* computing the longest proper prefix that is also a suffix — if this
-* length exceeds `(text.length - period) >= minRepetitions * period`,
-* it means a pattern of length `period` has repeated enough times.
+* Calculate tokens for tool calls
 */
-const DEFAULT_CONFIG = {
-	minPatternLength: 10,
-	minRepetitions: 3,
-	maxBufferSize: 5e3
-};
-var RepetitionDetector = class {
-	buffer = "";
-	config;
-	detected = false;
-	constructor(config) {
-		this.config = {
-			...DEFAULT_CONFIG,
-			...config
-		};
-	}
-	/**
-	* Feed a text chunk into the detector.
-	* Returns `true` if repetition has been detected (now or previously).
-	* Once detected, subsequent calls return `true` without further analysis.
-	*/
-	feed(text) {
-		if (this.detected) return true;
-		if (!text) return false;
-		this.buffer += text;
-		if (this.buffer.length > this.config.maxBufferSize) this.buffer = this.buffer.slice(-this.config.maxBufferSize);
-		const minRequired = this.config.minPatternLength * this.config.minRepetitions;
-		if (this.buffer.length < minRequired) return false;
-		this.detected = detectRepetition(this.buffer, this.config.minPatternLength, this.config.minRepetitions);
-		return this.detected;
-	}
-	/** Reset detector state for a new stream */
-	reset() {
-		this.buffer = "";
-		this.detected = false;
-	}
-	/** Whether repetition has been detected */
-	get isDetected() {
-		return this.detected;
-	}
-};
-/**
-* Detect if the tail of `text` contains a repeating pattern.
-*
-* Uses the KMP prefix function: for a string S, the prefix function π[i]
-* gives the length of the longest proper prefix of S[0..i] that is also
-* a suffix. If π[n-1] ≥ (n - period) where period = n - π[n-1], then
-* the string is composed of a repeating unit of length `period`.
-*
-* We check the suffix of the buffer (last `checkLength` chars) to detect
-* if a pattern of at least `minPatternLength` chars repeats at least
-* `minRepetitions` times.
-*/
-function detectRepetition(text, minPatternLength, minRepetitions) {
-	const minWindow = minPatternLength * minRepetitions;
-	const maxWindow = Math.min(text.length, 2e3);
-	const windowSizes = [
-		minWindow,
-		Math.floor(maxWindow * .5),
-		maxWindow
-	].filter((w) => w >= minWindow && w <= text.length);
-	for (const windowSize of windowSizes) {
-		const window = text.slice(-windowSize);
-		const period = findRepeatingPeriod(window);
-		if (period >= minPatternLength) {
-			if (Math.floor(window.length / period) >= minRepetitions) return true;
-		}
-	}
-	return false;
-}
-/**
-* Find the shortest repeating period in a string using KMP prefix function.
-* Returns the period length, or the string length if no repetition found.
-*/
-function findRepeatingPeriod(s) {
-	const n = s.length;
-	if (n === 0) return 0;
-	const pi = new Int32Array(n);
-	for (let i = 1; i < n; i++) {
-		let j = pi[i - 1] ?? 0;
-		while (j > 0 && s[i] !== s[j]) j = pi[j - 1] ?? 0;
-		if (s[i] === s[j]) j++;
-		pi[i] = j;
-	}
-	const period = n - pi[n - 1];
-	if (period < n && n % period === 0) return period;
-	if (period < n && pi[n - 1] >= period) return period;
-	return n;
-}
-/**
-* Create a repetition detector callback for use in stream processing.
-* Returns a function that accepts text deltas and logs a warning on first detection.
-*/
-function createStreamRepetitionChecker(label, config) {
-	const detector = new RepetitionDetector(config);
-	let warned = false;
-	return (textDelta) => {
-		const isRepetitive = detector.feed(textDelta);
-		if (isRepetitive && !warned) {
-			warned = true;
-			consola.warn(`[RepetitionDetector] ${label}: Repetitive output detected in stream`);
-		}
-		return isRepetitive;
-	};
-}
-
-//#endregion
-//#region src/lib/tokenizer.ts
-const ENCODING_MAP = {
-	o200k_base: () => import("gpt-tokenizer/encoding/o200k_base"),
-	cl100k_base: () => import("gpt-tokenizer/encoding/cl100k_base"),
-	p50k_base: () => import("gpt-tokenizer/encoding/p50k_base"),
-	p50k_edit: () => import("gpt-tokenizer/encoding/p50k_edit"),
-	r50k_base: () => import("gpt-tokenizer/encoding/r50k_base")
-};
-const encodingCache = /* @__PURE__ */ new Map();
-/**
-* Calculate tokens for tool calls
-*/
-const calculateToolCallsTokens = (toolCalls, encoder, constants) => {
-	let tokens = 0;
-	for (const toolCall of toolCalls) {
-		tokens += constants.funcInit;
-		tokens += encoder.encode(JSON.stringify(toolCall)).length;
+const calculateToolCallsTokens = (toolCalls, encoder, constants) => {
+	let tokens = 0;
+	for (const toolCall of toolCalls) {
+		tokens += constants.funcInit;
+		tokens += encoder.encode(JSON.stringify(toolCall)).length;
 	}
 	tokens += constants.funcEnd;
 	return tokens;
@@ -3547,135 +3645,6 @@ const getTokenCount = async (payload, model) => {
 	};
 };
 
-//#endregion
-//#region src/lib/anthropic/beta.ts
-/**
-* Vendor-neutral utilities for manipulating the `anthropic-beta` request header.
-*
-* Lives in `lib/anthropic/` (not in either transport module) so both the
-* Anthropic-native and OpenAI-translated transport layers can share these
-* helpers without introducing cross-transport imports.
-*/
-/** Anthropic beta feature that unlocks the 1M context window. */
-const CONTEXT_1M_BETA_FEATURE = "context-1m-2025-08-07";
-/**
-* Merge two comma-separated anthropic-beta header values. Trims whitespace,
-* drops empty tokens, and dedupes by exact string match. Returns a canonical
-* comma-joined string with no spaces.
-*
-* Either input may be undefined / empty.
-*/
-function mergeBetaFeatures(existing, incoming) {
-	const seen = /* @__PURE__ */ new Set();
-	const out = [];
-	for (const raw of [existing, incoming]) {
-		if (!raw) continue;
-		for (const part of raw.split(",")) {
-			const f = part.trim();
-			if (f.length === 0 || seen.has(f)) continue;
-			seen.add(f);
-			out.push(f);
-		}
-	}
-	return out.join(",");
-}
-/**
-* Append the context-1m feature to an anthropic-beta header value, deduping
-* any prior occurrence. Returns the merged comma-separated string.
-*/
-function appendContext1mBeta(existing) {
-	return mergeBetaFeatures(existing, CONTEXT_1M_BETA_FEATURE);
-}
-/**
-* True iff a model id appears to be the suffixed 1M-context variant of an
-* Anthropic Claude model (e.g. claude-opus-4-8-1m, claude-opus-4.6-1m).
-*
-* Used as a state.models-independent signal for whether to inject the
-* context-1m-2025-08-07 beta header, so the 1M intent survives a stale or
-* empty model cache (where `resolveAnthropicModelForDirectPath` would return
-* undefined). Forwarding the beta is harmless to upstreams that ignore it.
-*/
-function isOneMillionSuffixedClaudeId(modelId) {
-	return modelId.startsWith("claude-") && modelId.endsWith("-1m");
-}
-
-//#endregion
-//#region src/lib/headers.ts
-/**
-* Vendor-neutral header-bag helpers.
-*
-* HTTP header names are case-insensitive, but a plain-object header bag is
-* case-sensitive on its keys. Code that wants to look up "anthropic-beta"
-* without knowing whether some other producer wrote "Anthropic-Beta" needs
-* `findHeaderKey`. Code that wants to set a header without creating a
-* second case variant of the same name needs `setHeader`.
-*/
-/** Case-insensitive lookup of a header key in a plain-object header bag. */
-function findHeaderKey(headers, name) {
-	const lower = name.toLowerCase();
-	return Object.keys(headers).find((k) => k.toLowerCase() === lower);
-}
-/** Case-insensitive read of a header value. */
-function getHeader(headers, name) {
-	const key = findHeaderKey(headers, name);
-	return key === void 0 ? void 0 : headers[key];
-}
-/**
-* Set a header value at the existing case variant if one is present, else at
-* the supplied canonical name. Prevents a second key (different case) from
-* being added for the same logical header.
-*/
-function setHeader(headers, name, value) {
-	const key = findHeaderKey(headers, name) ?? name;
-	headers[key] = value;
-}
-
-//#endregion
-//#region src/services/copilot/create-chat-completions.ts
-const GPT_MODEL_PATTERN = /^gpt-/i;
-const createChatCompletions = async (payload, options) => {
-	if (!state.copilotToken) throw new Error("Copilot token not found");
-	const vendor = options?.resolvedModel?.vendor;
-	const isOpenAIVendor = vendor === "OpenAI" || vendor === "Azure OpenAI";
-	const isLikelyGPT = !options?.resolvedModel && GPT_MODEL_PATTERN.test(payload.model);
-	let wire = payload;
-	if (isOpenAIVendor || isLikelyGPT) {
-		const { max_tokens, max_completion_tokens, ...rest } = payload;
-		const effective = max_completion_tokens ?? max_tokens;
-		wire = {
-			...rest,
-			...effective !== null && effective !== void 0 && { max_completion_tokens: effective }
-		};
-	}
-	const enableVision = wire.messages.some((x) => typeof x.content !== "string" && x.content?.some((x) => x.type === "image_url"));
-	const isAgentCall = wire.messages.some((msg) => ["assistant", "tool"].includes(msg.role));
-	const modelSupportsVision = options?.resolvedModel?.capabilities?.supports?.vision !== false;
-	const headers = {
-		...copilotHeaders(state, {
-			vision: enableVision && modelSupportsVision,
-			modelRequestHeaders: options?.resolvedModel?.request_headers,
-			intent: isAgentCall ? "conversation-agent" : "conversation-panel"
-		}),
-		"X-Initiator": options?.initiator ?? (isAgentCall ? "agent" : "user")
-	};
-	if (options?.anthropicBeta) {
-		const existingKey = findHeaderKey(headers, "anthropic-beta") ?? "anthropic-beta";
-		headers[existingKey] = mergeBetaFeatures(headers[existingKey], options.anthropicBeta);
-		consola.debug(`[ChatCompletions] anthropic-beta after merge: ${headers[existingKey]}`);
-	}
-	const response = await copilotFetch("/chat/completions", {
-		method: "POST",
-		headers,
-		body: JSON.stringify(wire)
-	});
-	if (!response.ok) {
-		consola.error("Failed to create chat completions", response);
-		throw await HTTPError.fromResponse("Failed to create chat completions", response, options?.errorModelIdOverride ?? payload.model);
-	}
-	if (payload.stream) return events(response);
-	return await response.json();
-};
-
 //#endregion
 //#region src/lib/auto-truncate-openai.ts
 /**
@@ -3865,7 +3834,7 @@ function createTruncationSystemContext$1(removedCount, compressedCount, summary)
 	return context;
 }
 /** Create a truncation marker message (fallback when no system message) */
-function createTruncationMarker$2(removedCount, compressedCount, summary) {
+function createTruncationMarker$1(removedCount, compressedCount, summary) {
 	const parts = [];
 	if (removedCount > 0) parts.push(`${removedCount} earlier messages removed`);
 	if (compressedCount > 0) parts.push(`${compressedCount} tool results compressed`);
@@ -3992,7 +3961,7 @@ async function autoTruncateOpenAI(payload, model, config = {}) {
 			content: typeof lastSystem.content === "string" ? lastSystem.content + truncationContext : lastSystem.content
 		};
 		newSystemMessages = [...systemMessages.slice(0, lastSystemIdx), updatedSystem];
-	} else newMessages = [createTruncationMarker$2(removedCount, compressedCount, summary), ...preserved];
+	} else newMessages = [createTruncationMarker$1(removedCount, compressedCount, summary), ...preserved];
 	const newPayload = {
 		...payload,
 		messages: [...newSystemMessages, ...newMessages]
@@ -4018,22 +3987,481 @@ async function autoTruncateOpenAI(payload, model, config = {}) {
 }
 
 //#endregion
-//#region src/lib/error-metrics.ts
-function safeString(value, max = 200) {
-	try {
-		if (typeof value !== "string") return void 0;
-		return value.length > max ? value.slice(0, max) : value;
-	} catch {
-		return;
-	}
+//#region src/lib/openai-payload-prep.ts
+/**
+* OpenAI-shape payload preparation.
+*
+* Pre-flight steps for any request whose final payload is an OpenAI
+* ChatCompletionsPayload — auto-truncate decisions, 413 diagnostic logging,
+* and the non-streaming type guard. Used by both `routes/chat-completions`
+* (native OpenAI) and `routes/messages/translated-handler` (Anthropic that
+* gets translated into OpenAI shape before hitting upstream).
+*/
+/** Type guard for non-streaming responses */
+function isNonStreaming(response) {
+	return Object.hasOwn(response, "choices");
 }
-function getStringProp(obj, key, max = 200) {
-	try {
-		if (typeof obj !== "object" || obj === null) return void 0;
-		return safeString(obj[key], max);
-	} catch {
-		return;
-	}
+/** Build final payload with auto-truncate if needed */
+async function buildFinalPayload(payload, model, autoTruncateConfig = {}) {
+	if (!state.autoTruncate || !model) {
+		if (state.autoTruncate && !model) consola.warn(`Auto-truncate: Model '${payload.model}' not found in cached models, skipping`);
+		return {
+			finalPayload: payload,
+			truncateResult: null
+		};
+	}
+	try {
+		const check = await checkNeedsCompactionOpenAI(payload, model, autoTruncateConfig);
+		consola.debug(`Auto-truncate check: ${check.currentTokens} tokens (limit ${check.tokenLimit}), ${Math.round(check.currentBytes / 1024)}KB (limit ${check.byteLimit === Infinity ? "unlimited" : `${Math.round(check.byteLimit / 1024)}KB`}), needed: ${check.needed}${check.reason ? ` (${check.reason})` : ""}`);
+		if (!check.needed) return {
+			finalPayload: payload,
+			truncateResult: null
+		};
+		let reasonText;
+		if (check.reason === "both") reasonText = "tokens and size";
+		else if (check.reason === "bytes") reasonText = "size";
+		else reasonText = "tokens";
+		consola.info(`Auto-truncate triggered: exceeds ${reasonText} limit`);
+		const truncateResult = await autoTruncateOpenAI(payload, model, autoTruncateConfig);
+		return {
+			finalPayload: truncateResult.payload,
+			truncateResult
+		};
+	} catch (error) {
+		consola.warn("Auto-truncate failed, proceeding with original payload:", error instanceof Error ? error.message : error);
+		return {
+			finalPayload: payload,
+			truncateResult: null
+		};
+	}
+}
+/**
+* Log helpful debugging information when a 413 error occurs.
+* Also adjusts the dynamic byte limit for future requests.
+*/
+async function logPayloadSizeInfo(payload, model) {
+	const messageCount = payload.messages.length;
+	const bodySize = JSON.stringify(payload).length;
+	const bodySizeKB = Math.round(bodySize / 1024);
+	onRequestTooLarge(bodySize);
+	let imageCount = 0;
+	let largeMessages = 0;
+	let totalImageSize = 0;
+	for (const msg of payload.messages) {
+		if (Array.isArray(msg.content)) {
+			for (const part of msg.content) if (part.type === "image_url") {
+				imageCount++;
+				if (part.image_url.url.startsWith("data:")) totalImageSize += part.image_url.url.length;
+			}
+		}
+		if ((typeof msg.content === "string" ? msg.content.length : JSON.stringify(msg.content).length) > 5e4) largeMessages++;
+	}
+	consola.info("");
+	consola.info("╭─────────────────────────────────────────────────────────╮");
+	consola.info("│           413 Request Entity Too Large                  │");
+	consola.info("╰─────────────────────────────────────────────────────────╯");
+	consola.info("");
+	consola.info(`  Request body size: ${bodySizeKB} KB (${bodySize.toLocaleString()} bytes)`);
+	consola.info(`  Message count: ${messageCount}`);
+	if (model) try {
+		const tokenCount = await getTokenCount(payload, model);
+		const limit = model.capabilities?.limits?.max_prompt_tokens ?? 128e3;
+		consola.info(`  Estimated tokens: ${tokenCount.input.toLocaleString()} / ${limit.toLocaleString()}`);
+	} catch {}
+	if (imageCount > 0) {
+		const imageSizeKB = Math.round(totalImageSize / 1024);
+		consola.info(`  Images: ${imageCount} (${imageSizeKB} KB base64 data)`);
+	}
+	if (largeMessages > 0) consola.info(`  Large messages (>50KB): ${largeMessages}`);
+	consola.info("");
+	consola.info("  Suggestions:");
+	if (!state.autoTruncate) consola.info("    • Enable --auto-truncate to automatically truncate history");
+	if (imageCount > 0) consola.info("    • Remove or resize large images in the conversation");
+	consola.info("    • Start a new conversation with /clear or /reset");
+	consola.info("    • Reduce conversation history by deleting old messages");
+	consola.info("");
+}
+
+//#endregion
+//#region src/lib/repetition-detector.ts
+/**
+* Stream repetition detector.
+*
+* Uses the KMP failure function (prefix function) to detect repeated patterns
+* in streaming text output. When a model gets stuck in a repetitive loop,
+* it wastes tokens producing the same content over and over. This detector
+* identifies such loops early so the caller can take action (log warning,
+* abort stream, etc.).
+*
+* The algorithm works by maintaining a sliding buffer of recent text and
+* computing the longest proper prefix that is also a suffix — if this
+* length exceeds `(text.length - period) >= minRepetitions * period`,
+* it means a pattern of length `period` has repeated enough times.
+*/
+const DEFAULT_CONFIG = {
+	minPatternLength: 10,
+	minRepetitions: 3,
+	maxBufferSize: 5e3
+};
+var RepetitionDetector = class {
+	buffer = "";
+	config;
+	detected = false;
+	constructor(config) {
+		this.config = {
+			...DEFAULT_CONFIG,
+			...config
+		};
+	}
+	/**
+	* Feed a text chunk into the detector.
+	* Returns `true` if repetition has been detected (now or previously).
+	* Once detected, subsequent calls return `true` without further analysis.
+	*/
+	feed(text) {
+		if (this.detected) return true;
+		if (!text) return false;
+		this.buffer += text;
+		if (this.buffer.length > this.config.maxBufferSize) this.buffer = this.buffer.slice(-this.config.maxBufferSize);
+		const minRequired = this.config.minPatternLength * this.config.minRepetitions;
+		if (this.buffer.length < minRequired) return false;
+		this.detected = detectRepetition(this.buffer, this.config.minPatternLength, this.config.minRepetitions);
+		return this.detected;
+	}
+	/** Reset detector state for a new stream */
+	reset() {
+		this.buffer = "";
+		this.detected = false;
+	}
+	/** Whether repetition has been detected */
+	get isDetected() {
+		return this.detected;
+	}
+};
+/**
+* Detect if the tail of `text` contains a repeating pattern.
+*
+* Uses the KMP prefix function: for a string S, the prefix function π[i]
+* gives the length of the longest proper prefix of S[0..i] that is also
+* a suffix. If π[n-1] ≥ (n - period) where period = n - π[n-1], then
+* the string is composed of a repeating unit of length `period`.
+*
+* We check the suffix of the buffer (last `checkLength` chars) to detect
+* if a pattern of at least `minPatternLength` chars repeats at least
+* `minRepetitions` times.
+*/
+function detectRepetition(text, minPatternLength, minRepetitions) {
+	const minWindow = minPatternLength * minRepetitions;
+	const maxWindow = Math.min(text.length, 2e3);
+	const windowSizes = [
+		minWindow,
+		Math.floor(maxWindow * .5),
+		maxWindow
+	].filter((w) => w >= minWindow && w <= text.length);
+	for (const windowSize of windowSizes) {
+		const window = text.slice(-windowSize);
+		const period = findRepeatingPeriod(window);
+		if (period >= minPatternLength) {
+			if (Math.floor(window.length / period) >= minRepetitions) return true;
+		}
+	}
+	return false;
+}
+/**
+* Find the shortest repeating period in a string using KMP prefix function.
+* Returns the period length, or the string length if no repetition found.
+*/
+function findRepeatingPeriod(s) {
+	const n = s.length;
+	if (n === 0) return 0;
+	const pi = new Int32Array(n);
+	for (let i = 1; i < n; i++) {
+		let j = pi[i - 1] ?? 0;
+		while (j > 0 && s[i] !== s[j]) j = pi[j - 1] ?? 0;
+		if (s[i] === s[j]) j++;
+		pi[i] = j;
+	}
+	const period = n - pi[n - 1];
+	if (period < n && n % period === 0) return period;
+	if (period < n && pi[n - 1] >= period) return period;
+	return n;
+}
+/**
+* Create a repetition detector callback for use in stream processing.
+* Returns a function that accepts text deltas and logs a warning on first detection.
+*/
+function createStreamRepetitionChecker(label, config) {
+	const detector = new RepetitionDetector(config);
+	let warned = false;
+	return (textDelta) => {
+		const isRepetitive = detector.feed(textDelta);
+		if (isRepetitive && !warned) {
+			warned = true;
+			consola.warn(`[RepetitionDetector] ${label}: Repetitive output detected in stream`);
+		}
+		return isRepetitive;
+	};
+}
+
+//#endregion
+//#region src/lib/anthropic/beta.ts
+/**
+* Vendor-neutral utilities for manipulating the `anthropic-beta` request header.
+*
+* Lives in `lib/anthropic/` (not in either transport module) so both the
+* Anthropic-native and OpenAI-translated transport layers can share these
+* helpers without introducing cross-transport imports.
+*/
+/** Anthropic beta feature that unlocks the 1M context window. */
+const CONTEXT_1M_BETA_FEATURE = "context-1m-2025-08-07";
+/**
+* Merge two comma-separated anthropic-beta header values. Trims whitespace,
+* drops empty tokens, and dedupes by exact string match. Returns a canonical
+* comma-joined string with no spaces.
+*
+* Either input may be undefined / empty.
+*/
+function mergeBetaFeatures(existing, incoming) {
+	const seen = /* @__PURE__ */ new Set();
+	const out = [];
+	for (const raw of [existing, incoming]) {
+		if (!raw) continue;
+		for (const part of raw.split(",")) {
+			const f = part.trim();
+			if (f.length === 0 || seen.has(f)) continue;
+			seen.add(f);
+			out.push(f);
+		}
+	}
+	return out.join(",");
+}
+/**
+* Append the context-1m feature to an anthropic-beta header value, deduping
+* any prior occurrence. Returns the merged comma-separated string.
+*/
+function appendContext1mBeta(existing) {
+	return mergeBetaFeatures(existing, CONTEXT_1M_BETA_FEATURE);
+}
+/**
+* True iff a model id appears to be the suffixed 1M-context variant of an
+* Anthropic Claude model (e.g. claude-opus-4-8-1m, claude-opus-4.6-1m).
+*
+* Used as a state.models-independent signal for whether to inject the
+* context-1m-2025-08-07 beta header, so the 1M intent survives a stale or
+* empty model cache (where `resolveAnthropicModelForDirectPath` would return
+* undefined). Forwarding the beta is harmless to upstreams that ignore it.
+*/
+function isOneMillionSuffixedClaudeId(modelId) {
+	return modelId.startsWith("claude-") && modelId.endsWith("-1m");
+}
+
+//#endregion
+//#region src/lib/headers.ts
+/**
+* Vendor-neutral header-bag helpers.
+*
+* HTTP header names are case-insensitive, but a plain-object header bag is
+* case-sensitive on its keys. Code that wants to look up "anthropic-beta"
+* without knowing whether some other producer wrote "Anthropic-Beta" needs
+* `findHeaderKey`. Code that wants to set a header without creating a
+* second case variant of the same name needs `setHeader`.
+*/
+/** Case-insensitive lookup of a header key in a plain-object header bag. */
+function findHeaderKey(headers, name) {
+	const lower = name.toLowerCase();
+	return Object.keys(headers).find((k) => k.toLowerCase() === lower);
+}
+/** Case-insensitive read of a header value. */
+function getHeader(headers, name) {
+	const key = findHeaderKey(headers, name);
+	return key === void 0 ? void 0 : headers[key];
+}
+/**
+* Set a header value at the existing case variant if one is present, else at
+* the supplied canonical name. Prevents a second key (different case) from
+* being added for the same logical header.
+*/
+function setHeader(headers, name, value) {
+	const key = findHeaderKey(headers, name) ?? name;
+	headers[key] = value;
+}
+
+//#endregion
+//#region src/services/copilot/create-chat-completions.ts
+const GPT_MODEL_PATTERN = /^gpt-/i;
+const createChatCompletions = async (payload, options) => {
+	if (!state.copilotToken) throw new Error("Copilot token not found");
+	const vendor = options?.resolvedModel?.vendor;
+	const isOpenAIVendor = vendor === "OpenAI" || vendor === "Azure OpenAI";
+	const isLikelyGPT = !options?.resolvedModel && GPT_MODEL_PATTERN.test(payload.model);
+	let wire = payload;
+	if (isOpenAIVendor || isLikelyGPT) {
+		const { max_tokens, max_completion_tokens, ...rest } = payload;
+		const effective = max_completion_tokens ?? max_tokens;
+		wire = {
+			...rest,
+			...effective !== null && effective !== void 0 && { max_completion_tokens: effective }
+		};
+	}
+	const enableVision = wire.messages.some((x) => typeof x.content !== "string" && x.content?.some((x) => x.type === "image_url"));
+	const isAgentCall = wire.messages.some((msg) => ["assistant", "tool"].includes(msg.role));
+	const modelSupportsVision = options?.resolvedModel?.capabilities?.supports?.vision !== false;
+	const headers = {
+		...copilotHeaders(state, {
+			vision: enableVision && modelSupportsVision,
+			modelRequestHeaders: options?.resolvedModel?.request_headers,
+			intent: isAgentCall ? "conversation-agent" : "conversation-panel"
+		}),
+		"X-Initiator": options?.initiator ?? (isAgentCall ? "agent" : "user")
+	};
+	if (options?.anthropicBeta) {
+		const existingKey = findHeaderKey(headers, "anthropic-beta") ?? "anthropic-beta";
+		headers[existingKey] = mergeBetaFeatures(headers[existingKey], options.anthropicBeta);
+		consola.debug(`[ChatCompletions] anthropic-beta after merge: ${headers[existingKey]}`);
+	}
+	const response = await copilotFetch("/chat/completions", {
+		method: "POST",
+		headers,
+		body: JSON.stringify(wire)
+	});
+	if (!response.ok) {
+		consola.error("Failed to create chat completions", response);
+		throw await HTTPError.fromResponse("Failed to create chat completions", response, options?.errorModelIdOverride ?? payload.model);
+	}
+	if (payload.stream) return events(response);
+	return await response.json();
+};
+
+//#endregion
+//#region src/lib/echo-model.ts
+/**
+* Capture the requested model id from a raw request `model` value, classifying
+* it into the three-state contract. `undefined`/missing → `absent`; `""` →
+* `empty`; any other string → `present`.
+*/
+function captureRequestedModel(rawModel) {
+	if (rawModel === void 0 || rawModel === null) return { kind: "absent" };
+	if (typeof rawModel !== "string") return { kind: "absent" };
+	if (rawModel === "") return { kind: "empty" };
+	return {
+		kind: "present",
+		value: rawModel
+	};
+}
+/**
+* Resolve a {@link RequestedModel} into the action to take on a model field:
+*  - `{ write: true, value }` → set the field to `value`.
+*  - `{ write: false, omit: true }` → remove the field (absent case).
+*  - `null` → leave the field untouched (context-missing case).
+*/
+function resolveFieldAction(requested) {
+	if (requested.kind === "present") return { value: requested.value };
+	if (requested.kind === "empty") return { value: "" };
+	if (requested.kind === "absent") return { omit: true };
+	return null;
+}
+/**
+* Apply the requested-model action to a single `model`-like key on a shallow
+* clone of `obj`. Returns a new object; never mutates `obj`. If `obj` does not
+* own `key`, it is returned (cloned) unchanged regardless of the action — we
+* only ever rewrite a field the upstream payload actually carries (supports
+* AC-MALFORMED-SSE: no model field → original passthrough).
+*/
+function rewriteKey(obj, key, requested) {
+	if (!Object.hasOwn(obj, key)) return obj;
+	const action = resolveFieldAction(requested);
+	if (action === null) return obj;
+	if ("omit" in action) {
+		const { [key]: _omitted, ...rest } = obj;
+		return rest;
+	}
+	return {
+		...obj,
+		[key]: action.value
+	};
+}
+/**
+* Core rewrite over a plain record. Rewrites the documented model fields:
+*  - top-level `model`,
+*  - nested `message.model` (Anthropic message_start),
+*  - nested `response.model` (OpenAI Responses event).
+* Returns a shallow clone; never mutates the input.
+*/
+function echoRecord(body, requested) {
+	let out = rewriteKey(body, "model", requested);
+	if (isRecord(out.message) && Object.hasOwn(out.message, "model")) {
+		const newMessage = rewriteKey(out.message, "model", requested);
+		if (newMessage !== out.message) out = {
+			...out,
+			message: newMessage
+		};
+	}
+	if (isRecord(out.response) && Object.hasOwn(out.response, "model")) {
+		const newResponse = rewriteKey(out.response, "model", requested);
+		if (newResponse !== out.response) out = {
+			...out,
+			response: newResponse
+		};
+	}
+	return out;
+}
+/**
+* Rewrite the documented client-facing model field(s) of a JSON response body
+* to the requested model id. Handles every supported non-stream/body shape:
+*  - top-level `model` (OpenAI chat/completions & Responses bodies, Anthropic
+*    messages body),
+*  - nested `message.model` (Anthropic `message_start` event object),
+*  - nested `response.model` (OpenAI Responses streaming event object).
+*
+* Returns a shallow-cloned object; the input is never mutated. Fields that are
+* not present are left as-is (a payload with no model field round-trips
+* unchanged), supporting AC-MALFORMED-SSE.
+*
+* The generic is constrained to `object` (not an index-signature shape) so it
+* accepts the project's domain interfaces (`AnthropicResponse`,
+* `ChatCompletionChunk`, …) directly without forcing callers to widen them.
+*/
+function echoModelInResponseBody(body, requested) {
+	return echoRecord(body, requested);
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+* Rewrite the model field of an already-parsed SSE event payload to the
+* requested model id, dispatched by protocol shape:
+*  - Anthropic `message_start` → `message.model`,
+*  - OpenAI chunk → top-level `model`,
+*  - OpenAI Responses event → nested `response.model`.
+*
+* The field dispatch is identical to {@link echoModelInResponseBody} (both
+* operate on the same documented model fields), so this delegates to the same
+* core rather than duplicating the shape logic — the two exports exist to name
+* the two responsibilities (body vs parsed-event) at call sites, per the PRD's
+* single-policy-point design. Events with no model field round-trip unchanged
+* (AC-MALFORMED-SSE); the input is never mutated.
+*/
+function echoModelInParsedEvent(event, requested) {
+	return echoRecord(event, requested);
+}
+
+//#endregion
+//#region src/lib/error-metrics.ts
+function safeString(value, max = 200) {
+	try {
+		if (typeof value !== "string") return void 0;
+		return value.length > max ? value.slice(0, max) : value;
+	} catch {
+		return;
+	}
+}
+function getStringProp(obj, key, max = 200) {
+	try {
+		if (typeof obj !== "object" || obj === null) return void 0;
+		return safeString(obj[key], max);
+	} catch {
+		return;
+	}
 }
 function extractErrorMetrics(error) {
 	if (error instanceof HTTPError) {
@@ -4060,37 +4488,96 @@ function extractErrorMetrics(error) {
 }
 
 //#endregion
-//#region src/routes/shared.ts
-/**
-* Shared utilities for request handlers.
-* Contains common functions used by both OpenAI and Anthropic message handlers.
-*/
+//#region src/routes/observability-recording.ts
 /**
-* Resolve the requested model id (R) carried on the response context into a
-* {@link RequestedModel}. A context that never captured R (`undefined`) is
-* treated as `context-missing` so the echo passes the upstream value through
-* unchanged — it must never invent an id or throw.
+* Observability recording for error paths.
+*
+* Writes failed requests to history and emits matching PostHog analytics
+* events for both non-streaming errors (before the stream starts) and
+* mid-stream errors (after the accumulator has partial data). Success-path
+* analytics live in `tracker-mutations.ts` alongside `completeTracking`.
 */
-function requestedModelOf(ctx) {
-	return ctx.requestedModel ?? { kind: "context-missing" };
+function formatError(error) {
+	if (error instanceof Error) return error.message || error.name;
+	if (typeof error === "string") return error;
+	try {
+		const s = JSON.stringify(error);
+		if (s && s !== "{}") return s;
+	} catch {}
+	try {
+		return String(error);
+	} catch {
+		return "Unknown error";
+	}
 }
-/**
-* Echo the requested model id into a JSON response body at the client write-out
-* boundary. Thin context-aware wrapper over {@link echoModelInResponseBody};
-* MUST be called AFTER history/posthog/TUI have read the upstream value.
-*/
-function echoResponseBody(body, ctx) {
-	return echoModelInResponseBody(body, requestedModelOf(ctx));
+/** Record error response to history */
+function recordErrorResponse(ctx, model, error, endpoint, stream) {
+	recordResponse(ctx.historyId, {
+		success: false,
+		model,
+		usage: {
+			input_tokens: 0,
+			output_tokens: 0
+		},
+		error: formatError(error),
+		content: null
+	}, Date.now() - ctx.startTime);
+	const metrics = extractErrorMetrics(error);
+	const { attempts } = getRetryAttempts(error);
+	captureRequest({
+		model,
+		inputTokens: 0,
+		outputTokens: 0,
+		durationMs: Date.now() - ctx.startTime,
+		success: false,
+		stream: stream ?? false,
+		toolCount: 0,
+		...metrics,
+		errorPhase: stream ? "pre_stream" : "non_stream",
+		endpoint,
+		attempt: attempts
+	});
+}
+/** Record streaming error to history (works with any accumulator type) */
+function recordStreamError(opts) {
+	const { acc, fallbackModel, ctx, error, endpoint } = opts;
+	const model = acc.model || fallbackModel;
+	recordResponse(ctx.historyId, {
+		success: false,
+		model,
+		usage: {
+			input_tokens: 0,
+			output_tokens: 0
+		},
+		error: formatError(error),
+		content: null
+	}, Date.now() - ctx.startTime);
+	const metrics = extractErrorMetrics(error);
+	captureRequest({
+		model,
+		inputTokens: acc.inputTokens ?? 0,
+		outputTokens: acc.outputTokens ?? 0,
+		durationMs: Date.now() - ctx.startTime,
+		success: false,
+		stream: true,
+		toolCount: 0,
+		...metrics,
+		errorPhase: "mid_stream",
+		endpoint,
+		attempt: 1
+	});
 }
+
+//#endregion
+//#region src/routes/tracker-mutations.ts
 /**
-* Echo the requested model id into an already-parsed SSE event payload at the
-* client write-out boundary. Thin context-aware wrapper over
-* {@link echoModelInParsedEvent}; MUST be called AFTER the stream accumulator
-* (the observability data source) has read the upstream value.
+* TUI tracker mutations and analytics completion.
+*
+* All in-place updates to the TUI request tracker (model, status, resolved
+* model) and the success/failure terminal transitions. `completeTracking`
+* additionally emits a PostHog analytics event for successful requests; error
+* paths emit their PostHog events through `observability-recording.ts`.
 */
-function echoParsedEvent(event, ctx) {
-	return echoModelInParsedEvent(event, requestedModelOf(ctx));
-}
 /** Helper to update tracker model */
 function updateTrackerModel(trackingId, model, resolvedModel) {
 	if (!trackingId) return;
@@ -4110,36 +4597,6 @@ function updateTrackerStatus(trackingId, status) {
 	if (!trackingId) return;
 	requestTracker.updateRequest(trackingId, { status });
 }
-/** Record error response to history */
-function recordErrorResponse(ctx, model, error, endpoint, stream) {
-	recordResponse(ctx.historyId, {
-		success: false,
-		model,
-		usage: {
-			input_tokens: 0,
-			output_tokens: 0
-		},
-		error: error instanceof Error ? error.message : "Unknown error",
-		content: null
-	}, Date.now() - ctx.startTime);
-	if (endpoint !== void 0) {
-		const metrics = extractErrorMetrics(error);
-		const { attempts } = getRetryAttempts(error);
-		captureRequest({
-			model,
-			inputTokens: 0,
-			outputTokens: 0,
-			durationMs: Date.now() - ctx.startTime,
-			success: false,
-			stream: stream ?? false,
-			toolCount: 0,
-			...metrics,
-			errorPhase: stream ? "pre_stream" : "non_stream",
-			endpoint,
-			attempt: attempts
-		});
-	}
-}
 /** Complete TUI tracking and send PostHog analytics */
 function completeTracking(trackingId, inputTokens, outputTokens, queueWaitMs, reasoningTokens, analytics) {
 	if (!trackingId) return;
@@ -4166,149 +4623,90 @@ function completeTracking(trackingId, inputTokens, outputTokens, queueWaitMs, re
 		stopReason: analytics.stopReason
 	});
 }
-function formatError(error) {
-	if (error instanceof Error) return error.message || error.name;
-	if (typeof error === "string") return error;
-	try {
-		const s = JSON.stringify(error);
-		if (s && s !== "{}") return s;
-	} catch {}
-	try {
-		return String(error);
-	} catch {
-		return "Unknown error";
-	}
-}
 /** Fail TUI tracking */
 function failTracking(trackingId, error) {
 	if (!trackingId) return;
 	requestTracker.failRequest(trackingId, formatError(error));
 }
+
+//#endregion
+//#region src/routes/entry-context.ts
 /**
-* Create a marker to prepend to responses indicating auto-truncation occurred.
-* Works with both OpenAI and Anthropic truncate results.
+* Construct the route-entry context for any handler.
+*
+* Returns `{ ctx, payload }` where `payload` is the normalized version of
+* `rawPayload` (possibly unchanged) and `ctx` is fully populated with the
+* captured R, history id, tracking id, and start time.
 */
-function createTruncationMarker$1(result) {
-	if (!result.wasCompacted) return "";
-	const { originalTokens, compactedTokens, removedMessageCount } = result;
-	if (originalTokens === void 0 || compactedTokens === void 0 || removedMessageCount === void 0) return `\n\n---\n[Auto-truncated: conversation history was reduced to fit context limits]`;
-	const reduction = originalTokens - compactedTokens;
-	return `\n\n---\n[Auto-truncated: ${removedMessageCount} messages removed, ${originalTokens} → ${compactedTokens} tokens (${Math.round(reduction / originalTokens * 100)}% reduction)]`;
-}
-/** Record streaming error to history (works with any accumulator type) */
-function recordStreamError(opts) {
-	const { acc, fallbackModel, ctx, error, endpoint } = opts;
-	const model = acc.model || fallbackModel;
-	recordResponse(ctx.historyId, {
-		success: false,
-		model,
-		usage: {
-			input_tokens: 0,
-			output_tokens: 0
-		},
-		error: formatError(error),
-		content: null
-	}, Date.now() - ctx.startTime);
-	if (endpoint !== void 0) {
-		const metrics = extractErrorMetrics(error);
-		captureRequest({
-			model,
-			inputTokens: acc.inputTokens ?? 0,
-			outputTokens: acc.outputTokens ?? 0,
-			durationMs: Date.now() - ctx.startTime,
-			success: false,
-			stream: true,
-			toolCount: 0,
-			...metrics,
-			errorPhase: "mid_stream",
-			endpoint,
-			attempt: 1
-		});
-	}
-}
-/** Type guard for non-streaming responses */
-function isNonStreaming(response) {
-	return Object.hasOwn(response, "choices");
-}
-/** Build final payload with auto-truncate if needed */
-async function buildFinalPayload(payload, model, autoTruncateConfig = {}) {
-	if (!state.autoTruncate || !model) {
-		if (state.autoTruncate && !model) consola.warn(`Auto-truncate: Model '${payload.model}' not found in cached models, skipping`);
-		return {
-			finalPayload: payload,
-			truncateResult: null
-		};
-	}
-	try {
-		const check = await checkNeedsCompactionOpenAI(payload, model, autoTruncateConfig);
-		consola.debug(`Auto-truncate check: ${check.currentTokens} tokens (limit ${check.tokenLimit}), ${Math.round(check.currentBytes / 1024)}KB (limit ${check.byteLimit === Infinity ? "unlimited" : `${Math.round(check.byteLimit / 1024)}KB`}), needed: ${check.needed}${check.reason ? ` (${check.reason})` : ""}`);
-		if (!check.needed) return {
-			finalPayload: payload,
-			truncateResult: null
-		};
-		let reasonText;
-		if (check.reason === "both") reasonText = "tokens and size";
-		else if (check.reason === "bytes") reasonText = "size";
-		else reasonText = "tokens";
-		consola.info(`Auto-truncate triggered: exceeds ${reasonText} limit`);
-		const truncateResult = await autoTruncateOpenAI(payload, model, autoTruncateConfig);
-		return {
-			finalPayload: truncateResult.payload,
-			truncateResult
-		};
-	} catch (error) {
-		consola.warn("Auto-truncate failed, proceeding with original payload:", error instanceof Error ? error.message : error);
-		return {
-			finalPayload: payload,
-			truncateResult: null
-		};
-	}
+function createEntryContext(args) {
+	const requestedModel = captureRequestedModel(args.rawPayload.model);
+	const payload = args.normalizePayload ? args.normalizePayload(args.rawPayload) : args.rawPayload;
+	const trackingId = args.c.get("trackingId");
+	const startTime = (trackingId ? requestTracker.getRequest(trackingId) : void 0)?.startTime ?? Date.now();
+	updateTrackerModel(trackingId, payload.model);
+	return {
+		payload,
+		ctx: {
+			historyId: recordRequest(args.endpoint, args.buildHistoryRequest(payload)),
+			trackingId,
+			startTime,
+			requestedModel
+		}
+	};
 }
+
+//#endregion
+//#region src/routes/response-context.ts
 /**
-* Log helpful debugging information when a 413 error occurs.
-* Also adjusts the dynamic byte limit for future requests.
+* Resolve the requested model id (R) carried on the response context into a
+* {@link RequestedModel}. A context that never captured R (`undefined`) is
+* treated as `context-missing` so the echo passes the upstream value through
+* unchanged — it must never invent an id or throw.
+*
+* `createEntryContext` always populates `requestedModel`, so callers operating
+* on a ctx that came from the entry adapter never hit the `context-missing`
+* branch. The fallback exists for the (theoretically impossible) case where
+* a ctx was constructed by hand without `requestedModel` — e.g., a test
+* fixture or a future code path that bypasses the adapter.
 */
-async function logPayloadSizeInfo(payload, model) {
-	const messageCount = payload.messages.length;
-	const bodySize = JSON.stringify(payload).length;
-	const bodySizeKB = Math.round(bodySize / 1024);
-	onRequestTooLarge(bodySize);
-	let imageCount = 0;
-	let largeMessages = 0;
-	let totalImageSize = 0;
-	for (const msg of payload.messages) {
-		if (Array.isArray(msg.content)) {
-			for (const part of msg.content) if (part.type === "image_url") {
-				imageCount++;
-				if (part.image_url.url.startsWith("data:")) totalImageSize += part.image_url.url.length;
-			}
-		}
-		if ((typeof msg.content === "string" ? msg.content.length : JSON.stringify(msg.content).length) > 5e4) largeMessages++;
-	}
-	consola.info("");
-	consola.info("╭─────────────────────────────────────────────────────────╮");
-	consola.info("│           413 Request Entity Too Large                  │");
-	consola.info("╰─────────────────────────────────────────────────────────╯");
-	consola.info("");
-	consola.info(`  Request body size: ${bodySizeKB} KB (${bodySize.toLocaleString()} bytes)`);
-	consola.info(`  Message count: ${messageCount}`);
-	if (model) try {
-		const tokenCount = await getTokenCount(payload, model);
-		const limit = model.capabilities?.limits?.max_prompt_tokens ?? 128e3;
-		consola.info(`  Estimated tokens: ${tokenCount.input.toLocaleString()} / ${limit.toLocaleString()}`);
-	} catch {}
-	if (imageCount > 0) {
-		const imageSizeKB = Math.round(totalImageSize / 1024);
-		consola.info(`  Images: ${imageCount} (${imageSizeKB} KB base64 data)`);
-	}
-	if (largeMessages > 0) consola.info(`  Large messages (>50KB): ${largeMessages}`);
-	consola.info("");
-	consola.info("  Suggestions:");
-	if (!state.autoTruncate) consola.info("    • Enable --auto-truncate to automatically truncate history");
-	if (imageCount > 0) consola.info("    • Remove or resize large images in the conversation");
-	consola.info("    • Start a new conversation with /clear or /reset");
-	consola.info("    • Reduce conversation history by deleting old messages");
-	consola.info("");
+function requestedModelOf(ctx) {
+	return ctx.requestedModel ?? { kind: "context-missing" };
+}
+/**
+* Echo the requested model id into a JSON response body at the client write-out
+* boundary. Thin context-aware wrapper over {@link echoModelInResponseBody};
+* MUST be called AFTER history/posthog/TUI have read the upstream value.
+*/
+function echoResponseBody(body, ctx) {
+	return echoModelInResponseBody(body, requestedModelOf(ctx));
+}
+/**
+* Echo the requested model id into an already-parsed SSE event payload at the
+* client write-out boundary. Thin context-aware wrapper over
+* {@link echoModelInParsedEvent}; MUST be called AFTER the stream accumulator
+* (the observability data source) has read the upstream value.
+*/
+function echoParsedEvent(event, ctx) {
+	return echoModelInParsedEvent(event, requestedModelOf(ctx));
+}
+
+//#endregion
+//#region src/routes/truncation-marker.ts
+/**
+* Create a marker to prepend to responses indicating auto-truncation occurred.
+* Works with both OpenAI and Anthropic truncate results.
+*
+* Distinct from the file-private `createTruncationMarker` helpers in
+* `lib/auto-truncate-{openai,anthropic}.ts` — those build a synthetic upstream
+* `Message`/`AnthropicMessage` used as a no-system-message fallback inside the
+* truncate algorithm; this one returns the client-facing display suffix.
+*/
+function formatClientTruncationMarker(result) {
+	if (!result.wasCompacted) return "";
+	const { originalTokens, compactedTokens, removedMessageCount } = result;
+	if (originalTokens === void 0 || compactedTokens === void 0 || removedMessageCount === void 0) return `\n\n---\n[Auto-truncated: conversation history was reduced to fit context limits]`;
+	const reduction = originalTokens - compactedTokens;
+	return `\n\n---\n[Auto-truncated: ${removedMessageCount} messages removed, ${originalTokens} → ${compactedTokens} tokens (${Math.round(reduction / originalTokens * 100)}% reduction)]`;
 }
 
 //#endregion
@@ -4317,28 +4715,24 @@ function getReasoningTokensFromOpenAIUsage(usage) {
 	return usage?.completion_tokens_details?.reasoning_tokens;
 }
 async function handleCompletion$1(c) {
-	const originalPayload = await c.req.json();
-	consola.debug("Request payload:", JSON.stringify(originalPayload).slice(-400));
-	const requestedModel = captureRequestedModel(originalPayload.model);
-	const trackingId = c.get("trackingId");
-	const startTime = (trackingId ? requestTracker.getRequest(trackingId) : void 0)?.startTime ?? Date.now();
-	updateTrackerModel(trackingId, originalPayload.model);
-	const ctx = {
-		historyId: recordRequest("openai", {
-			model: originalPayload.model,
-			messages: convertOpenAIMessages(originalPayload.messages),
-			stream: originalPayload.stream ?? false,
-			tools: originalPayload.tools?.map((t) => ({
+	const rawPayload = await c.req.json();
+	consola.debug("Request payload:", JSON.stringify(rawPayload).slice(-400));
+	const { ctx, payload: originalPayload } = createEntryContext({
+		c,
+		rawPayload,
+		endpoint: "openai",
+		buildHistoryRequest: (p) => ({
+			model: p.model,
+			messages: convertOpenAIMessages(p.messages),
+			stream: p.stream ?? false,
+			tools: p.tools?.map((t) => ({
 				name: t.function.name,
 				description: t.function.description
 			})),
-			max_tokens: originalPayload.max_tokens ?? void 0,
-			temperature: originalPayload.temperature ?? void 0
-		}),
-		trackingId,
-		startTime,
-		requestedModel
-	};
+			max_tokens: p.max_tokens ?? void 0,
+			temperature: p.temperature ?? void 0
+		})
+	});
 	const selectedModel = findModelById(originalPayload.model);
 	await logTokenCount(originalPayload, selectedModel);
 	const { finalPayload, truncateResult } = await buildFinalPayload(originalPayload, selectedModel);
@@ -4353,21 +4747,20 @@ async function handleCompletion$1(c) {
 		c,
 		payload,
 		selectedModel,
-		ctx,
-		trackingId
+		ctx
 	});
 }
 /**
 * Execute the API call with enhanced error handling for 413 errors.
 */
 async function executeRequest(opts) {
-	const { c, payload, selectedModel, ctx, trackingId } = opts;
+	const { c, payload, selectedModel, ctx } = opts;
 	try {
 		const { result: response, queueWaitMs } = await executeWithAdaptiveRateLimit(() => createChatCompletions(payload, { resolvedModel: selectedModel }));
 		ctx.queueWaitMs = queueWaitMs;
 		if (isNonStreaming(response)) return handleNonStreamingResponse$1(c, response, ctx, payload);
 		consola.debug("Streaming response");
-		updateTrackerStatus(trackingId, "streaming");
+		updateTrackerStatus(ctx.trackingId, "streaming");
 		return streamSSE(c, async (stream) => {
 			await handleStreamingResponse$1({
 				stream,
@@ -4397,7 +4790,7 @@ function handleNonStreamingResponse$1(c, originalResponse, ctx, payload) {
 	consola.debug("Non-streaming response:", JSON.stringify(originalResponse));
 	let response = originalResponse;
 	if (state.verbose && ctx.truncateResult?.wasCompacted && response.choices[0]?.message.content) {
-		const marker = createTruncationMarker$1(ctx.truncateResult);
+		const marker = formatClientTruncationMarker(ctx.truncateResult);
 		response = {
 			...response,
 			choices: response.choices.map((choice, i) => i === 0 ? {
@@ -4483,7 +4876,7 @@ async function handleStreamingResponse$1(opts) {
 	const checkRepetition = createStreamRepetitionChecker(`openai:${payload.model}`);
 	try {
 		if (state.verbose && ctx.truncateResult?.wasCompacted) {
-			const marker = createTruncationMarker$1(ctx.truncateResult);
+			const marker = formatClientTruncationMarker(ctx.truncateResult);
 			const markerChunk = {
 				id: `compact-marker-${Date.now()}`,
 				object: "chat.completion.chunk",
@@ -4664,51 +5057,6 @@ completionRoutes.post("/", async (c) => {
 	}
 });
 
-//#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 copilotFetch("/embeddings", {
-		method: "POST",
-		headers: copilotHeaders(state),
-		body: JSON.stringify(payload)
-	});
-	if (!response.ok) throw await HTTPError.fromResponse("Failed to create embeddings", response);
-	return await response.json();
-};
-
-//#endregion
-//#region src/routes/embeddings/route.ts
-const embeddingRoutes = new Hono();
-function isRecord(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-embeddingRoutes.post("/", async (c) => {
-	const startTime = Date.now();
-	try {
-		const rawBody = await c.req.json();
-		const payload = rawBody;
-		const requestedModel = captureRequestedModel(isRecord(rawBody) ? rawBody.model : void 0);
-		const response = await createEmbeddings(payload);
-		if (!isRecord(response)) return c.json(response);
-		const upstreamModel = typeof response.model === "string" ? response.model : "";
-		const usage = response.usage;
-		captureRequest({
-			model: upstreamModel,
-			inputTokens: isRecord(usage) && typeof usage.prompt_tokens === "number" ? usage.prompt_tokens : 0,
-			outputTokens: 0,
-			durationMs: Date.now() - startTime,
-			success: true,
-			stream: false,
-			toolCount: 0,
-			endpoint: "embeddings"
-		});
-		return c.json(echoTopLevelModel(response, requestedModel));
-	} catch (error) {
-		return forwardError(c, error);
-	}
-});
-
 //#endregion
 //#region src/routes/event-logging/route.ts
 const eventLoggingRoutes = new Hono();
@@ -4717,509 +5065,11 @@ eventLoggingRoutes.post("/batch", (c) => {
 });
 
 //#endregion
-//#region src/routes/gemini/error.ts
-const STATUS_MAP = {
-	400: "INVALID_ARGUMENT",
-	401: "PERMISSION_DENIED",
-	403: "PERMISSION_DENIED",
-	404: "NOT_FOUND",
-	413: "INVALID_ARGUMENT",
-	429: "RESOURCE_EXHAUSTED",
-	500: "INTERNAL"
-};
-function geminiError(c, code, status, message) {
-	return c.json({ error: {
-		code,
-		message,
-		status
-	} }, code);
-}
-function forwardGeminiError(c, error) {
-	if (error instanceof HTTPError) {
-		const status = STATUS_MAP[error.status] ?? "INTERNAL";
-		const code = error.status;
-		let message = error.responseText;
-		try {
-			const parsed = JSON.parse(error.responseText);
-			if (parsed.error?.message) message = parsed.error.message;
-		} catch {}
-		consola.error(`HTTP ${code}:`, message.slice(0, 200));
-		return geminiError(c, code, status, message);
-	}
-	consola.error("Unexpected error:", error);
-	return geminiError(c, 500, "INTERNAL", error instanceof Error ? error.message : "Unknown error");
-}
-
-//#endregion
-//#region src/routes/gemini/gemini-to-openai.ts
-function translateGeminiToOpenAI(request, model) {
-	const messages = [];
-	if (request.systemInstruction) {
-		const systemText = extractTextFromParts(request.systemInstruction.parts);
-		if (systemText) messages.push({
-			role: "system",
-			content: systemText
-		});
-	}
-	let globalCallIndex = 0;
-	const callIdQueue = /* @__PURE__ */ new Map();
-	if (!Array.isArray(request.contents)) return { payload: {
-		messages: [],
-		model
-	} };
-	for (const content of request.contents) {
-		const translated = translateContent(content, callIdQueue, () => `call_gemini_${globalCallIndex++}`);
-		messages.push(...translated);
-	}
-	const payload = {
-		messages,
-		model
-	};
-	const config = request.generationConfig;
-	if (config) {
-		if (config.temperature !== void 0) payload.temperature = config.temperature;
-		if (config.topP !== void 0) payload.top_p = config.topP;
-		if (config.maxOutputTokens !== void 0) payload.max_tokens = config.maxOutputTokens;
-		if (config.stopSequences !== void 0) payload.stop = config.stopSequences;
-		if (config.responseMimeType === "application/json") payload.response_format = { type: "json_object" };
-	}
-	if (request.tools) {
-		const tools = translateTools(request.tools);
-		if (tools.length > 0) payload.tools = tools;
-	}
-	if (request.toolConfig?.functionCallingConfig?.mode) payload.tool_choice = {
-		AUTO: "auto",
-		ANY: "required",
-		NONE: "none"
-	}[request.toolConfig.functionCallingConfig.mode];
-	return { payload };
-}
-function mapFunctionCallsToToolCalls(functionCalls, callIdQueue, generateId) {
-	return functionCalls.map((fc) => {
-		const id = generateId();
-		pushToQueue(callIdQueue, fc.functionCall.name, id);
-		return {
-			id,
-			type: "function",
-			function: {
-				name: fc.functionCall.name,
-				arguments: JSON.stringify(fc.functionCall.args)
-			}
-		};
-	});
-}
-function translateContent(content, callIdQueue, generateId) {
-	const role = content.role === "model" ? "assistant" : "user";
-	const messages = [];
-	const textParts = [];
-	const imageParts = [];
-	const functionCalls = [];
-	const functionResponses = [];
-	for (const part of content.parts) if (isTextPart(part)) {
-		if (!part.thought) textParts.push(part);
-	} else if (isInlineDataPart(part)) imageParts.push(part);
-	else if (isFunctionCallPart(part)) functionCalls.push(part);
-	else if (isFunctionResponsePart(part)) functionResponses.push(part);
-	else if (isFileDataPart(part)) throw new HTTPError("fileData parts are not supported", 400, "fileData parts are not supported");
-	if (imageParts.length > 0) {
-		const contentParts = [];
-		for (const part of content.parts) if (isTextPart(part) && !part.thought) contentParts.push({
-			type: "text",
-			text: part.text
-		});
-		else if (isInlineDataPart(part)) contentParts.push({
-			type: "image_url",
-			image_url: { url: `data:${part.inlineData.mimeType};base64,${part.inlineData.data}` }
-		});
-		const msg = {
-			role,
-			content: contentParts
-		};
-		if (functionCalls.length > 0 && role === "assistant") msg.tool_calls = mapFunctionCallsToToolCalls(functionCalls, callIdQueue, generateId);
-		messages.push(msg);
-	} else if (functionCalls.length > 0 && role === "assistant") {
-		const textContent = textParts.length > 0 ? textParts.map((p) => p.text).join("") : null;
-		messages.push({
-			role: "assistant",
-			content: textContent,
-			tool_calls: mapFunctionCallsToToolCalls(functionCalls, callIdQueue, generateId)
-		});
-	} else if (textParts.length > 0) messages.push({
-		role,
-		content: textParts.map((p) => p.text).join("")
-	});
-	let orphanIndex = 0;
-	for (const fr of functionResponses) {
-		const queue = callIdQueue.get(fr.functionResponse.name);
-		const id = queue && queue.length > 0 ? queue.shift() : `call_gemini_orphan_${orphanIndex++}`;
-		messages.push({
-			role: "tool",
-			content: JSON.stringify(fr.functionResponse.response),
-			tool_call_id: id
-		});
-	}
-	return messages;
-}
-function translateTools(geminiTools) {
-	const tools = [];
-	for (const tool of geminiTools) if (tool.functionDeclarations) for (const decl of tool.functionDeclarations) tools.push({
-		type: "function",
-		function: {
-			name: decl.name,
-			description: decl.description,
-			parameters: decl.parameters ?? {
-				type: "object",
-				properties: {}
-			}
-		}
-	});
-	return tools;
-}
-function pushToQueue(queue, name, id) {
-	const existing = queue.get(name);
-	if (existing) existing.push(id);
-	else queue.set(name, [id]);
-}
-function extractTextFromParts(parts) {
-	return parts.filter((p) => "text" in p && (!("thought" in p) || !p.thought)).map((p) => p.text).join("\n");
-}
-function isTextPart(part) {
-	return "text" in part;
-}
-function isInlineDataPart(part) {
-	return "inlineData" in part;
-}
-function isFunctionCallPart(part) {
-	return "functionCall" in part;
-}
-function isFunctionResponsePart(part) {
-	return "functionResponse" in part;
-}
-function isFileDataPart(part) {
-	return "fileData" in part;
-}
-
-//#endregion
-//#region src/routes/gemini/count-tokens-handler.ts
-async function handleGeminiCountTokens(c, model) {
-	try {
-		const { payload } = translateGeminiToOpenAI(await c.req.json(), model);
-		const selectedModel = findModelById(model);
-		if (!selectedModel) {
-			consola.warn("Model not found for count_tokens, returning estimate");
-			return c.json({ totalTokens: 1 });
-		}
-		const tokenCount = await getTokenCount(payload, selectedModel);
-		const totalTokens = tokenCount.input + tokenCount.output;
-		consola.debug(`Gemini countTokens: ${totalTokens} tokens`);
-		return c.json({ totalTokens });
-	} catch (error) {
-		return forwardGeminiError(c, error);
-	}
-}
-
-//#endregion
-//#region src/routes/gemini/openai-to-gemini.ts
-function translateOpenAIResponseToGemini(response, model) {
-	const choice = response.choices.at(0);
-	if (!choice) return {
-		candidates: [],
-		usageMetadata: buildUsageMetadata(response.usage),
-		modelVersion: model
-	};
-	const parts = [];
-	if (choice.message.content) parts.push({ text: choice.message.content });
-	if (choice.message.tool_calls) for (const tc of choice.message.tool_calls) {
-		const args = parseArgs(tc.function.arguments);
-		parts.push({ functionCall: {
-			name: tc.function.name,
-			args
-		} });
-	}
-	if (parts.length === 0) parts.push({ text: "" });
-	return {
-		candidates: [{
-			content: {
-				role: "model",
-				parts
-			},
-			finishReason: mapFinishReason(choice.finish_reason),
-			index: 0
-		}],
-		usageMetadata: buildUsageMetadata(response.usage),
-		modelVersion: model
-	};
-}
-function createGeminiStreamState() {
-	return {
-		toolCalls: /* @__PURE__ */ new Map(),
-		usage: {
-			promptTokens: 0,
-			completionTokens: 0,
-			totalTokens: 0
-		},
-		model: "",
-		finishReason: ""
-	};
-}
-function translateOpenAIChunkToGemini(chunk, state) {
-	const results = [];
-	if (!state.model && chunk.model) state.model = chunk.model;
-	if (chunk.usage) {
-		state.usage.promptTokens = chunk.usage.prompt_tokens;
-		state.usage.completionTokens = chunk.usage.completion_tokens;
-		state.usage.totalTokens = chunk.usage.total_tokens;
-	}
-	const choice = chunk.choices.at(0);
-	if (!choice) return results;
-	const delta = choice.delta;
-	if (delta.tool_calls) for (const tc of delta.tool_calls) {
-		const existing = state.toolCalls.get(tc.index);
-		if (existing) {
-			if (tc.function?.arguments) existing.args += tc.function.arguments;
-		} else {
-			const flushed = flushToolCalls(state, tc.index);
-			if (flushed) results.push(flushed);
-			state.toolCalls.set(tc.index, {
-				name: tc.function?.name ?? "",
-				args: tc.function?.arguments ?? ""
-			});
-		}
-	}
-	if (delta.content) results.push(buildGeminiChunk([{ text: delta.content }], choice.finish_reason, state));
-	if (choice.finish_reason) {
-		state.finishReason = choice.finish_reason;
-		const flushed = flushToolCalls(state);
-		if (flushed) results.push(flushed);
-		if (!delta.content) results.push(buildGeminiChunk([], choice.finish_reason, state));
-	}
-	return results;
-}
-function flushToolCalls(state, belowIndex) {
-	if (state.toolCalls.size === 0) return null;
-	const parts = [];
-	for (const [idx, tc] of state.toolCalls) {
-		if (belowIndex !== void 0 && idx >= belowIndex) continue;
-		const args = parseArgs(tc.args);
-		parts.push({ functionCall: {
-			name: tc.name,
-			args
-		} });
-		state.toolCalls.delete(idx);
-	}
-	if (parts.length === 0) return null;
-	return buildGeminiChunk(parts, null, state);
-}
-function buildGeminiChunk(parts, finishReason, state) {
-	const candidate = {
-		content: {
-			role: "model",
-			parts: parts.length > 0 ? parts : [{ text: "" }]
-		},
-		index: 0
-	};
-	if (finishReason) candidate.finishReason = mapFinishReason(finishReason);
-	return {
-		candidates: [candidate],
-		usageMetadata: {
-			promptTokenCount: state.usage.promptTokens,
-			candidatesTokenCount: state.usage.completionTokens,
-			totalTokenCount: state.usage.totalTokens
-		},
-		modelVersion: state.model
-	};
-}
-function parseArgs(raw) {
-	try {
-		return JSON.parse(raw);
-	} catch {
-		return { raw };
-	}
-}
-function mapFinishReason(reason) {
-	switch (reason) {
-		case "stop":
-		case "tool_calls": return "STOP";
-		case "length": return "MAX_TOKENS";
-		case "content_filter": return "SAFETY";
-		default: return "OTHER";
-	}
-}
-function buildUsageMetadata(usage) {
-	return {
-		promptTokenCount: usage?.prompt_tokens ?? 0,
-		candidatesTokenCount: usage?.completion_tokens ?? 0,
-		totalTokenCount: usage?.total_tokens ?? 0
-	};
-}
-
-//#endregion
-//#region src/routes/gemini/handler.ts
-async function handleGeminiGenerate(c, model, isStream, requestedModel) {
-	try {
-		const geminiRequest = await c.req.json();
-		consola.debug("Gemini request for model:", model, "stream:", isStream);
-		const trackingId = c.get("trackingId");
-		const startTime = Date.now();
-		updateTrackerModel(trackingId, model);
-		const { payload } = translateGeminiToOpenAI(geminiRequest, model);
-		payload.stream = isStream;
-		const selectedModel = findModelById(model);
-		if (isNullish(payload.max_tokens) && selectedModel) payload.max_tokens = selectedModel.capabilities?.limits?.max_output_tokens;
-		const ctx = {
-			historyId: recordRequest("gemini", {
-				model,
-				messages: payload.messages.map((m) => ({
-					role: m.role,
-					content: typeof m.content === "string" ? m.content : JSON.stringify(m.content),
-					tool_calls: m.tool_calls,
-					tool_call_id: m.tool_call_id
-				})),
-				stream: isStream,
-				max_tokens: payload.max_tokens ?? void 0,
-				temperature: payload.temperature ?? void 0
-			}),
-			trackingId,
-			startTime,
-			requestedModel
-		};
-		const { result: response, queueWaitMs } = await executeWithAdaptiveRateLimit(() => createChatCompletions(payload, { resolvedModel: selectedModel }));
-		ctx.queueWaitMs = queueWaitMs;
-		if (isNonStreaming(response)) return handleNonStreamResponse(c, response, model, ctx, payload);
-		consola.debug("Streaming Gemini response");
-		updateTrackerStatus(trackingId, "streaming");
-		return stream(c, async (s) => {
-			c.header("Content-Type", "text/event-stream");
-			c.header("Cache-Control", "no-cache");
-			c.header("Connection", "keep-alive");
-			const streamState = createGeminiStreamState();
-			try {
-				for await (const rawEvent of response) {
-					if (rawEvent.data === "[DONE]") break;
-					let chunk;
-					try {
-						chunk = JSON.parse(rawEvent.data);
-					} catch (parseError) {
-						consola.debug("Failed to parse stream chunk:", parseError);
-						continue;
-					}
-					const geminiChunks = translateOpenAIChunkToGemini(chunk, streamState);
-					for (const gc of geminiChunks) await s.write(`data: ${JSON.stringify(echoParsedEvent(gc, ctx))}\n\n`);
-				}
-				recordResponse(ctx.historyId, {
-					success: true,
-					model: streamState.model || model,
-					usage: {
-						input_tokens: streamState.usage.promptTokens,
-						output_tokens: streamState.usage.completionTokens
-					},
-					content: null
-				}, Date.now() - ctx.startTime);
-				completeTracking(ctx.trackingId, streamState.usage.promptTokens, streamState.usage.completionTokens, ctx.queueWaitMs, void 0, {
-					model: streamState.model || model,
-					stream: true,
-					durationMs: Date.now() - ctx.startTime,
-					stopReason: streamState.finishReason || void 0,
-					toolCount: payload.tools?.length ?? 0
-				});
-			} catch (error) {
-				recordStreamError({
-					acc: { model: streamState.model || model },
-					fallbackModel: model,
-					ctx,
-					error,
-					endpoint: "chat_completions"
-				});
-				failTracking(ctx.trackingId, error);
-				try {
-					await s.write(`data: ${JSON.stringify({ candidates: [{
-						content: {
-							role: "model",
-							parts: [{ text: `\n\n[copilot-api: upstream stream terminated. Please retry.]` }]
-						},
-						finishReason: "OTHER",
-						index: 0
-					}] })}\n\n`);
-				} catch {}
-			}
-		});
-	} catch (error) {
-		const trackingId = c.get("trackingId");
-		if (trackingId) failTracking(trackingId, error);
-		return forwardGeminiError(c, error);
-	}
-}
-function handleNonStreamResponse(c, response, model, ctx, payload) {
-	const geminiResponse = translateOpenAIResponseToGemini(response, model);
-	const usage = response.usage;
-	recordResponse(ctx.historyId, {
-		success: true,
-		model: response.model || model,
-		usage: {
-			input_tokens: usage?.prompt_tokens ?? 0,
-			output_tokens: usage?.completion_tokens ?? 0
-		},
-		stop_reason: response.choices[0]?.finish_reason,
-		content: response.choices[0] ? {
-			role: "assistant",
-			content: response.choices[0].message.content ?? ""
-		} : null
-	}, Date.now() - ctx.startTime);
-	completeTracking(ctx.trackingId, usage?.prompt_tokens ?? 0, usage?.completion_tokens ?? 0, ctx.queueWaitMs, void 0, {
-		model: response.model || model,
-		stream: false,
-		durationMs: Date.now() - ctx.startTime,
-		stopReason: response.choices[0]?.finish_reason,
-		toolCount: payload.tools?.length ?? 0
-	});
-	return c.json(echoResponseBody(geminiResponse, ctx));
-}
-
-//#endregion
-//#region src/routes/gemini/model-alias.ts
-/**
-* Maps Gemini model names to equivalent models available on GitHub Copilot.
-*
-* Two types of aliases:
-*
-* - **Forced**: Always applied regardless of Copilot model availability.
-*   Use when the old model name should never reach the backend.
-*
-* - **Conditional**: Only applied when the requested model is absent from
-*   the Copilot model list, so if Copilot adds native support the request
-*   goes through unchanged.
-*/
-const GEMINI_FORCED_ALIASES = { "gemini-3.1-pro-preview-customtools": "gemini-3.1-pro-preview" };
-const GEMINI_CONDITIONAL_ALIASES = {
-	"gemini-2.5-flash-lite": "gemini-3.5-flash",
-	"gemini-2.5-flash": "gemini-3.5-flash"
-};
-function resolveGeminiModelAlias(model) {
-	if (model in GEMINI_FORCED_ALIASES) return GEMINI_FORCED_ALIASES[model];
-	if (!(model in GEMINI_CONDITIONAL_ALIASES)) return model;
-	if (findModelById(model)) return model;
-	return GEMINI_CONDITIONAL_ALIASES[model];
+//#region src/lib/srvx-bun.ts
+function getBunServerFromRequest(req) {
+	return req.runtime?.bun?.server;
 }
 
-//#endregion
-//#region src/routes/gemini/route.ts
-const geminiRoutes = new Hono();
-geminiRoutes.post("/:modelAction", async (c) => {
-	const modelAction = c.req.param("modelAction");
-	const colonIndex = modelAction.lastIndexOf(":");
-	if (colonIndex === -1) return geminiError(c, 400, "INVALID_ARGUMENT", "Missing action in URL");
-	const rawModel = modelAction.slice(0, Math.max(0, colonIndex));
-	const requestedModel = captureRequestedModel(rawModel);
-	const model = resolveGeminiModelAlias(rawModel);
-	const action = modelAction.slice(Math.max(0, colonIndex + 1));
-	switch (action) {
-		case "generateContent": return handleGeminiGenerate(c, model, false, requestedModel);
-		case "streamGenerateContent": return handleGeminiGenerate(c, model, true, requestedModel);
-		case "countTokens": return handleGeminiCountTokens(c, model);
-		default: return geminiError(c, 400, "INVALID_ARGUMENT", `Unknown action: ${action}`);
-	}
-});
-
 //#endregion
 //#region src/routes/history/api.ts
 function handleGetEntries(c) {
@@ -6717,7 +6567,7 @@ historyRoutes.get("/api/sessions/:id", handleGetSession);
 historyRoutes.delete("/api/sessions/:id", handleDeleteSession);
 historyRoutes.get("/ws", (c) => {
 	if (c.req.header("Upgrade") !== "websocket") return c.text("Expected WebSocket upgrade", 426);
-	if (c.env?.server?.upgrade(c.req.raw)) return new Response(null, { status: 101 });
+	if (getBunServerFromRequest(c.req.raw)?.upgrade(c.req.raw, { data: { kind: "history" } })) return new Response(null, { status: 101 });
 	return c.text("WebSocket upgrade failed", 500);
 });
 historyRoutes.get("/", (c) => {
@@ -8291,7 +8141,7 @@ function handleDirectAnthropicNonStreamingResponse(c, response, ctx, truncateRes
 		stopReason: response.stop_reason ?? void 0
 	});
 	let finalResponse = response;
-	if (state.verbose && truncateResult?.wasCompacted) finalResponse = prependMarkerToResponse(response, createTruncationMarker$1(truncateResult));
+	if (state.verbose && truncateResult?.wasCompacted) finalResponse = prependMarkerToResponse(response, formatClientTruncationMarker(truncateResult));
 	logServerToolBlocks(finalResponse.content);
 	finalResponse = filterServerToolBlocksFromResponse(finalResponse);
 	return c.json(echoResponseBody(finalResponse, ctx));
@@ -8496,7 +8346,7 @@ function handleNonStreamingResponse(opts) {
 	let anthropicResponse = translateToAnthropic(response, toolNameMapping);
 	consola.debug("Translated Anthropic response:", JSON.stringify(anthropicResponse));
 	if (state.verbose && ctx.truncateResult?.wasCompacted) {
-		const marker = createTruncationMarker$1(ctx.truncateResult);
+		const marker = formatClientTruncationMarker(ctx.truncateResult);
 		anthropicResponse = prependMarkerToResponse(anthropicResponse, marker);
 	}
 	recordResponse(ctx.historyId, {
@@ -8551,7 +8401,7 @@ async function handleStreamingResponse(opts) {
 	const checkRepetition = createStreamRepetitionChecker(`translated:${anthropicPayload.model}`);
 	try {
 		if (ctx.truncateResult?.wasCompacted) {
-			const marker = createTruncationMarker$1(ctx.truncateResult);
+			const marker = formatClientTruncationMarker(ctx.truncateResult);
 			await sendTruncationMarkerEvent(stream, streamState, marker);
 			acc.content += marker;
 		}
@@ -8663,37 +8513,34 @@ function resolveModelFromBetaHeader(model, betaHeader) {
 	return resolved;
 }
 async function handleCompletion(c) {
-	const anthropicPayload = await c.req.json();
-	consola.debug("Anthropic request payload:", JSON.stringify(anthropicPayload));
-	const requestedModel = captureRequestedModel(anthropicPayload.model);
-	const betaHeader = c.req.header("anthropic-beta");
-	anthropicPayload.model = resolveModelFromBetaHeader(anthropicPayload.model, betaHeader);
+	const rawPayload = await c.req.json();
+	consola.debug("Anthropic request payload:", JSON.stringify(rawPayload));
+	const { ctx, payload: anthropicPayload } = createEntryContext({
+		c,
+		rawPayload,
+		endpoint: "anthropic",
+		normalizePayload: (p) => ({
+			...p,
+			model: resolveModelFromBetaHeader(p.model, c.req.header("anthropic-beta"))
+		}),
+		buildHistoryRequest: (p) => ({
+			model: p.model,
+			messages: convertAnthropicMessages(p.messages),
+			stream: p.stream ?? false,
+			tools: p.tools?.map((t) => ({
+				name: t.name,
+				description: t.description
+			})),
+			max_tokens: p.max_tokens,
+			temperature: p.temperature,
+			system: extractSystemPrompt(p.system)
+		})
+	});
 	logToolInfo(anthropicPayload);
 	const subagentMarker = parseSubagentMarkerFromFirstUser(anthropicPayload);
 	const initiatorOverride = subagentMarker ? "agent" : void 0;
 	if (subagentMarker) consola.debug("Detected Subagent marker:", JSON.stringify(subagentMarker));
-	const useDirectAnthropicApi = supportsDirectAnthropicApi(anthropicPayload.model);
-	const trackingId = c.get("trackingId");
-	const startTime = (trackingId ? requestTracker.getRequest(trackingId) : void 0)?.startTime ?? Date.now();
-	updateTrackerModel(trackingId, anthropicPayload.model);
-	const ctx = {
-		historyId: recordRequest("anthropic", {
-			model: anthropicPayload.model,
-			messages: convertAnthropicMessages(anthropicPayload.messages),
-			stream: anthropicPayload.stream ?? false,
-			tools: anthropicPayload.tools?.map((t) => ({
-				name: t.name,
-				description: t.description
-			})),
-			max_tokens: anthropicPayload.max_tokens,
-			temperature: anthropicPayload.temperature,
-			system: extractSystemPrompt(anthropicPayload.system)
-		}),
-		trackingId,
-		startTime,
-		requestedModel
-	};
-	if (useDirectAnthropicApi) return handleDirectAnthropicCompletion(c, anthropicPayload, ctx, initiatorOverride);
+	if (supportsDirectAnthropicApi(anthropicPayload.model)) return handleDirectAnthropicCompletion(c, anthropicPayload, ctx, initiatorOverride);
 	return handleTranslatedCompletion(c, anthropicPayload, ctx, initiatorOverride);
 }
 /**
@@ -8793,7 +8640,7 @@ const modelRoutes = new Hono();
 modelRoutes.get("/", async (c) => {
 	try {
 		if (!state.models) await cacheModels();
-		const models = state.models?.data.map((model) => ({
+		const models = state.models?.data.filter((model) => !isHiddenModel(model.id, state.showAllModels)).map((model) => ({
 			id: model.id,
 			object: "model",
 			type: "model",
@@ -9083,33 +8930,34 @@ const TERMINAL_EVENTS = new Set([
 	"error"
 ]);
 const handleResponses = async (c) => {
-	let payload = await c.req.json();
-	const requestedModel = captureRequestedModel(payload.model);
-	if (state.normalizeResponsesCallIds) payload = normalizeCallIds(payload);
+	const { ctx, payload } = createEntryContext({
+		c,
+		rawPayload: await c.req.json(),
+		endpoint: "openai",
+		normalizePayload: (p) => {
+			const np = state.normalizeResponsesCallIds ? normalizeCallIds(p) : p;
+			useFunctionApplyPatch(np);
+			filterUnsupportedBuiltins(np);
+			return np;
+		},
+		buildHistoryRequest: (p) => {
+			const historyTools = convertResponsesToolsToDefinitions(p.tools);
+			return {
+				model: p.model,
+				messages: convertResponsesInputToMessages(p.input),
+				stream: p.stream ?? false,
+				tools: historyTools.length > 0 ? historyTools : void 0,
+				max_tokens: p.max_output_tokens ?? void 0,
+				temperature: p.temperature ?? void 0,
+				system: p.instructions ?? void 0
+			};
+		}
+	});
 	consola.debug("Responses request payload:", JSON.stringify(payload));
-	const trackingId = c.get("trackingId");
-	const startTime = (trackingId ? requestTracker.getRequest(trackingId) : void 0)?.startTime ?? Date.now();
-	updateTrackerModel(trackingId, payload.model);
-	useFunctionApplyPatch(payload);
-	removeWebSearchTool(payload);
 	const model = payload.model;
 	const stream = payload.stream ?? false;
 	const tools = convertResponsesToolsToDefinitions(payload.tools);
-	const historyId = recordRequest("openai", {
-		model,
-		messages: convertResponsesInputToMessages(payload.input),
-		stream,
-		tools: tools.length > 0 ? tools : void 0,
-		max_tokens: payload.max_output_tokens ?? void 0,
-		temperature: payload.temperature ?? void 0,
-		system: payload.instructions ?? void 0
-	});
-	const ctx = {
-		historyId,
-		trackingId,
-		startTime,
-		requestedModel
-	};
+	const { historyId, trackingId, startTime } = ctx;
 	const selectedModel = findModelById(payload.model);
 	if (!(selectedModel?.supported_endpoints?.includes(RESPONSES_ENDPOINT) ?? false)) {
 		recordErrorResponse(ctx, model, /* @__PURE__ */ new Error("This model does not support the responses endpoint."), "responses", stream);
@@ -9149,7 +8997,7 @@ const handleResponses = async (c) => {
 							const parsed = JSON.parse(rawData);
 							if (typeof parsed.sequence_number === "number") lastSequenceNumber = parsed.sequence_number;
 						} catch {}
-						const processedData = fixStreamIds(rawData, eventType, idTracker, requestedModel);
+						const processedData = fixStreamIds(rawData, eventType, idTracker, requestedModelOf(ctx));
 						await stream.writeSSE({
 							id: chunk.id,
 							event: eventType,
@@ -9246,11 +9094,10 @@ const useFunctionApplyPatch = (payload) => {
 		}
 	}
 };
-const removeWebSearchTool = (payload) => {
+const UNSUPPORTED_BUILTIN_TOOL_TYPES = new Set(["web_search", "image_generation"]);
+const filterUnsupportedBuiltins = (payload) => {
 	if (!Array.isArray(payload.tools) || payload.tools.length === 0) return;
-	payload.tools = payload.tools.filter((t) => {
-		return t.type !== "web_search";
-	});
+	payload.tools = payload.tools.filter((t) => typeof t.type !== "string" || !UNSUPPORTED_BUILTIN_TOOL_TYPES.has(t.type));
 };
 /** Record a ResponsesResult to history */
 function recordResponseResult(result, fallbackModel, historyId, startTime) {
@@ -9309,8 +9156,9 @@ usageRoute.get("/", async (c) => {
 const server = new Hono();
 server.use(tuiLogger());
 server.use(cors());
+server.use(authGate());
 server.get("/", (c) => c.text("Server running"));
-server.get("/health", (c) => {
+const healthHandler = (c) => {
 	const healthy = Boolean(state.copilotToken && state.githubToken);
 	return c.json({
 		status: healthy ? "healthy" : "unhealthy",
@@ -9320,20 +9168,19 @@ server.get("/health", (c) => {
 			models: Boolean(state.models)
 		}
 	}, healthy ? 200 : 503);
-});
+};
+server.get("/health", healthHandler);
+server.get("/health/", healthHandler);
 server.route("/chat/completions", completionRoutes);
 server.route("/models", modelRoutes);
-server.route("/embeddings", embeddingRoutes);
 server.route("/usage", usageRoute);
 server.route("/token", tokenRoute);
 server.route("/v1/chat/completions", completionRoutes);
 server.route("/v1/models", modelRoutes);
-server.route("/v1/embeddings", embeddingRoutes);
 server.route("/v1/messages", messageRoutes);
 server.route("/api/event_logging", eventLoggingRoutes);
 server.route("/v1/responses", responsesRoutes);
 server.route("/responses", responsesRoutes);
-server.route("/v1beta/models", geminiRoutes);
 server.route("/history", historyRoutes);
 
 //#endregion
@@ -9365,6 +9212,7 @@ function formatModelInfo(model) {
 }
 async function runServer(options) {
 	consola.info(`copilot-api v${version}`);
+	configureProxyApiKey(options.apiKey);
 	if (options.proxyEnv) initProxyFromEnv();
 	if (options.verbose) {
 		consola.level = 5;
@@ -9381,6 +9229,8 @@ async function runServer(options) {
 	if (options.accountType !== "individual") consola.info(`Using ${options.accountType} plan GitHub account`);
 	state.manualApprove = options.manual;
 	state.showToken = options.showToken;
+	state.showAllModels = options.showAllModels;
+	if (options.showAllModels) consola.warn("--show-all-models: hidden model blacklist is BYPASSED for this run");
 	state.autoTruncate = options.autoTruncate;
 	state.compressToolResults = options.compressToolResults;
 	state.redirectAnthropic = options.redirectAnthropic;
@@ -9425,21 +9275,31 @@ async function runServer(options) {
 		consola.error(error instanceof Error ? error.message : String(error));
 		process.exit(1);
 	}
-	consola.info(`Available models:\n${state.models?.data.map((m) => formatModelInfo(m)).join("\n")}`);
-	const serverUrl = `http://${options.host ?? "localhost"}:${options.port}`;
+	const allModels = state.models?.data ?? [];
+	if (allModels.length === 0) {
+		consola.error(`Upstream returned zero models for account type "${state.accountType}". Verify the account type matches your Copilot plan and that upstream is reachable.`);
+		process.exit(1);
+	}
+	const visibleModels = allModels.filter((m) => !isHiddenModel(m.id, state.showAllModels));
+	if (visibleModels.length === 0) consola.warn("All upstream models are filtered by the hardcoded blacklist. /v1/models will return an empty list, but explicit POSTs with a hidden id still pass through to upstream. Restart with --show-all-models to see the full catalogue.");
+	else consola.info(`Available models:\n${visibleModels.map((m) => formatModelInfo(m)).join("\n")}`);
+	const serverUrl = `http://${resolveClientHost(options.host, process.env.HOST)}:${options.port}`;
 	if (options.claudeCode) {
-		invariant(state.models, "Models should be loaded by now");
+		if (visibleModels.length === 0) {
+			consola.error("--claude-code interactive setup needs at least one visible model. Restart with --show-all-models or update src/lib/hidden-models.ts.");
+			process.exit(1);
+		}
 		const selectedModel = await consola.prompt("Select a model to use with Claude Code", {
 			type: "select",
-			options: state.models.data.map((model) => model.id)
+			options: visibleModels.map((model) => model.id)
 		});
 		const selectedSmallModel = await consola.prompt("Select a small model to use with Claude Code", {
 			type: "select",
-			options: state.models.data.map((model) => model.id)
+			options: visibleModels.map((model) => model.id)
 		});
 		const command = generateEnvScript({
 			ANTHROPIC_BASE_URL: serverUrl,
-			ANTHROPIC_AUTH_TOKEN: "dummy",
+			[CLAUDE_CODE_AUTH_TOKEN_ENV]: CLAUDE_CODE_AUTH_TOKEN_PLACEHOLDER,
 			ANTHROPIC_MODEL: selectedModel,
 			ANTHROPIC_DEFAULT_SONNET_MODEL: selectedModel,
 			ANTHROPIC_SMALL_FAST_MODEL: selectedSmallModel,
@@ -9454,13 +9314,27 @@ async function runServer(options) {
 			consola.warn("Failed to copy to clipboard. Here is the Claude Code command:");
 			consola.log(command);
 		}
+		for (const line of buildClaudeCodeAuthHint(options.apiKeySource)) consola.warn(line);
 	}
 	consola.box(`🌐 Usage Viewer: https://ericc-ch.github.io/copilot-api?endpoint=${serverUrl}/usage${options.history ? `\n📜 History UI: ${serverUrl}/history` : ""}`);
+	for (const line of buildStartupAuthLines({
+		source: options.apiKeySource,
+		bindAddress: resolveBindAddress(options.host, process.env.HOST)
+	})) process.stdout.write(`${line}\n`);
 	setupShutdownHandlers();
 	setServerInstance(serve({
 		fetch: server.fetch,
 		port: options.port,
-		hostname: options.host
+		hostname: options.host,
+		bun: { websocket: {
+			open(ws) {
+				if (ws.data?.kind === "history") addClient(ws);
+			},
+			close(ws) {
+				if (ws.data?.kind === "history") removeClient(ws);
+			},
+			message() {}
+		} }
 	}));
 }
 function parseTimezoneOffset(value) {
@@ -9542,7 +9416,7 @@ const start = defineCommand({
 		"github-token": {
 			alias: "g",
 			type: "string",
-			description: "Provide GitHub token directly (must be generated using the `auth` subcommand)"
+			description: "Provide GitHub token directly (must be generated using the `auth` subcommand). Falls back to the GH_TOKEN env var if the flag is omitted — prefer the env for automation since argv is visible via /proc/<pid>/cmdline."
 		},
 		"claude-code": {
 			alias: "c",
@@ -9555,6 +9429,11 @@ const start = defineCommand({
 			default: false,
 			description: "Show GitHub and Copilot tokens on fetch and refresh"
 		},
+		"show-all-models": {
+			type: "boolean",
+			default: false,
+			description: "Show ALL upstream models, including the hardcoded blacklist (default: false, blacklist filtered from listings)"
+		},
 		"proxy-env": {
 			type: "boolean",
 			default: false,
@@ -9603,9 +9482,17 @@ const start = defineCommand({
 		"posthog-key": {
 			type: "string",
 			description: "PostHog API key for token usage analytics (opt-in, no key = disabled)"
+		},
+		"api-key": {
+			type: "string",
+			description: "Proxy API key for inbound authentication. When set (non-empty after trimming), all endpoints except / and /health require this key via 'Authorization: Bearer <key>'. Omitted or empty = auth disabled (default, all requests pass through)."
 		}
 	},
 	run({ args }) {
+		const resolvedApiKey = resolveProxyApiKey({
+			flag: args["api-key"],
+			env: process.env.COPILOT_API_KEY
+		});
 		return runServer({
 			port: Number.parseInt(args.port, 10),
 			host: args.host,
@@ -9617,9 +9504,10 @@ const start = defineCommand({
 			requestInterval: Number.parseInt(args["request-interval"], 10),
 			recoveryTimeout: Number.parseInt(args["recovery-timeout"], 10),
 			consecutiveSuccesses: Number.parseInt(args["consecutive-successes"], 10),
-			githubToken: args["github-token"],
+			githubToken: args["github-token"] || process.env.GH_TOKEN,
 			claudeCode: args["claude-code"],
 			showToken: args["show-token"],
+			showAllModels: args["show-all-models"],
 			proxyEnv: args["proxy-env"],
 			history: !args["no-history"],
 			historyLimit: Number.parseInt(args["history-limit"], 10),
@@ -9629,7 +9517,9 @@ const start = defineCommand({
 			stripServerTools: args["strip-server-tools"],
 			contextEditing: parseContextEditing(args["context-editing"]),
 			timezoneOffset: parseTimezoneOffset(args["timezone-offset"]),
-			posthogKey: args["posthog-key"]
+			posthogKey: args["posthog-key"],
+			apiKey: resolvedApiKey.key,
+			apiKeySource: resolvedApiKey.source
 		});
 	}
 });