@hsupu/copilot-api 0.8.1-beta.2 → 0.8.3

package/dist/main.mjs

@@ -3,20 +3,21 @@ import { defineCommand, runMain } from "citty";
 import consola, { consola as consola$1 } from "consola";
 import * as fs$1 from "node:fs/promises";
 import fs, { access, constants, readFile } from "node:fs/promises";
+import { randomBytes, randomUUID } from "node:crypto";
 import os, { homedir } from "node:os";
 import * as path$1 from "node:path";
 import path, { dirname, join, resolve } from "node:path";
 import tls from "node:tls";
 import { getProxyForUrl } from "proxy-from-env";
 import { SocksClient } from "socks";
-import { Agent, ProxyAgent, setGlobalDispatcher } from "undici";
-import { randomBytes, randomUUID } from "node:crypto";
+import { Agent, ProxyAgent, WebSocket as WebSocket$1, setGlobalDispatcher } from "undici";
 import pc from "picocolors";
 import { existsSync, promises, readFileSync, readdirSync } from "node:fs";
 import invariant from "tiny-invariant";
 import { events } from "fetch-event-stream";
 import { Hono } from "hono";
 import { streamSSE } from "hono/streaming";
+import { parseDocument } from "yaml";
 import { cors } from "hono/cors";
 import { trimTrailingSlash } from "hono/trailing-slash";
 //#region src/lib/state.ts
@@ -82,47 +83,110 @@ const DEFAULT_MODEL_OVERRIDES = {
 	sonnet: "claude-sonnet-4.6",
 	haiku: "claude-haiku-4.5"
 };
-const mutableState = {
-	accountType: "individual",
-	autoTruncate: true,
-	compressToolResultsBeforeTruncate: true,
-	contextEditingMode: "off",
+/**
+* Default values for config-managed scalar/runtime fields.
+* Single source of truth for mutableState initialization and resetConfigManagedState().
+* Model overrides continue to use DEFAULT_MODEL_OVERRIDES.
+*/
+const CONFIG_MANAGED_DEFAULTS = {
 	stripServerTools: false,
 	immutableThinkingMessages: false,
 	dedupToolCalls: false,
+	stripReadToolResultTags: false,
+	contextEditingMode: "off",
+	contextEditingTrigger: 1e5,
+	contextEditingKeepTools: 3,
+	contextEditingKeepThinking: 1,
+	toolSearchEnabled: true,
+	cacheControlMode: "proxied",
+	nonDeferredTools: [],
+	rewriteSystemReminders: false,
+	systemPromptOverrides: [],
+	compressToolResultsBeforeTruncate: true,
 	fetchTimeout: 300,
+	streamIdleTimeout: 300,
+	staleRequestMaxAge: 600,
+	modelRefreshInterval: 600,
+	shutdownGracefulWait: 60,
+	shutdownAbortWait: 120,
 	historyLimit: 200,
 	historyMinEntries: 50,
+	normalizeResponsesCallIds: true,
+	upstreamWebSocket: false
+};
+function resetConfigManagedState() {
+	setAnthropicBehavior({
+		stripServerTools: CONFIG_MANAGED_DEFAULTS.stripServerTools,
+		immutableThinkingMessages: CONFIG_MANAGED_DEFAULTS.immutableThinkingMessages,
+		dedupToolCalls: CONFIG_MANAGED_DEFAULTS.dedupToolCalls,
+		stripReadToolResultTags: CONFIG_MANAGED_DEFAULTS.stripReadToolResultTags,
+		contextEditingMode: CONFIG_MANAGED_DEFAULTS.contextEditingMode,
+		contextEditingTrigger: CONFIG_MANAGED_DEFAULTS.contextEditingTrigger,
+		contextEditingKeepTools: CONFIG_MANAGED_DEFAULTS.contextEditingKeepTools,
+		contextEditingKeepThinking: CONFIG_MANAGED_DEFAULTS.contextEditingKeepThinking,
+		toolSearchEnabled: CONFIG_MANAGED_DEFAULTS.toolSearchEnabled,
+		cacheControlMode: CONFIG_MANAGED_DEFAULTS.cacheControlMode,
+		nonDeferredTools: [...CONFIG_MANAGED_DEFAULTS.nonDeferredTools],
+		rewriteSystemReminders: CONFIG_MANAGED_DEFAULTS.rewriteSystemReminders,
+		systemPromptOverrides: [...CONFIG_MANAGED_DEFAULTS.systemPromptOverrides],
+		compressToolResultsBeforeTruncate: CONFIG_MANAGED_DEFAULTS.compressToolResultsBeforeTruncate
+	});
+	setModelOverrides({ ...DEFAULT_MODEL_OVERRIDES });
+	setTimeoutConfig({
+		fetchTimeout: CONFIG_MANAGED_DEFAULTS.fetchTimeout,
+		streamIdleTimeout: CONFIG_MANAGED_DEFAULTS.streamIdleTimeout,
+		staleRequestMaxAge: CONFIG_MANAGED_DEFAULTS.staleRequestMaxAge,
+		modelRefreshInterval: CONFIG_MANAGED_DEFAULTS.modelRefreshInterval
+	});
+	setShutdownConfig({
+		shutdownGracefulWait: CONFIG_MANAGED_DEFAULTS.shutdownGracefulWait,
+		shutdownAbortWait: CONFIG_MANAGED_DEFAULTS.shutdownAbortWait
+	});
+	setHistoryConfig({
+		historyLimit: CONFIG_MANAGED_DEFAULTS.historyLimit,
+		historyMinEntries: CONFIG_MANAGED_DEFAULTS.historyMinEntries
+	});
+	setHistoryMaxEntries(CONFIG_MANAGED_DEFAULTS.historyLimit);
+	setResponsesConfig({
+		normalizeResponsesCallIds: CONFIG_MANAGED_DEFAULTS.normalizeResponsesCallIds,
+		upstreamWebSocket: CONFIG_MANAGED_DEFAULTS.upstreamWebSocket
+	});
+}
+const mutableState = {
+	accountType: "individual",
+	autoTruncate: true,
+	compressToolResultsBeforeTruncate: CONFIG_MANAGED_DEFAULTS.compressToolResultsBeforeTruncate,
+	contextEditingMode: CONFIG_MANAGED_DEFAULTS.contextEditingMode,
+	contextEditingTrigger: CONFIG_MANAGED_DEFAULTS.contextEditingTrigger,
+	contextEditingKeepTools: CONFIG_MANAGED_DEFAULTS.contextEditingKeepTools,
+	contextEditingKeepThinking: CONFIG_MANAGED_DEFAULTS.contextEditingKeepThinking,
+	toolSearchEnabled: CONFIG_MANAGED_DEFAULTS.toolSearchEnabled,
+	cacheControlMode: CONFIG_MANAGED_DEFAULTS.cacheControlMode,
+	nonDeferredTools: [...CONFIG_MANAGED_DEFAULTS.nonDeferredTools],
+	stripServerTools: CONFIG_MANAGED_DEFAULTS.stripServerTools,
+	immutableThinkingMessages: CONFIG_MANAGED_DEFAULTS.immutableThinkingMessages,
+	dedupToolCalls: CONFIG_MANAGED_DEFAULTS.dedupToolCalls,
+	fetchTimeout: CONFIG_MANAGED_DEFAULTS.fetchTimeout,
+	historyLimit: CONFIG_MANAGED_DEFAULTS.historyLimit,
+	historyMinEntries: CONFIG_MANAGED_DEFAULTS.historyMinEntries,
 	modelIds: /* @__PURE__ */ new Set(),
 	modelIndex: /* @__PURE__ */ new Map(),
 	modelOverrides: { ...DEFAULT_MODEL_OVERRIDES },
-	rewriteSystemReminders: false,
+	rewriteSystemReminders: CONFIG_MANAGED_DEFAULTS.rewriteSystemReminders,
 	showGitHubToken: false,
-	shutdownAbortWait: 120,
-	shutdownGracefulWait: 60,
-	staleRequestMaxAge: 600,
-	streamIdleTimeout: 300,
-	systemPromptOverrides: [],
-	stripReadToolResultTags: false,
-	normalizeResponsesCallIds: true,
+	shutdownAbortWait: CONFIG_MANAGED_DEFAULTS.shutdownAbortWait,
+	shutdownGracefulWait: CONFIG_MANAGED_DEFAULTS.shutdownGracefulWait,
+	staleRequestMaxAge: CONFIG_MANAGED_DEFAULTS.staleRequestMaxAge,
+	modelRefreshInterval: CONFIG_MANAGED_DEFAULTS.modelRefreshInterval,
+	streamIdleTimeout: CONFIG_MANAGED_DEFAULTS.streamIdleTimeout,
+	systemPromptOverrides: [...CONFIG_MANAGED_DEFAULTS.systemPromptOverrides],
+	stripReadToolResultTags: CONFIG_MANAGED_DEFAULTS.stripReadToolResultTags,
+	normalizeResponsesCallIds: CONFIG_MANAGED_DEFAULTS.normalizeResponsesCallIds,
+	upstreamWebSocket: CONFIG_MANAGED_DEFAULTS.upstreamWebSocket,
 	verbose: false
 };
 const state = mutableState;
 //#endregion
-//#region src/lib/utils.ts
-const sleep = (ms) => new Promise((resolve) => {
-	setTimeout(resolve, ms);
-});
-const isNullish = (value) => value === null || value === void 0;
-/** Convert bytes to KB with rounding */
-function bytesToKB(bytes) {
-	return Math.round(bytes / 1024);
-}
-/** Generate unique ID (timestamp + random) */
-function generateId(randomLength = 7) {
-	return Date.now().toString(36) + Math.random().toString(36).slice(2, 2 + randomLength);
-}
-//#endregion
 //#region src/lib/ws/broadcast.ts
 /** Connected clients indexed by their raw WebSocket instance */
 const clients = /* @__PURE__ */ new Map();
@@ -332,7 +396,8 @@ const historyIndexes = {
 	summaryIndex: /* @__PURE__ */ new Map(),
 	sessionEntryCount: /* @__PURE__ */ new Map(),
 	sessionModelsSet: /* @__PURE__ */ new Map(),
-	sessionToolsSet: /* @__PURE__ */ new Map()
+	sessionToolsSet: /* @__PURE__ */ new Map(),
+	responseSessionIndex: /* @__PURE__ */ new Map()
 };
 const historyStatsCache = {
 	dirty: true,
@@ -344,6 +409,7 @@ function resetHistoryIndexes() {
 	historyIndexes.sessionEntryCount.clear();
 	historyIndexes.sessionModelsSet.clear();
 	historyIndexes.sessionToolsSet.clear();
+	historyIndexes.responseSessionIndex.clear();
 }
 function invalidateHistoryStats() {
 	historyStatsCache.dirty = true;
@@ -400,7 +466,7 @@ function initHistory(enabled, maxEntries) {
 	historyState.maxEntries = maxEntries;
 	historyState.entries = [];
 	historyState.sessions = /* @__PURE__ */ new Map();
-	historyState.currentSessionId = enabled ? generateId() : "";
+	historyState.currentSessionId = "";
 	resetHistoryIndexes();
 	invalidateHistoryStats();
 }
@@ -438,7 +504,7 @@ function getStats() {
 		const model = entry.response?.model || entry.request.model || "unknown";
 		modelDist[model] = (modelDist[model] || 0) + 1;
 		endpointDist[entry.endpoint] = (endpointDist[entry.endpoint] || 0) + 1;
-		const date = new Date(entry.timestamp);
+		const date = new Date(entry.startedAt);
 		const hourKey = `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, "0")}-${String(date.getDate()).padStart(2, "0")}T${String(date.getHours()).padStart(2, "0")}`;
 		hourlyActivity[hourKey] = (hourlyActivity[hourKey] || 0) + 1;
 		if (entry.response) {
@@ -480,7 +546,7 @@ function exportHistory(format = "json") {
 	const headers = [
 		"id",
 		"session_id",
-		"timestamp",
+		"started_at",
 		"endpoint",
 		"request_model",
 		"message_count",
@@ -495,8 +561,8 @@ function exportHistory(format = "json") {
 	];
 	const rows = historyState.entries.map((entry) => [
 		entry.id,
-		entry.sessionId,
-		formatLocalTimestamp(entry.timestamp),
+		entry.sessionId ?? "",
+		formatLocalTimestamp(entry.startedAt),
 		entry.endpoint,
 		entry.request.model,
 		entry.request.messages?.length,
@@ -512,6 +578,118 @@ function exportHistory(format = "json") {
 	return [headers.join(","), ...rows.map((row) => row.map((value) => escapeCsvValue(value)).join(","))].join("\n");
 }
 //#endregion
+//#region src/lib/history/sessions.ts
+const SESSION_HEADER_CANDIDATES = [
+	"x-session-id",
+	"x-conversation-id",
+	"x-chat-session-id",
+	"x-thread-id",
+	"x-interaction-id"
+];
+function normalizeSessionId(value) {
+	if (typeof value !== "string") return void 0;
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : void 0;
+}
+function ensureSession(sessionId, endpoint) {
+	const existing = historyState.sessions.get(sessionId);
+	if (existing) {
+		existing.lastActivity = Date.now();
+		if (!existing.endpoints.includes(endpoint)) existing.endpoints.push(endpoint);
+		historyState.currentSessionId = sessionId;
+		return existing;
+	}
+	const now = Date.now();
+	const session = {
+		id: sessionId,
+		startTime: now,
+		lastActivity: now,
+		requestCount: 0,
+		totalInputTokens: 0,
+		totalOutputTokens: 0,
+		models: [],
+		endpoints: [endpoint]
+	};
+	historyState.sessions.set(sessionId, session);
+	historyIndexes.sessionModelsSet.set(sessionId, /* @__PURE__ */ new Set());
+	historyIndexes.sessionToolsSet.set(sessionId, /* @__PURE__ */ new Set());
+	historyState.currentSessionId = sessionId;
+	return session;
+}
+function getSessionIdFromHeaders(headers) {
+	for (const name of SESSION_HEADER_CANDIDATES) {
+		const normalized = normalizeSessionId(headers instanceof Headers ? headers.get(name) : headers[name]);
+		if (normalized) return normalized;
+	}
+}
+function resolveResponseSessionId(previousResponseId) {
+	const normalized = normalizeSessionId(previousResponseId);
+	if (!normalized) return void 0;
+	return historyIndexes.responseSessionIndex.get(normalized) ?? normalized;
+}
+function registerResponseSession(responseId, sessionId) {
+	const normalizedResponseId = normalizeSessionId(responseId);
+	const normalizedSessionId = normalizeSessionId(sessionId);
+	if (!normalizedResponseId || !normalizedSessionId) return;
+	historyIndexes.responseSessionIndex.set(normalizedResponseId, normalizedSessionId);
+}
+/**
+* Get or create a tracked session when the caller has a real session identifier.
+* Returns undefined when no trustworthy identifier is available.
+*/
+function getCurrentSession(endpoint, sessionId) {
+	const normalized = normalizeSessionId(sessionId);
+	if (!normalized) return void 0;
+	ensureSession(normalized, endpoint);
+	return normalized;
+}
+function getSessions() {
+	const sessions = Array.from(historyState.sessions.values()).sort((a, b) => b.lastActivity - a.lastActivity);
+	return {
+		sessions,
+		total: sessions.length
+	};
+}
+function getSession(id) {
+	return historyState.sessions.get(id);
+}
+function getSessionEntries(sessionId, options = {}) {
+	const { cursor, limit = 50 } = options;
+	const all = historyState.entries.filter((entry) => entry.sessionId === sessionId).sort((a, b) => a.startedAt - b.startedAt);
+	const total = all.length;
+	let startIdx = 0;
+	if (cursor) {
+		const cursorIdx = all.findIndex((entry) => entry.id === cursor);
+		if (cursorIdx !== -1) startIdx = cursorIdx + 1;
+	}
+	const entries = all.slice(startIdx, startIdx + limit);
+	return {
+		entries,
+		total,
+		nextCursor: startIdx + limit < total ? entries.at(-1)?.id ?? null : null,
+		prevCursor: startIdx > 0 ? entries[0]?.id ?? null : null
+	};
+}
+function deleteSession(sessionId) {
+	if (!historyState.sessions.has(sessionId)) return false;
+	const remaining = [];
+	for (const entry of historyState.entries) if (entry.sessionId === sessionId) {
+		historyIndexes.entryIndex.delete(entry.id);
+		historyIndexes.summaryIndex.delete(entry.id);
+	} else remaining.push(entry);
+	historyState.entries = remaining;
+	historyState.sessions.delete(sessionId);
+	historyIndexes.sessionEntryCount.delete(sessionId);
+	historyIndexes.sessionModelsSet.delete(sessionId);
+	historyIndexes.sessionToolsSet.delete(sessionId);
+	for (const [responseId, mappedSessionId] of historyIndexes.responseSessionIndex) if (mappedSessionId === sessionId) historyIndexes.responseSessionIndex.delete(responseId);
+	invalidateHistoryStats();
+	if (historyState.currentSessionId === sessionId) historyState.currentSessionId = "";
+	notifySessionDeleted(sessionId);
+	notifyStatsUpdated(getStats());
+	return true;
+}
+//#endregion
 //#region src/lib/history/entries.ts
 /** Extract a preview from the last user message (first 100 chars) */
 function extractPreviewText(entry) {
@@ -542,9 +720,17 @@ function extractPreviewText(entry) {
 function toSummary(entry) {
 	return {
 		id: entry.id,
-		sessionId: entry.sessionId,
-		timestamp: entry.timestamp,
+		...entry.sessionId ? { sessionId: entry.sessionId } : {},
+		rawPath: entry.rawPath,
+		startedAt: entry.startedAt,
+		endedAt: entry.endedAt,
 		endpoint: entry.endpoint,
+		state: entry.state,
+		active: entry.active,
+		lastUpdatedAt: entry.lastUpdatedAt,
+		queueWaitMs: entry.queueWaitMs,
+		attemptCount: entry.attemptCount,
+		currentStrategy: entry.currentStrategy,
 		requestModel: entry.request.model,
 		stream: entry.request.stream,
 		messageCount: entry.request.messages?.length ?? 0,
@@ -558,6 +744,7 @@ function toSummary(entry) {
 	};
 }
 function updateSessionMetadata(entry) {
+	if (!entry.sessionId) return;
 	const session = historyState.sessions.get(entry.sessionId);
 	if (!session) return;
 	const model = entry.request.model;
@@ -581,6 +768,30 @@ function updateSessionMetadata(entry) {
 		}
 	}
 }
+function attachEntryToSession(entry) {
+	if (!entry.sessionId) return;
+	const sessionId = getCurrentSession(entry.endpoint, entry.sessionId);
+	if (!sessionId) return;
+	const session = historyState.sessions.get(sessionId);
+	if (!session) return;
+	entry.sessionId = sessionId;
+	session.requestCount++;
+	historyIndexes.sessionEntryCount.set(sessionId, (historyIndexes.sessionEntryCount.get(sessionId) ?? 0) + 1);
+	updateSessionMetadata(entry);
+}
+function detachEntryFromSession(entry) {
+	if (!entry.sessionId) return;
+	const sessionId = entry.sessionId;
+	const session = historyState.sessions.get(sessionId);
+	if (session) session.requestCount = Math.max(0, session.requestCount - 1);
+	const sessionCount = (historyIndexes.sessionEntryCount.get(sessionId) ?? 1) - 1;
+	if (sessionCount <= 0) {
+		historyIndexes.sessionEntryCount.delete(sessionId);
+		historyIndexes.sessionModelsSet.delete(sessionId);
+		historyIndexes.sessionToolsSet.delete(sessionId);
+		historyState.sessions.delete(sessionId);
+	} else historyIndexes.sessionEntryCount.set(sessionId, sessionCount);
+}
 function removeOldestEntries(count) {
 	if (count <= 0 || historyState.entries.length === 0) return 0;
 	const actualCount = Math.min(count, historyState.entries.length);
@@ -588,13 +799,7 @@ function removeOldestEntries(count) {
 	for (const entry of removed) {
 		historyIndexes.entryIndex.delete(entry.id);
 		historyIndexes.summaryIndex.delete(entry.id);
-		const sessionCount = (historyIndexes.sessionEntryCount.get(entry.sessionId) ?? 1) - 1;
-		if (sessionCount <= 0) {
-			historyIndexes.sessionEntryCount.delete(entry.sessionId);
-			historyIndexes.sessionModelsSet.delete(entry.sessionId);
-			historyIndexes.sessionToolsSet.delete(entry.sessionId);
-			historyState.sessions.delete(entry.sessionId);
-		} else historyIndexes.sessionEntryCount.set(entry.sessionId, sessionCount);
+		detachEntryFromSession(entry);
 	}
 	if (removed.length > 0) invalidateHistoryStats();
 	return removed.length;
@@ -606,13 +811,9 @@ function evictOldestEntries(count) {
 }
 function insertEntry(entry) {
 	if (!historyState.enabled) return;
-	const session = historyState.sessions.get(entry.sessionId);
-	if (!session) return;
 	historyState.entries.push(entry);
 	historyIndexes.entryIndex.set(entry.id, entry);
-	session.requestCount++;
-	historyIndexes.sessionEntryCount.set(entry.sessionId, (historyIndexes.sessionEntryCount.get(entry.sessionId) ?? 0) + 1);
-	updateSessionMetadata(entry);
+	attachEntryToSession(entry);
 	const summary = toSummary(entry);
 	historyIndexes.summaryIndex.set(entry.id, summary);
 	if (historyState.maxEntries > 0 && historyState.entries.length > historyState.maxEntries) removeOldestEntries(historyState.entries.length - historyState.maxEntries);
@@ -624,19 +825,35 @@ function updateEntry(id, update) {
 	if (!historyState.enabled) return;
 	const entry = historyIndexes.entryIndex.get(id);
 	if (!entry) return;
+	if (update.sessionId !== void 0 && update.sessionId !== entry.sessionId) {
+		detachEntryFromSession(entry);
+		entry.sessionId = update.sessionId;
+		attachEntryToSession(entry);
+	}
 	if (update.request) {
 		entry.request = update.request;
 		updateSessionMetadata(entry);
 	}
+	if (update.rawPath !== void 0) entry.rawPath = update.rawPath;
+	if (update.state !== void 0) entry.state = update.state;
+	if (update.active !== void 0) entry.active = update.active;
+	if (update.lastUpdatedAt !== void 0) entry.lastUpdatedAt = update.lastUpdatedAt;
+	if (update.queueWaitMs !== void 0) entry.queueWaitMs = update.queueWaitMs;
+	if (update.attemptCount !== void 0) entry.attemptCount = update.attemptCount;
+	if (update.currentStrategy !== void 0) entry.currentStrategy = update.currentStrategy;
 	if (update.response) entry.response = update.response;
 	if (update.pipelineInfo) entry.pipelineInfo = update.pipelineInfo;
 	if (update.durationMs !== void 0) entry.durationMs = update.durationMs;
+	if (update.startedAt !== void 0) entry.startedAt = update.startedAt;
+	if (update.endedAt !== void 0) entry.endedAt = update.endedAt;
+	if (update.transport !== void 0) entry.transport = update.transport;
 	if (update.sseEvents) entry.sseEvents = update.sseEvents;
 	if (update.effectiveRequest) entry.effectiveRequest = update.effectiveRequest;
 	if (update.wireRequest) entry.wireRequest = update.wireRequest;
 	if (update.attempts) entry.attempts = update.attempts;
+	if (update.warningMessages) entry.warningMessages = update.warningMessages;
 	if (update.response) {
-		const session = historyState.sessions.get(entry.sessionId);
+		const session = entry.sessionId ? historyState.sessions.get(entry.sessionId) : void 0;
 		if (session) {
 			session.totalInputTokens += update.response.usage.input_tokens;
 			session.totalOutputTokens += update.response.usage.output_tokens;
@@ -652,7 +869,7 @@ function updateEntry(id, update) {
 function clearHistory() {
 	historyState.entries = [];
 	historyState.sessions = /* @__PURE__ */ new Map();
-	historyState.currentSessionId = generateId();
+	historyState.currentSessionId = "";
 	resetHistoryIndexes();
 	invalidateHistoryStats();
 	notifyHistoryCleared();
@@ -673,13 +890,13 @@ function getHistorySummaries(options = {}) {
 	}
 	if (endpoint) summaries = summaries.filter((summary) => summary.endpoint === endpoint);
 	if (success !== void 0) summaries = summaries.filter((summary) => summary.responseSuccess === success);
-	if (from) summaries = summaries.filter((summary) => summary.timestamp >= from);
-	if (to) summaries = summaries.filter((summary) => summary.timestamp <= to);
+	if (from) summaries = summaries.filter((summary) => summary.startedAt >= from);
+	if (to) summaries = summaries.filter((summary) => summary.startedAt <= to);
 	if (search) {
 		const needle = search.toLowerCase();
 		summaries = summaries.filter((summary) => ensureSearchText(summary.id).includes(needle));
 	}
-	summaries.sort((a, b) => b.timestamp - a.timestamp || b.id.localeCompare(a.id));
+	summaries.sort((a, b) => b.startedAt - a.startedAt || b.id.localeCompare(a.id));
 	const total = summaries.length;
 	let startIdx = 0;
 	if (cursor) {
@@ -695,85 +912,6 @@ function getHistorySummaries(options = {}) {
 	};
 }
 //#endregion
-//#region src/lib/history/sessions.ts
-/**
-* Get or create current session.
-* Currently treats all requests as belonging to one session per server lifetime,
-* since clients don't provide session identifiers yet.
-* TODO: When clients support session headers, use that to group requests.
-*/
-function getCurrentSession(endpoint) {
-	if (historyState.currentSessionId) {
-		const session = historyState.sessions.get(historyState.currentSessionId);
-		if (session) {
-			session.lastActivity = Date.now();
-			if (!session.endpoints.includes(endpoint)) session.endpoints.push(endpoint);
-			return historyState.currentSessionId;
-		}
-	}
-	const now = Date.now();
-	const sessionId = generateId();
-	historyState.currentSessionId = sessionId;
-	historyIndexes.sessionModelsSet.set(sessionId, /* @__PURE__ */ new Set());
-	historyIndexes.sessionToolsSet.set(sessionId, /* @__PURE__ */ new Set());
-	historyState.sessions.set(sessionId, {
-		id: sessionId,
-		startTime: now,
-		lastActivity: now,
-		requestCount: 0,
-		totalInputTokens: 0,
-		totalOutputTokens: 0,
-		models: [],
-		endpoints: [endpoint]
-	});
-	return sessionId;
-}
-function getSessions() {
-	const sessions = Array.from(historyState.sessions.values()).sort((a, b) => b.lastActivity - a.lastActivity);
-	return {
-		sessions,
-		total: sessions.length
-	};
-}
-function getSession(id) {
-	return historyState.sessions.get(id);
-}
-function getSessionEntries(sessionId, options = {}) {
-	const { cursor, limit = 50 } = options;
-	const all = historyState.entries.filter((entry) => entry.sessionId === sessionId).sort((a, b) => a.timestamp - b.timestamp);
-	const total = all.length;
-	let startIdx = 0;
-	if (cursor) {
-		const cursorIdx = all.findIndex((entry) => entry.id === cursor);
-		if (cursorIdx !== -1) startIdx = cursorIdx + 1;
-	}
-	const entries = all.slice(startIdx, startIdx + limit);
-	return {
-		entries,
-		total,
-		nextCursor: startIdx + limit < total ? entries.at(-1)?.id ?? null : null,
-		prevCursor: startIdx > 0 ? entries[0]?.id ?? null : null
-	};
-}
-function deleteSession(sessionId) {
-	if (!historyState.sessions.has(sessionId)) return false;
-	const remaining = [];
-	for (const entry of historyState.entries) if (entry.sessionId === sessionId) {
-		historyIndexes.entryIndex.delete(entry.id);
-		historyIndexes.summaryIndex.delete(entry.id);
-	} else remaining.push(entry);
-	historyState.entries = remaining;
-	historyState.sessions.delete(sessionId);
-	historyIndexes.sessionEntryCount.delete(sessionId);
-	historyIndexes.sessionModelsSet.delete(sessionId);
-	historyIndexes.sessionToolsSet.delete(sessionId);
-	invalidateHistoryStats();
-	if (historyState.currentSessionId === sessionId) historyState.currentSessionId = generateId();
-	notifySessionDeleted(sessionId);
-	notifyStatsUpdated(getStats());
-	return true;
-}
-//#endregion
 //#region src/lib/history/memory-pressure.ts
 /**
 * Memory pressure monitor — proactively evicts old history entries
@@ -881,392 +1019,162 @@ function getMemoryPressureStats() {
 	};
 }
 //#endregion
-//#region src/lib/config/paths.ts
-const APP_DIR = path.join(os.homedir(), ".local", "share", "copilot-api");
-const PATHS = {
-	APP_DIR,
-	GITHUB_TOKEN_PATH: path.join(APP_DIR, "github_token"),
-	CONFIG_YAML: path.join(APP_DIR, "config.yaml"),
-	LEARNED_LIMITS: path.join(APP_DIR, "learned-limits.json"),
-	ERROR_DIR: path.join(APP_DIR, "errmsgs")
-};
-async function ensurePaths() {
-	await fs.mkdir(PATHS.APP_DIR, { recursive: true });
-	await ensureFile(PATHS.GITHUB_TOKEN_PATH);
-}
-async function ensureFile(filePath) {
-	const isWindows = process.platform === "win32";
-	try {
-		await fs.access(filePath, fs.constants.W_OK);
-		if (!isWindows) {
-			if (((await fs.stat(filePath)).mode & 511) !== 384) await fs.chmod(filePath, 384);
-		}
-	} catch {
-		await fs.writeFile(filePath, "");
-		if (!isWindows) await fs.chmod(filePath, 384);
-	}
-}
-//#endregion
-//#region src/lib/config/config.ts
+//#region src/lib/copilot-api.ts
+const standardHeaders = () => ({
+	"content-type": "application/json",
+	accept: "application/json"
+});
+const COPILOT_VERSION = "0.38.0";
+const EDITOR_PLUGIN_VERSION = `copilot-chat/${COPILOT_VERSION}`;
+const USER_AGENT = `GitHubCopilotChat/${COPILOT_VERSION}`;
+/** Copilot Chat API version (for chat/completions requests) */
+const COPILOT_API_VERSION = "2025-05-01";
+/** Copilot internal API version (for token & usage endpoints) */
+const COPILOT_INTERNAL_API_VERSION = "2025-04-01";
+/** GitHub public API version (for /user, repos, etc.) */
+const GITHUB_API_VERSION = "2022-11-28";
 /**
-* Application configuration: types, YAML loading, and state application.
-*
-* All config types live here as the single source of truth.
-* config.yaml is loaded with mtime-based caching.
+* Session-level interaction ID.
+* Used to correlate all requests within a single server session.
+* Unlike x-request-id (per-request UUID), this stays constant for the server lifetime.
 */
-/** Compile a raw rewrite rule into a CompiledRewriteRule. Returns null for invalid regex. */
-function compileRewriteRule(raw) {
-	const method = raw.method ?? "regex";
-	let modelPattern;
-	if (raw.model) try {
-		modelPattern = new RegExp(raw.model, "i");
-	} catch (err) {
-		consola.warn(`[config] Invalid model regex in rewrite rule: "${raw.model}"`, err);
-		return null;
-	}
-	if (method === "line") return {
-		from: raw.from,
-		to: raw.to,
-		method,
-		modelPattern
+const INTERACTION_ID = randomUUID();
+const copilotBaseUrl = (state) => state.accountType === "individual" ? "https://api.githubcopilot.com" : `https://api.${state.accountType}.githubcopilot.com`;
+const copilotWsUrl = (state) => copilotBaseUrl(state).replace(/^https:\/\//u, "wss://") + "/responses";
+const copilotHeaders = (state, opts) => {
+	const requestId = randomUUID();
+	const interactionType = opts?.intent ?? "conversation-panel";
+	const headers = {
+		Authorization: `Bearer ${state.copilotToken}`,
+		"content-type": standardHeaders()["content-type"],
+		"copilot-integration-id": "vscode-chat",
+		"editor-version": `vscode/${state.vsCodeVersion}`,
+		"editor-plugin-version": EDITOR_PLUGIN_VERSION,
+		"user-agent": USER_AGENT,
+		"openai-intent": interactionType,
+		"x-github-api-version": COPILOT_API_VERSION,
+		"x-request-id": requestId,
+		"X-Interaction-Id": INTERACTION_ID,
+		"X-Interaction-Type": interactionType,
+		"X-Agent-Task-Id": requestId,
+		"x-vscode-user-agent-library-version": "electron-fetch"
 	};
-	try {
-		let pattern = raw.from;
-		let flags = "gms";
-		const inlineMatch = pattern.match(/^\(\?([a-z]+)\)/i);
-		if (inlineMatch) {
-			pattern = pattern.slice(inlineMatch[0].length);
-			for (const f of inlineMatch[1]) if (!flags.includes(f)) flags += f;
-		}
-		return {
-			from: new RegExp(pattern, flags),
-			to: raw.to,
-			method,
-			modelPattern
-		};
-	} catch (err) {
-		consola.warn(`[config] Invalid regex in rewrite rule: "${raw.from}"`, err);
-		return null;
+	if (opts?.vision) headers["copilot-vision-request"] = "true";
+	if (opts?.modelRequestHeaders) {
+		const coreKeysLower = new Set(Object.keys(headers).map((k) => k.toLowerCase()));
+		for (const [key, value] of Object.entries(opts.modelRequestHeaders)) if (!coreKeysLower.has(key.toLowerCase())) headers[key] = value;
 	}
+	return headers;
+};
+const GITHUB_API_BASE_URL = "https://api.github.com";
+const githubHeaders = (state) => ({
+	...standardHeaders(),
+	authorization: `token ${state.githubToken}`,
+	"editor-version": `vscode/${state.vsCodeVersion}`,
+	"editor-plugin-version": EDITOR_PLUGIN_VERSION,
+	"user-agent": USER_AGENT,
+	"x-github-api-version": GITHUB_API_VERSION,
+	"x-vscode-user-agent-library-version": "electron-fetch"
+});
+const GITHUB_BASE_URL = "https://github.com";
+const GITHUB_CLIENT_ID = "Iv1.b507a08c87ecfe98";
+["read:user"].join(" ");
+/** Fallback VSCode version when GitHub API is unavailable */
+const VSCODE_VERSION_FALLBACK = "1.104.3";
+/** GitHub API endpoint for latest VSCode release */
+const VSCODE_RELEASE_URL = "https://api.github.com/repos/microsoft/vscode/releases/latest";
+/** Fetch the latest VSCode version and cache in global state */
+async function cacheVSCodeVersion() {
+	setVSCodeVersion(await getVSCodeVersion());
 }
-/** Compile an array of raw rewrite rules, skipping invalid ones */
-function compileRewriteRules(raws) {
-	return raws.map((r) => compileRewriteRule(r)).filter((r) => r !== null);
-}
-let cachedConfig = null;
-let configLastMtimeMs = 0;
-/** Time-based debounce: skip stat() if checked recently */
-let lastStatTimeMs = 0;
-const STAT_DEBOUNCE_MS = 2e3;
-async function loadConfig() {
+/** Fetch the latest VSCode version from GitHub releases, falling back to a hardcoded version */
+async function getVSCodeVersion() {
+	const controller = new AbortController();
+	const timeout = setTimeout(() => {
+		controller.abort();
+	}, 5e3);
 	try {
-		const now = Date.now();
-		if (cachedConfig && now - lastStatTimeMs < STAT_DEBOUNCE_MS) return cachedConfig;
-		const stat = await fs.stat(PATHS.CONFIG_YAML);
-		lastStatTimeMs = now;
-		if (cachedConfig && stat.mtimeMs === configLastMtimeMs) return cachedConfig;
-		const content = await fs.readFile(PATHS.CONFIG_YAML, "utf8");
-		const { parse } = await import("yaml");
-		cachedConfig = parse(content) ?? {};
-		configLastMtimeMs = stat.mtimeMs;
-		return cachedConfig;
-	} catch (err) {
-		if (err.code === "ENOENT") return {};
-		try {
-			configLastMtimeMs = (await fs.stat(PATHS.CONFIG_YAML)).mtimeMs;
-		} catch {}
-		consola.warn("[config] Failed to load config.yaml:", err);
-		return {};
+		const response = await fetch(VSCODE_RELEASE_URL, {
+			signal: controller.signal,
+			headers: {
+				Accept: "application/vnd.github.v3+json",
+				"User-Agent": "copilot-api"
+			}
+		});
+		if (!response.ok) return VSCODE_VERSION_FALLBACK;
+		const version = (await response.json()).tag_name;
+		if (version && /^\d+\.\d+\.\d+$/.test(version)) return version;
+		return VSCODE_VERSION_FALLBACK;
+	} catch {
+		return VSCODE_VERSION_FALLBACK;
+	} finally {
+		clearTimeout(timeout);
 	}
 }
-/** Get the mtime of the currently cached config (0 if not loaded) */
-function getConfigMtimeMs() {
-	return configLastMtimeMs;
-}
-let hasApplied = false;
-let lastAppliedMtimeMs = 0;
-/**
-* Load config.yaml and apply all hot-reloadable settings to global state.
-*
-* Scalar fields: only overridden when explicitly present in config (deleted keys keep current runtime value).
-* Collection fields (model_overrides, rewrite_system_reminders array): entire replacement when present.
-*
-* Safe to call per-request — loadConfig() is mtime-cached, so unchanged config
-* only costs one stat() syscall.
-*
-* NOT hot-reloaded: rate_limiter (stateful singleton initialized at startup).
-*/
-async function applyConfigToState() {
-	const config = await loadConfig();
-	if (config.anthropic) {
-		const a = config.anthropic;
-		if (a.strip_server_tools !== void 0) setAnthropicBehavior({ stripServerTools: a.strip_server_tools });
-		if (a.immutable_thinking_messages !== void 0) setAnthropicBehavior({ immutableThinkingMessages: a.immutable_thinking_messages });
-		if (a.dedup_tool_calls !== void 0) setAnthropicBehavior({ dedupToolCalls: a.dedup_tool_calls === true ? "input" : a.dedup_tool_calls });
-		if (a.strip_read_tool_result_tags !== void 0) setAnthropicBehavior({ stripReadToolResultTags: a.strip_read_tool_result_tags });
-		if (a.context_editing !== void 0) setAnthropicBehavior({ contextEditingMode: a.context_editing });
-		if (a.rewrite_system_reminders !== void 0) {
-			if (typeof a.rewrite_system_reminders === "boolean") setAnthropicBehavior({ rewriteSystemReminders: a.rewrite_system_reminders });
-			else if (Array.isArray(a.rewrite_system_reminders)) setAnthropicBehavior({ rewriteSystemReminders: compileRewriteRules(a.rewrite_system_reminders) });
-		}
-	}
-	if (Array.isArray(config.system_prompt_overrides)) setAnthropicBehavior({ systemPromptOverrides: config.system_prompt_overrides.length > 0 ? compileRewriteRules(config.system_prompt_overrides) : [] });
-	if (config.model_overrides) setModelOverrides({
-		...DEFAULT_MODEL_OVERRIDES,
-		...config.model_overrides
-	});
-	if (config.compress_tool_results_before_truncate !== void 0) setAnthropicBehavior({ compressToolResultsBeforeTruncate: config.compress_tool_results_before_truncate });
-	if (config.history) {
-		const h = config.history;
-		if (h.limit !== void 0) {
-			setHistoryConfig({ historyLimit: h.limit });
-			setHistoryMaxEntries(h.limit);
-		}
-		if (h.min_entries !== void 0) setHistoryConfig({ historyMinEntries: h.min_entries });
+//#endregion
+//#region src/lib/error/http-error.ts
+var HTTPError = class HTTPError extends Error {
+	status;
+	responseText;
+	/** Model ID that caused the error (if known) */
+	modelId;
+	/** Original response headers (for Retry-After, quota snapshots, etc.) */
+	responseHeaders;
+	constructor(message, status, responseText, modelId, responseHeaders) {
+		super(message);
+		this.status = status;
+		this.responseText = responseText;
+		this.modelId = modelId;
+		this.responseHeaders = responseHeaders;
 	}
-	if (config.shutdown) {
-		const s = config.shutdown;
-		if (s.graceful_wait !== void 0) setShutdownConfig({ shutdownGracefulWait: s.graceful_wait });
-		if (s.abort_wait !== void 0) setShutdownConfig({ shutdownAbortWait: s.abort_wait });
+	static async fromResponse(message, response, modelId) {
+		const text = await response.text();
+		return new HTTPError(message, response.status, text, modelId, response.headers);
 	}
-	if (config.fetch_timeout !== void 0) setTimeoutConfig({ fetchTimeout: config.fetch_timeout });
-	if (config.stream_idle_timeout !== void 0) setTimeoutConfig({ streamIdleTimeout: config.stream_idle_timeout });
-	if (config.stale_request_max_age !== void 0) setTimeoutConfig({ staleRequestMaxAge: config.stale_request_max_age });
-	const responsesConfig = config["openai-responses"];
-	if (responsesConfig && responsesConfig.normalize_call_ids !== void 0) setResponsesConfig({ normalizeResponsesCallIds: responsesConfig.normalize_call_ids });
-	const currentMtime = getConfigMtimeMs();
-	if (hasApplied && currentMtime !== lastAppliedMtimeMs) consola.info("[config] Reloaded config.yaml");
-	hasApplied = true;
-	lastAppliedMtimeMs = currentMtime;
-	return config;
-}
+};
 //#endregion
-//#region src/lib/proxy.ts
-/**
-* Proxy configuration: HTTP/HTTPS and SOCKS5/5h proxy support.
-*
-* Priority: explicit proxy URL (CLI --proxy or config.yaml) > env vars (--http-proxy-from-env).
-* On Node.js, proxying works via undici's global dispatcher.
-* On Bun, HTTP proxies are set via env vars (Bun handles them natively); SOCKS5 is not supported.
-*/
-/**
-* Initialize proxy for all outgoing fetch requests.
-*
-* On Node.js: sets undici's global dispatcher.
-* On Bun: sets process.env.HTTP_PROXY/HTTPS_PROXY for HTTP proxies (Bun handles natively).
-*
-* Must be called before any network requests.
-*/
-function initProxy(options) {
-	if (typeof Bun !== "undefined") {
-		initProxyBun(options);
-		return;
-	}
-	initProxyNode(options);
+//#region src/lib/error/parsing.ts
+/** Parse token limit info from error message text. */
+function parseTokenLimitError(message) {
+	const openaiMatch = message.match(/prompt token count of (\d+) exceeds the limit of (\d+)/);
+	if (openaiMatch) return {
+		current: Number.parseInt(openaiMatch[1], 10),
+		limit: Number.parseInt(openaiMatch[2], 10)
+	};
+	const anthropicMatch = message.match(/prompt is too long: (\d+) tokens > (\d+) maximum/);
+	if (anthropicMatch) return {
+		current: Number.parseInt(anthropicMatch[1], 10),
+		limit: Number.parseInt(anthropicMatch[2], 10)
+	};
+	return null;
 }
-/** Format a proxy URL for display (strip credentials) */
-function formatProxyDisplay(proxyUrl) {
+/** Extract retry_after from JSON response body. */
+function extractRetryAfterFromBody(responseText) {
 	try {
-		const u = new URL(proxyUrl);
-		const auth = u.username ? `${u.username}:***@` : "";
-		return `${u.protocol}//${auth}${u.host}`;
-	} catch {
-		return proxyUrl;
-	}
+		const parsed = JSON.parse(responseText);
+		if (parsed && typeof parsed === "object") {
+			if ("retry_after" in parsed && typeof parsed.retry_after === "number") return parsed.retry_after;
+			if ("error" in parsed) {
+				const err = parsed.error;
+				if (err && typeof err === "object" && "retry_after" in err && typeof err.retry_after === "number") return err.retry_after;
+			}
+		}
+	} catch {}
 }
-function initProxyNode(options) {
+/** Check if a 503 response body indicates upstream provider rate limiting. */
+function isUpstreamRateLimited(responseText) {
 	try {
-		if (options.url) {
-			setGlobalDispatcher(createDispatcherForUrl(options.url));
-			consola.debug(`Proxy configured: ${formatProxyDisplay(options.url)}`);
-			return;
-		}
-		if (options.fromEnv) {
-			setGlobalDispatcher(new EnvProxyDispatcher());
-			consola.debug("HTTP proxy configured from environment (per-URL)");
-		}
-	} catch (err) {
-		consola.error("Proxy setup failed:", err);
-		throw err;
-	}
-}
-/** Create the appropriate undici dispatcher for a proxy URL scheme */
-function createDispatcherForUrl(proxyUrl) {
-	const url = new URL(proxyUrl);
-	const protocol = url.protocol.toLowerCase();
-	if (protocol === "http:" || protocol === "https:") return new ProxyAgent(proxyUrl);
-	if (protocol === "socks5:" || protocol === "socks5h:") return createSocksAgent(url);
-	throw new Error(`Unsupported proxy protocol: ${protocol}. Supported: http, https, socks5, socks5h`);
-}
-/**
-* Create an undici Agent that routes connections through a SOCKS5/5h proxy.
-*
-* For socks5h:// the proxy performs DNS resolution (hostname passed as-is).
-* For socks5:// the hostname is also passed to the proxy (proxy resolves).
-* Both protocols support username/password authentication via URL credentials.
-*/
-function createSocksAgent(proxyUrl) {
-	const proxy = {
-		host: proxyUrl.hostname,
-		port: Number(proxyUrl.port) || 1080,
-		type: 5
-	};
-	if (proxyUrl.username) {
-		proxy.userId = decodeURIComponent(proxyUrl.username);
-		proxy.password = proxyUrl.password ? decodeURIComponent(proxyUrl.password) : void 0;
-	}
-	return new Agent({ connect(opts, callback) {
-		const destPort = Number(opts.port) || (opts.protocol === "https:" ? 443 : 80);
-		SocksClient.createConnection({
-			proxy,
-			command: "connect",
-			destination: {
-				host: opts.hostname,
-				port: destPort
-			}
-		}).then(({ socket }) => {
-			if (opts.protocol === "https:") callback(null, tls.connect({
-				socket,
-				servername: opts.servername ?? opts.hostname
-			}));
-			else callback(null, socket);
-		}).catch((err) => {
-			callback(err instanceof Error ? err : new Error(String(err)), null);
-		});
-	} });
-}
-/**
-* Custom dispatcher that routes requests through proxies based on environment variables.
-* Uses proxy-from-env to resolve HTTP_PROXY/HTTPS_PROXY/NO_PROXY per-URL.
-*/
-var EnvProxyDispatcher = class extends Agent {
-	proxies = /* @__PURE__ */ new Map();
-	dispatch(options, handler) {
-		try {
-			const origin = this.getOriginUrl(options.origin);
-			const proxyUrl = this.getProxyUrl(origin);
-			if (!proxyUrl) {
-				consola.debug(`HTTP proxy bypass: ${origin.hostname}`);
-				return super.dispatch(options, handler);
-			}
-			const agent = this.getOrCreateProxyAgent(proxyUrl);
-			consola.debug(`HTTP proxy route: ${origin.hostname} via ${formatProxyDisplay(proxyUrl)}`);
-			return agent.dispatch(options, handler);
-		} catch {
-			return super.dispatch(options, handler);
-		}
-	}
-	getOriginUrl(origin) {
-		return typeof origin === "string" ? new URL(origin) : origin;
-	}
-	getProxyUrl(origin) {
-		const raw = getProxyForUrl(origin.toString());
-		return raw && raw.length > 0 ? raw : void 0;
-	}
-	getOrCreateProxyAgent(proxyUrl) {
-		let agent = this.proxies.get(proxyUrl);
-		if (!agent) {
-			agent = new ProxyAgent(proxyUrl);
-			this.proxies.set(proxyUrl, agent);
-		}
-		return agent;
-	}
-	async close() {
-		await super.close();
-		await Promise.all([...this.proxies.values()].map((p) => p.close()));
-		this.proxies.clear();
-	}
-	destroy(errOrCallback, callback) {
-		for (const agent of this.proxies.values()) if (typeof errOrCallback === "function") agent.destroy(errOrCallback);
-		else if (callback) agent.destroy(errOrCallback ?? null, callback);
-		else agent.destroy(errOrCallback ?? null).catch(() => {});
-		this.proxies.clear();
-		if (typeof errOrCallback === "function") {
-			super.destroy(errOrCallback);
-			return;
-		} else if (callback) {
-			super.destroy(errOrCallback ?? null, callback);
-			return;
-		} else return super.destroy(errOrCallback ?? null);
-	}
-};
-/**
-* Initialize proxy for Bun runtime.
-* Bun handles HTTP_PROXY/HTTPS_PROXY env vars natively.
-* SOCKS5 proxies are not supported on Bun.
-*/
-function initProxyBun(options) {
-	if (!options.url) return;
-	const protocol = new URL(options.url).protocol.toLowerCase();
-	if (protocol === "socks5:" || protocol === "socks5h:") throw new Error("SOCKS5 proxy is not supported on Bun runtime. Use Node.js or an HTTP proxy instead.");
-	process.env.HTTP_PROXY = options.url;
-	process.env.HTTPS_PROXY = options.url;
-	consola.debug(`Proxy configured (Bun env): ${formatProxyDisplay(options.url)}`);
-}
-//#endregion
-//#region src/lib/error/http-error.ts
-var HTTPError = class HTTPError extends Error {
-	status;
-	responseText;
-	/** Model ID that caused the error (if known) */
-	modelId;
-	/** Original response headers (for Retry-After, quota snapshots, etc.) */
-	responseHeaders;
-	constructor(message, status, responseText, modelId, responseHeaders) {
-		super(message);
-		this.status = status;
-		this.responseText = responseText;
-		this.modelId = modelId;
-		this.responseHeaders = responseHeaders;
-	}
-	static async fromResponse(message, response, modelId) {
-		const text = await response.text();
-		return new HTTPError(message, response.status, text, modelId, response.headers);
-	}
-};
-//#endregion
-//#region src/lib/error/parsing.ts
-/** Parse token limit info from error message text. */
-function parseTokenLimitError(message) {
-	const openaiMatch = message.match(/prompt token count of (\d+) exceeds the limit of (\d+)/);
-	if (openaiMatch) return {
-		current: Number.parseInt(openaiMatch[1], 10),
-		limit: Number.parseInt(openaiMatch[2], 10)
-	};
-	const anthropicMatch = message.match(/prompt is too long: (\d+) tokens > (\d+) maximum/);
-	if (anthropicMatch) return {
-		current: Number.parseInt(anthropicMatch[1], 10),
-		limit: Number.parseInt(anthropicMatch[2], 10)
-	};
-	return null;
-}
-/** Extract retry_after from JSON response body. */
-function extractRetryAfterFromBody(responseText) {
-	try {
-		const parsed = JSON.parse(responseText);
-		if (parsed && typeof parsed === "object") {
-			if ("retry_after" in parsed && typeof parsed.retry_after === "number") return parsed.retry_after;
-			if ("error" in parsed) {
-				const err = parsed.error;
-				if (err && typeof err === "object" && "retry_after" in err && typeof err.retry_after === "number") return err.retry_after;
-			}
-		}
-	} catch {}
-}
-/** Check if a 503 response body indicates upstream provider rate limiting. */
-function isUpstreamRateLimited(responseText) {
-	try {
-		const parsed = JSON.parse(responseText);
-		if (parsed && typeof parsed === "object" && "error" in parsed) {
-			const err = parsed.error;
-			if (err && typeof err === "object") {
-				const errObj = err;
-				if (typeof errObj.code === "string" && errObj.code.includes("rate")) return true;
-				if (typeof errObj.message === "string") {
-					const msg = errObj.message.toLowerCase();
-					if (msg.includes("rate limit") || msg.includes("too many requests") || msg.includes("quota")) return true;
-				}
-			}
+		const parsed = JSON.parse(responseText);
+		if (parsed && typeof parsed === "object" && "error" in parsed) {
+			const err = parsed.error;
+			if (err && typeof err === "object") {
+				const errObj = err;
+				if (typeof errObj.code === "string" && errObj.code.includes("rate")) return true;
+				if (typeof errObj.message === "string") {
+					const msg = errObj.message.toLowerCase();
+					if (msg.includes("rate limit") || msg.includes("too many requests") || msg.includes("quota")) return true;
+				}
+			}
 		}
 	} catch {
 		const lower = responseText.toLowerCase();
@@ -1625,92 +1533,446 @@ function truncateForLog(text, maxLen) {
 	return `${text.slice(0, maxLen)}… (${text.length} bytes total)`;
 }
 //#endregion
-//#region src/lib/copilot-api.ts
-const standardHeaders = () => ({
-	"content-type": "application/json",
-	accept: "application/json"
-});
-const COPILOT_VERSION = "0.38.0";
-const EDITOR_PLUGIN_VERSION = `copilot-chat/${COPILOT_VERSION}`;
-const USER_AGENT = `GitHubCopilotChat/${COPILOT_VERSION}`;
-/** Copilot Chat API version (for chat/completions requests) */
-const COPILOT_API_VERSION = "2025-05-01";
-/** Copilot internal API version (for token & usage endpoints) */
-const COPILOT_INTERNAL_API_VERSION = "2025-04-01";
-/** GitHub public API version (for /user, repos, etc.) */
-const GITHUB_API_VERSION = "2022-11-28";
+//#region src/lib/fetch-utils.ts
+const SENSITIVE_HEADER_NAMES = new Set([
+	"authorization",
+	"proxy-authorization",
+	"x-api-key",
+	"api-key"
+]);
 /**
-* Session-level interaction ID.
-* Used to correlate all requests within a single server session.
-* Unlike x-request-id (per-request UUID), this stays constant for the server lifetime.
+* Create an AbortSignal for fetch timeout if configured.
+* Controls the time from request start to receiving response headers.
+* Returns undefined if fetchTimeout is 0 (disabled).
 */
-const INTERACTION_ID = randomUUID();
-const copilotBaseUrl = (state) => state.accountType === "individual" ? "https://api.githubcopilot.com" : `https://api.${state.accountType}.githubcopilot.com`;
-const copilotHeaders = (state, opts) => {
-	const headers = {
-		Authorization: `Bearer ${state.copilotToken}`,
-		"content-type": standardHeaders()["content-type"],
-		"copilot-integration-id": "vscode-chat",
-		"editor-version": `vscode/${state.vsCodeVersion}`,
-		"editor-plugin-version": EDITOR_PLUGIN_VERSION,
-		"user-agent": USER_AGENT,
-		"openai-intent": opts?.intent ?? "conversation-panel",
-		"x-github-api-version": COPILOT_API_VERSION,
-		"x-request-id": randomUUID(),
-		"X-Interaction-Id": INTERACTION_ID,
-		"x-vscode-user-agent-library-version": "electron-fetch"
-	};
-	if (opts?.vision) headers["copilot-vision-request"] = "true";
-	if (opts?.modelRequestHeaders) {
-		const coreKeysLower = new Set(Object.keys(headers).map((k) => k.toLowerCase()));
-		for (const [key, value] of Object.entries(opts.modelRequestHeaders)) if (!coreKeysLower.has(key.toLowerCase())) headers[key] = value;
-	}
-	return headers;
-};
-const GITHUB_API_BASE_URL = "https://api.github.com";
-const githubHeaders = (state) => ({
-	...standardHeaders(),
-	authorization: `token ${state.githubToken}`,
-	"editor-version": `vscode/${state.vsCodeVersion}`,
-	"editor-plugin-version": EDITOR_PLUGIN_VERSION,
-	"user-agent": USER_AGENT,
-	"x-github-api-version": GITHUB_API_VERSION,
-	"x-vscode-user-agent-library-version": "electron-fetch"
-});
-const GITHUB_BASE_URL = "https://github.com";
-const GITHUB_CLIENT_ID = "Iv1.b507a08c87ecfe98";
-["read:user"].join(" ");
-/** Fallback VSCode version when GitHub API is unavailable */
-const VSCODE_VERSION_FALLBACK = "1.104.3";
-/** GitHub API endpoint for latest VSCode release */
-const VSCODE_RELEASE_URL = "https://api.github.com/repos/microsoft/vscode/releases/latest";
-/** Fetch the latest VSCode version and cache in global state */
-async function cacheVSCodeVersion() {
-	setVSCodeVersion(await getVSCodeVersion());
+function createFetchSignal() {
+	return state.fetchTimeout > 0 ? AbortSignal.timeout(state.fetchTimeout * 1e3) : void 0;
 }
-/** Fetch the latest VSCode version from GitHub releases, falling back to a hardcoded version */
-async function getVSCodeVersion() {
-	const controller = new AbortController();
-	const timeout = setTimeout(() => {
-		controller.abort();
-	}, 5e3);
+/**
+* Populate a HeadersCapture object with request and response headers.
+* Should be called immediately after fetch(), before !response.ok check,
+* so headers are captured even for error responses.
+*/
+function captureHttpHeaders(capture, requestHeaders, response) {
+	capture.request = sanitizeHeadersForHistory(requestHeaders);
+	capture.response = Object.fromEntries(response.headers.entries());
+}
+/** Return a copy of headers safe to persist in history/error artifacts. */
+function sanitizeHeadersForHistory(headers) {
+	return Object.fromEntries(Object.entries(headers).map(([name, value]) => [name, SENSITIVE_HEADER_NAMES.has(name.toLowerCase()) ? "***" : value]));
+}
+//#endregion
+//#region src/lib/models/client.ts
+/** Fetch models from Copilot API and cache in global state */
+async function cacheModels() {
+	setModels(await getModels());
+}
+const getModels = async () => {
+	const response = await fetch(`${copilotBaseUrl(state)}/models`, {
+		headers: copilotHeaders(state),
+		signal: createFetchSignal()
+	});
+	if (!response.ok) throw await HTTPError.fromResponse("Failed to get models", response);
+	return await response.json();
+};
+//#endregion
+//#region src/lib/models/refresh-loop.ts
+let refreshTimer = null;
+let refreshLoopRunning = false;
+let refreshIntervalSeconds = state.modelRefreshInterval;
+let refreshModelsImpl = cacheModels;
+function clearRefreshTimer() {
+	if (refreshTimer) {
+		clearTimeout(refreshTimer);
+		refreshTimer = null;
+	}
+}
+function logRefreshFailure(error) {
+	const message = error instanceof Error ? error.message : String(error);
+	if (state.models?.data.length) {
+		consola.warn(`[Models] Periodic refresh failed, keeping cached models: ${message}`);
+		return;
+	}
+	consola.error(`[Models] Periodic refresh failed with no cached models: ${message}`);
+}
+function scheduleNextRefresh() {
+	clearRefreshTimer();
+	if (!refreshLoopRunning || refreshIntervalSeconds <= 0) return;
+	refreshTimer = setTimeout(() => {
+		refreshModelsImpl().catch(logRefreshFailure).finally(() => {
+			scheduleNextRefresh();
+		});
+	}, refreshIntervalSeconds * 1e3);
+}
+function startModelRefreshLoop(refreshModels = cacheModels) {
+	refreshLoopRunning = true;
+	refreshModelsImpl = refreshModels;
+	refreshIntervalSeconds = state.modelRefreshInterval;
+	scheduleNextRefresh();
+	return () => {
+		refreshLoopRunning = false;
+		clearRefreshTimer();
+	};
+}
+function syncModelRefreshLoop(intervalSeconds = state.modelRefreshInterval) {
+	refreshIntervalSeconds = intervalSeconds;
+	if (!refreshLoopRunning) return;
+	scheduleNextRefresh();
+}
+//#endregion
+//#region src/lib/config/paths.ts
+const APP_DIR = path.join(os.homedir(), ".local", "share", "copilot-api");
+const PATHS = {
+	APP_DIR,
+	GITHUB_TOKEN_PATH: path.join(APP_DIR, "github_token"),
+	CONFIG_YAML: path.join(APP_DIR, "config.yaml"),
+	LEARNED_LIMITS: path.join(APP_DIR, "learned-limits.json"),
+	REQUEST_TELEMETRY: path.join(APP_DIR, "request-telemetry.json"),
+	ERROR_DIR: path.join(APP_DIR, "errmsgs")
+};
+async function ensurePaths() {
+	await fs.mkdir(PATHS.APP_DIR, { recursive: true });
+	await ensureFile(PATHS.GITHUB_TOKEN_PATH);
+}
+async function ensureFile(filePath) {
+	const isWindows = process.platform === "win32";
 	try {
-		const response = await fetch(VSCODE_RELEASE_URL, {
-			signal: controller.signal,
-			headers: {
-				Accept: "application/vnd.github.v3+json",
-				"User-Agent": "copilot-api"
+		await fs.access(filePath, fs.constants.W_OK);
+		if (!isWindows) {
+			if (((await fs.stat(filePath)).mode & 511) !== 384) await fs.chmod(filePath, 384);
+		}
+	} catch {
+		await fs.writeFile(filePath, "");
+		if (!isWindows) await fs.chmod(filePath, 384);
+	}
+}
+//#endregion
+//#region src/lib/config/config.ts
+/**
+* Application configuration: types, YAML loading, and state application.
+*
+* All config types live here as the single source of truth.
+* config.yaml is loaded with mtime-based caching.
+*/
+/** Compile a raw rewrite rule into a CompiledRewriteRule. Returns null for invalid regex. */
+function compileRewriteRule(raw) {
+	const method = raw.method ?? "regex";
+	let modelPattern;
+	if (raw.model) try {
+		modelPattern = new RegExp(raw.model, "i");
+	} catch (err) {
+		consola.warn(`[config] Invalid model regex in rewrite rule: "${raw.model}"`, err);
+		return null;
+	}
+	if (method === "line") return {
+		from: raw.from,
+		to: raw.to,
+		method,
+		modelPattern
+	};
+	try {
+		let pattern = raw.from;
+		let flags = "gms";
+		const inlineMatch = pattern.match(/^\(\?([a-z]+)\)/i);
+		if (inlineMatch) {
+			pattern = pattern.slice(inlineMatch[0].length);
+			for (const f of inlineMatch[1]) if (!flags.includes(f)) flags += f;
+		}
+		return {
+			from: new RegExp(pattern, flags),
+			to: raw.to,
+			method,
+			modelPattern
+		};
+	} catch (err) {
+		consola.warn(`[config] Invalid regex in rewrite rule: "${raw.from}"`, err);
+		return null;
+	}
+}
+/** Compile an array of raw rewrite rules, skipping invalid ones */
+function compileRewriteRules(raws) {
+	return raws.map((r) => compileRewriteRule(r)).filter((r) => r !== null);
+}
+let cachedConfig = null;
+let configLastMtimeMs = 0;
+/** Time-based debounce: skip stat() if checked recently */
+let lastStatTimeMs = 0;
+const STAT_DEBOUNCE_MS = 2e3;
+async function loadRawConfigFile() {
+	try {
+		const content = await fs.readFile(PATHS.CONFIG_YAML, "utf8");
+		const { parse } = await import("yaml");
+		const parsed = parse(content);
+		if (parsed === null || parsed === void 0) return {};
+		if (typeof parsed !== "object" || Array.isArray(parsed)) throw new TypeError("config.yaml must contain a top-level mapping");
+		return parsed;
+	} catch (err) {
+		if (err.code === "ENOENT") return {};
+		throw err;
+	}
+}
+async function loadConfig() {
+	try {
+		const now = Date.now();
+		if (cachedConfig && now - lastStatTimeMs < STAT_DEBOUNCE_MS) return cachedConfig;
+		const stat = await fs.stat(PATHS.CONFIG_YAML);
+		lastStatTimeMs = now;
+		if (cachedConfig && stat.mtimeMs === configLastMtimeMs) return cachedConfig;
+		cachedConfig = await loadRawConfigFile();
+		configLastMtimeMs = stat.mtimeMs;
+		return cachedConfig;
+	} catch (err) {
+		if (err.code === "ENOENT") return {};
+		try {
+			configLastMtimeMs = (await fs.stat(PATHS.CONFIG_YAML)).mtimeMs;
+		} catch {}
+		consola.warn("[config] Failed to load config.yaml:", err);
+		return {};
+	}
+}
+/** Get the mtime of the currently cached config (0 if not loaded) */
+function getConfigMtimeMs() {
+	return configLastMtimeMs;
+}
+/** Exposed for testing: reset the mtime cache */
+function resetConfigCache() {
+	cachedConfig = null;
+	configLastMtimeMs = 0;
+	lastStatTimeMs = 0;
+}
+let hasApplied = false;
+let lastAppliedMtimeMs = 0;
+/**
+* Load config.yaml and apply all hot-reloadable settings to global state.
+*
+* Scalar fields: only overridden when explicitly present in config (deleted keys keep current runtime value).
+* Collection fields (model_overrides, rewrite_system_reminders array): entire replacement when present.
+*
+* Safe to call per-request — loadConfig() is mtime-cached, so unchanged config
+* only costs one stat() syscall.
+*
+* NOT hot-reloaded: rate_limiter (stateful singleton initialized at startup).
+*/
+async function applyConfigToState() {
+	const config = await loadConfig();
+	if (config.anthropic) {
+		const a = config.anthropic;
+		if (a.strip_server_tools !== void 0) setAnthropicBehavior({ stripServerTools: a.strip_server_tools });
+		if (a.immutable_thinking_messages !== void 0) setAnthropicBehavior({ immutableThinkingMessages: a.immutable_thinking_messages });
+		if (a.dedup_tool_calls !== void 0) setAnthropicBehavior({ dedupToolCalls: a.dedup_tool_calls === true ? "input" : a.dedup_tool_calls });
+		if (a.strip_read_tool_result_tags !== void 0) setAnthropicBehavior({ stripReadToolResultTags: a.strip_read_tool_result_tags });
+		if (a.context_editing !== void 0) setAnthropicBehavior({ contextEditingMode: a.context_editing });
+		if (a.context_editing_trigger !== void 0) setAnthropicBehavior({ contextEditingTrigger: a.context_editing_trigger });
+		if (a.context_editing_keep_tools !== void 0) setAnthropicBehavior({ contextEditingKeepTools: a.context_editing_keep_tools });
+		if (a.context_editing_keep_thinking !== void 0) setAnthropicBehavior({ contextEditingKeepThinking: a.context_editing_keep_thinking });
+		if (a.tool_search !== void 0) setAnthropicBehavior({ toolSearchEnabled: a.tool_search });
+		if (a.cache_control !== void 0) setAnthropicBehavior({ cacheControlMode: a.cache_control });
+		else if (a.auto_cache_control !== void 0) {
+			const mapped = a.auto_cache_control ? "proxied" : "disabled";
+			consola.warn(`[Config] anthropic.auto_cache_control is deprecated, use cache_control: "${mapped}" instead`);
+			setAnthropicBehavior({ cacheControlMode: mapped });
+		}
+		if (Array.isArray(a.non_deferred_tools)) setAnthropicBehavior({ nonDeferredTools: a.non_deferred_tools });
+		if (a.rewrite_system_reminders !== void 0) {
+			if (typeof a.rewrite_system_reminders === "boolean") setAnthropicBehavior({ rewriteSystemReminders: a.rewrite_system_reminders });
+			else if (Array.isArray(a.rewrite_system_reminders)) setAnthropicBehavior({ rewriteSystemReminders: compileRewriteRules(a.rewrite_system_reminders) });
+		}
+	}
+	if (Array.isArray(config.system_prompt_overrides)) setAnthropicBehavior({ systemPromptOverrides: config.system_prompt_overrides.length > 0 ? compileRewriteRules(config.system_prompt_overrides) : [] });
+	if (config.model_overrides) setModelOverrides({
+		...DEFAULT_MODEL_OVERRIDES,
+		...config.model_overrides
+	});
+	if (config.compress_tool_results_before_truncate !== void 0) setAnthropicBehavior({ compressToolResultsBeforeTruncate: config.compress_tool_results_before_truncate });
+	if (config.history) {
+		const h = config.history;
+		if (h.limit !== void 0) {
+			setHistoryConfig({ historyLimit: h.limit });
+			setHistoryMaxEntries(h.limit);
+		}
+		if (h.min_entries !== void 0) setHistoryConfig({ historyMinEntries: h.min_entries });
+	}
+	if (config.shutdown) {
+		const s = config.shutdown;
+		if (s.graceful_wait !== void 0) setShutdownConfig({ shutdownGracefulWait: s.graceful_wait });
+		if (s.abort_wait !== void 0) setShutdownConfig({ shutdownAbortWait: s.abort_wait });
+	}
+	if (config.fetch_timeout !== void 0) setTimeoutConfig({ fetchTimeout: config.fetch_timeout });
+	if (config.stream_idle_timeout !== void 0) setTimeoutConfig({ streamIdleTimeout: config.stream_idle_timeout });
+	if (config.stale_request_max_age !== void 0) setTimeoutConfig({ staleRequestMaxAge: config.stale_request_max_age });
+	if (config.model_refresh_interval !== void 0) setTimeoutConfig({ modelRefreshInterval: config.model_refresh_interval });
+	const responsesConfig = config["openai-responses"];
+	if (responsesConfig && responsesConfig.normalize_call_ids !== void 0) setResponsesConfig({ normalizeResponsesCallIds: responsesConfig.normalize_call_ids });
+	if (responsesConfig && responsesConfig.upstream_websocket !== void 0) setResponsesConfig({ upstreamWebSocket: responsesConfig.upstream_websocket });
+	syncModelRefreshLoop();
+	const currentMtime = getConfigMtimeMs();
+	if (hasApplied && currentMtime !== lastAppliedMtimeMs) consola.info("[config] Reloaded config.yaml");
+	hasApplied = true;
+	lastAppliedMtimeMs = currentMtime;
+	return config;
+}
+//#endregion
+//#region src/lib/proxy.ts
+/**
+* Proxy configuration: HTTP/HTTPS and SOCKS5/5h proxy support.
+*
+* Priority: explicit proxy URL (CLI --proxy or config.yaml) > env vars (--http-proxy-from-env).
+* On Node.js, proxying works via undici's global dispatcher.
+* On Bun, HTTP proxies are set via env vars (Bun handles them natively); SOCKS5 is not supported.
+*/
+/**
+* Initialize proxy for all outgoing fetch requests.
+*
+* On Node.js: sets undici's global dispatcher.
+* On Bun: sets process.env.HTTP_PROXY/HTTPS_PROXY for HTTP proxies (Bun handles natively).
+*
+* Must be called before any network requests.
+*/
+function initProxy(options) {
+	if (typeof Bun !== "undefined") {
+		initProxyBun(options);
+		return;
+	}
+	initProxyNode(options);
+}
+/** Format a proxy URL for display (strip credentials) */
+function formatProxyDisplay(proxyUrl) {
+	try {
+		const u = new URL(proxyUrl);
+		const auth = u.username ? `${u.username}:***@` : "";
+		return `${u.protocol}//${auth}${u.host}`;
+	} catch {
+		return proxyUrl;
+	}
+}
+function initProxyNode(options) {
+	try {
+		if (options.url) {
+			setGlobalDispatcher(createDispatcherForUrl(options.url));
+			consola.debug(`Proxy configured: ${formatProxyDisplay(options.url)}`);
+			return;
+		}
+		if (options.fromEnv) {
+			setGlobalDispatcher(new EnvProxyDispatcher());
+			consola.debug("HTTP proxy configured from environment (per-URL)");
+		}
+	} catch (err) {
+		consola.error("Proxy setup failed:", err);
+		throw err;
+	}
+}
+/** Create the appropriate undici dispatcher for a proxy URL scheme */
+function createDispatcherForUrl(proxyUrl) {
+	const url = new URL(proxyUrl);
+	const protocol = url.protocol.toLowerCase();
+	if (protocol === "http:" || protocol === "https:") return new ProxyAgent(proxyUrl);
+	if (protocol === "socks5:" || protocol === "socks5h:") return createSocksAgent(url);
+	throw new Error(`Unsupported proxy protocol: ${protocol}. Supported: http, https, socks5, socks5h`);
+}
+/**
+* Create an undici Agent that routes connections through a SOCKS5/5h proxy.
+*
+* For socks5h:// the proxy performs DNS resolution (hostname passed as-is).
+* For socks5:// the hostname is also passed to the proxy (proxy resolves).
+* Both protocols support username/password authentication via URL credentials.
+*/
+function createSocksAgent(proxyUrl) {
+	const proxy = {
+		host: proxyUrl.hostname,
+		port: Number(proxyUrl.port) || 1080,
+		type: 5
+	};
+	if (proxyUrl.username) {
+		proxy.userId = decodeURIComponent(proxyUrl.username);
+		proxy.password = proxyUrl.password ? decodeURIComponent(proxyUrl.password) : void 0;
+	}
+	return new Agent({ connect(opts, callback) {
+		const destPort = Number(opts.port) || (opts.protocol === "https:" ? 443 : 80);
+		SocksClient.createConnection({
+			proxy,
+			command: "connect",
+			destination: {
+				host: opts.hostname,
+				port: destPort
 			}
+		}).then(({ socket }) => {
+			if (opts.protocol === "https:") callback(null, tls.connect({
+				socket,
+				servername: opts.servername ?? opts.hostname
+			}));
+			else callback(null, socket);
+		}).catch((err) => {
+			callback(err instanceof Error ? err : new Error(String(err)), null);
 		});
-		if (!response.ok) return VSCODE_VERSION_FALLBACK;
-		const version = (await response.json()).tag_name;
-		if (version && /^\d+\.\d+\.\d+$/.test(version)) return version;
-		return VSCODE_VERSION_FALLBACK;
-	} catch {
-		return VSCODE_VERSION_FALLBACK;
-	} finally {
-		clearTimeout(timeout);
+	} });
+}
+/**
+* Custom dispatcher that routes requests through proxies based on environment variables.
+* Uses proxy-from-env to resolve HTTP_PROXY/HTTPS_PROXY/NO_PROXY per-URL.
+*/
+var EnvProxyDispatcher = class extends Agent {
+	proxies = /* @__PURE__ */ new Map();
+	dispatch(options, handler) {
+		try {
+			const origin = this.getOriginUrl(options.origin);
+			const proxyUrl = this.getProxyUrl(origin);
+			if (!proxyUrl) {
+				consola.debug(`HTTP proxy bypass: ${origin.hostname}`);
+				return super.dispatch(options, handler);
+			}
+			const agent = this.getOrCreateProxyAgent(proxyUrl);
+			consola.debug(`HTTP proxy route: ${origin.hostname} via ${formatProxyDisplay(proxyUrl)}`);
+			return agent.dispatch(options, handler);
+		} catch {
+			return super.dispatch(options, handler);
+		}
+	}
+	getOriginUrl(origin) {
+		return typeof origin === "string" ? new URL(origin) : origin;
+	}
+	getProxyUrl(origin) {
+		const raw = getProxyForUrl(origin.toString());
+		return raw && raw.length > 0 ? raw : void 0;
+	}
+	getOrCreateProxyAgent(proxyUrl) {
+		let agent = this.proxies.get(proxyUrl);
+		if (!agent) {
+			agent = new ProxyAgent(proxyUrl);
+			this.proxies.set(proxyUrl, agent);
+		}
+		return agent;
+	}
+	async close() {
+		await super.close();
+		await Promise.all([...this.proxies.values()].map((p) => p.close()));
+		this.proxies.clear();
+	}
+	destroy(errOrCallback, callback) {
+		for (const agent of this.proxies.values()) if (typeof errOrCallback === "function") agent.destroy(errOrCallback);
+		else if (callback) agent.destroy(errOrCallback ?? null, callback);
+		else agent.destroy(errOrCallback ?? null).catch(() => {});
+		this.proxies.clear();
+		if (typeof errOrCallback === "function") {
+			super.destroy(errOrCallback);
+			return;
+		} else if (callback) {
+			super.destroy(errOrCallback ?? null, callback);
+			return;
+		} else return super.destroy(errOrCallback ?? null);
 	}
+};
+/**
+* Initialize proxy for Bun runtime.
+* Bun handles HTTP_PROXY/HTTPS_PROXY env vars natively.
+* SOCKS5 proxies are not supported on Bun.
+*/
+function initProxyBun(options) {
+	if (!options.url) return;
+	const protocol = new URL(options.url).protocol.toLowerCase();
+	if (protocol === "socks5:" || protocol === "socks5h:") throw new Error("SOCKS5 proxy is not supported on Bun runtime. Use Node.js or an HTTP proxy instead.");
+	process.env.HTTP_PROXY = options.url;
+	process.env.HTTPS_PROXY = options.url;
+	consola.debug(`Proxy configured (Bun env): ${formatProxyDisplay(options.url)}`);
 }
 //#endregion
 //#region src/lib/token/copilot-client.ts
@@ -1914,6 +2176,20 @@ var CopilotTokenManager = class {
 	}
 };
 //#endregion
+//#region src/lib/utils.ts
+const sleep = (ms) => new Promise((resolve) => {
+	setTimeout(resolve, ms);
+});
+const isNullish = (value) => value === null || value === void 0;
+/** Convert bytes to KB with rounding */
+function bytesToKB(bytes) {
+	return Math.round(bytes / 1024);
+}
+/** Generate unique ID (timestamp + random) */
+function generateId(randomLength = 7) {
+	return Date.now().toString(36) + Math.random().toString(36).slice(2, 2 + randomLength);
+}
+//#endregion
 //#region src/lib/token/github-client.ts
 /** GitHub OAuth API client — device code flow and user info */
 const getGitHubUser = async () => {
@@ -2473,49 +2749,6 @@ const checkUsage = defineCommand({
 	}
 });
 //#endregion
-//#region src/lib/fetch-utils.ts
-const SENSITIVE_HEADER_NAMES = new Set([
-	"authorization",
-	"proxy-authorization",
-	"x-api-key",
-	"api-key"
-]);
-/**
-* Create an AbortSignal for fetch timeout if configured.
-* Controls the time from request start to receiving response headers.
-* Returns undefined if fetchTimeout is 0 (disabled).
-*/
-function createFetchSignal() {
-	return state.fetchTimeout > 0 ? AbortSignal.timeout(state.fetchTimeout * 1e3) : void 0;
-}
-/**
-* Populate a HeadersCapture object with request and response headers.
-* Should be called immediately after fetch(), before !response.ok check,
-* so headers are captured even for error responses.
-*/
-function captureHttpHeaders(capture, requestHeaders, response) {
-	capture.request = sanitizeHeadersForHistory(requestHeaders);
-	capture.response = Object.fromEntries(response.headers.entries());
-}
-/** Return a copy of headers safe to persist in history/error artifacts. */
-function sanitizeHeadersForHistory(headers) {
-	return Object.fromEntries(Object.entries(headers).map(([name, value]) => [name, SENSITIVE_HEADER_NAMES.has(name.toLowerCase()) ? "***" : value]));
-}
-//#endregion
-//#region src/lib/models/client.ts
-/** Fetch models from Copilot API and cache in global state */
-async function cacheModels() {
-	setModels(await getModels());
-}
-const getModels = async () => {
-	const response = await fetch(`${copilotBaseUrl(state)}/models`, {
-		headers: copilotHeaders(state),
-		signal: createFetchSignal()
-	});
-	if (!response.ok) throw await HTTPError.fromResponse("Failed to get models", response);
-	return await response.json();
-};
-//#endregion
 //#region src/debug.ts
 async function getPackageVersion() {
 	try {
@@ -3004,6 +3237,284 @@ async function executeWithAdaptiveRateLimit(fn) {
 	return rateLimiterInstance.execute(fn);
 }
 //#endregion
+//#region src/lib/request-telemetry.ts
+const BUCKET_MS = 300 * 1e3;
+const WINDOW_MS = 10080 * 60 * 1e3;
+const PERSIST_INTERVAL_MS = 60 * 1e3;
+let acceptedSinceStart = 0;
+let bucketCounts = /* @__PURE__ */ new Map();
+let modelStatsSinceStart = /* @__PURE__ */ new Map();
+let modelBucketStats = /* @__PURE__ */ new Map();
+let persistTimer$1 = null;
+let telemetryFilePath = PATHS.REQUEST_TELEMETRY;
+function getBucketStart(timestamp) {
+	return Math.floor(timestamp / BUCKET_MS) * BUCKET_MS;
+}
+function createEmptyModelTelemetry() {
+	return {
+		requestCount: 0,
+		successCount: 0,
+		failureCount: 0,
+		totalDurationMs: 0,
+		inputTokens: 0,
+		outputTokens: 0,
+		cacheReadInputTokens: 0,
+		cacheCreationInputTokens: 0,
+		reasoningTokens: 0
+	};
+}
+function isValidPersistedModelTelemetry(value) {
+	if (!value || typeof value !== "object") return false;
+	const stats = value;
+	return typeof stats.requestCount === "number" && typeof stats.successCount === "number" && typeof stats.failureCount === "number" && typeof stats.totalDurationMs === "number" && typeof stats.inputTokens === "number" && typeof stats.outputTokens === "number" && typeof stats.cacheReadInputTokens === "number" && typeof stats.cacheCreationInputTokens === "number" && typeof stats.reasoningTokens === "number";
+}
+function copyPersistedTelemetry(stats) {
+	return {
+		requestCount: stats.requestCount,
+		successCount: stats.successCount,
+		failureCount: stats.failureCount,
+		totalDurationMs: stats.totalDurationMs,
+		inputTokens: stats.inputTokens,
+		outputTokens: stats.outputTokens,
+		cacheReadInputTokens: stats.cacheReadInputTokens,
+		cacheCreationInputTokens: stats.cacheCreationInputTokens,
+		reasoningTokens: stats.reasoningTokens
+	};
+}
+function getOrCreateModelStats(target, model) {
+	const normalizedModel = model.trim() || "unknown";
+	let stats = target.get(normalizedModel);
+	if (!stats) {
+		stats = createEmptyModelTelemetry();
+		target.set(normalizedModel, stats);
+	}
+	return stats;
+}
+function getOrCreateModelBucket(timestamp) {
+	let bucket = modelBucketStats.get(timestamp);
+	if (!bucket) {
+		bucket = /* @__PURE__ */ new Map();
+		modelBucketStats.set(timestamp, bucket);
+	}
+	return bucket;
+}
+function applySettledTelemetry(stats, opts) {
+	const durationMs = Math.max(0, opts.endedAt - opts.startedAt);
+	const usage = opts.usage;
+	stats.requestCount += 1;
+	if (opts.success) stats.successCount += 1;
+	else stats.failureCount += 1;
+	stats.totalDurationMs += durationMs;
+	stats.inputTokens += usage?.input_tokens ?? 0;
+	stats.outputTokens += usage?.output_tokens ?? 0;
+	stats.cacheReadInputTokens += usage?.cache_read_input_tokens ?? 0;
+	stats.cacheCreationInputTokens += usage?.cache_creation_input_tokens ?? 0;
+	stats.reasoningTokens += usage?.output_tokens_details?.reasoning_tokens ?? 0;
+}
+function pruneBuckets(now = Date.now()) {
+	const earliest = getBucketStart(now - WINDOW_MS);
+	for (const key of bucketCounts.keys()) if (key < earliest) bucketCounts.delete(key);
+	for (const key of modelBucketStats.keys()) if (key < earliest) modelBucketStats.delete(key);
+}
+function buildFilledBuckets(now = Date.now()) {
+	const latestBucket = getBucketStart(now);
+	const bucketCount = Math.floor(WINDOW_MS / BUCKET_MS);
+	const firstBucket = latestBucket - (bucketCount - 1) * BUCKET_MS;
+	const result = [];
+	for (let index = 0; index < bucketCount; index++) {
+		const timestamp = firstBucket + index * BUCKET_MS;
+		result.push({
+			timestamp,
+			count: bucketCounts.get(timestamp) ?? 0
+		});
+	}
+	return result;
+}
+function buildModelSnapshots(source) {
+	return [...source].map(([model, stats]) => toModelSnapshot(model, stats)).sort((left, right) => right.requestCount - left.requestCount || right.usage.totalTokens - left.usage.totalTokens || right.totalDurationMs - left.totalDurationMs || left.model.localeCompare(right.model));
+}
+function toUsageTotals(stats) {
+	return {
+		inputTokens: stats.inputTokens,
+		outputTokens: stats.outputTokens,
+		totalTokens: stats.inputTokens + stats.outputTokens,
+		cacheReadInputTokens: stats.cacheReadInputTokens,
+		cacheCreationInputTokens: stats.cacheCreationInputTokens,
+		reasoningTokens: stats.reasoningTokens
+	};
+}
+function toModelSnapshot(model, stats) {
+	return {
+		model,
+		requestCount: stats.requestCount,
+		successCount: stats.successCount,
+		failureCount: stats.failureCount,
+		totalDurationMs: stats.totalDurationMs,
+		averageDurationMs: stats.requestCount > 0 ? stats.totalDurationMs / stats.requestCount : 0,
+		usage: toUsageTotals(stats)
+	};
+}
+function buildLast7dModelSnapshots(now = Date.now()) {
+	pruneBuckets(now);
+	const aggregate = /* @__PURE__ */ new Map();
+	const series = /* @__PURE__ */ new Map();
+	for (const [timestamp, bucket] of modelBucketStats.entries()) for (const [model, stats] of bucket.entries()) {
+		const target = getOrCreateModelStats(aggregate, model);
+		target.requestCount += stats.requestCount;
+		target.successCount += stats.successCount;
+		target.failureCount += stats.failureCount;
+		target.totalDurationMs += stats.totalDurationMs;
+		target.inputTokens += stats.inputTokens;
+		target.outputTokens += stats.outputTokens;
+		target.cacheReadInputTokens += stats.cacheReadInputTokens;
+		target.cacheCreationInputTokens += stats.cacheCreationInputTokens;
+		target.reasoningTokens += stats.reasoningTokens;
+		let buckets = series.get(model);
+		if (!buckets) {
+			buckets = [];
+			series.set(model, buckets);
+		}
+		buckets.push({
+			timestamp,
+			requestCount: stats.requestCount,
+			successCount: stats.successCount,
+			failureCount: stats.failureCount,
+			totalDurationMs: stats.totalDurationMs,
+			averageDurationMs: stats.requestCount > 0 ? stats.totalDurationMs / stats.requestCount : 0,
+			usage: toUsageTotals(stats)
+		});
+	}
+	return [...aggregate.entries()].map(([model, stats]) => ({
+		...toModelSnapshot(model, stats),
+		buckets: (series.get(model) ?? []).sort((left, right) => left.timestamp - right.timestamp)
+	})).sort((left, right) => right.requestCount - left.requestCount || right.usage.totalTokens - left.usage.totalTokens || right.totalDurationMs - left.totalDurationMs || left.model.localeCompare(right.model));
+}
+function startPeriodicPersistence() {
+	if (persistTimer$1) return;
+	persistTimer$1 = setInterval(() => {
+		persistRequestTelemetry();
+	}, PERSIST_INTERVAL_MS);
+}
+function stopPeriodicPersistence() {
+	if (!persistTimer$1) return;
+	clearInterval(persistTimer$1);
+	persistTimer$1 = null;
+}
+function loadModelBuckets(raw) {
+	modelBucketStats = new Map(Object.entries(raw).map(([bucketKey, bucketValue]) => {
+		const bucketTimestamp = Number(bucketKey);
+		if (!Number.isFinite(bucketTimestamp) || !bucketValue || typeof bucketValue !== "object") return null;
+		const bucket = /* @__PURE__ */ new Map();
+		for (const [model, stats] of Object.entries(bucketValue)) if (isValidPersistedModelTelemetry(stats)) bucket.set(model, copyPersistedTelemetry(stats));
+		return [bucketTimestamp, bucket];
+	}).filter((entry) => Boolean(entry)));
+}
+async function initRequestTelemetry() {
+	stopPeriodicPersistence();
+	acceptedSinceStart = 0;
+	bucketCounts = /* @__PURE__ */ new Map();
+	modelStatsSinceStart = /* @__PURE__ */ new Map();
+	modelBucketStats = /* @__PURE__ */ new Map();
+	try {
+		const raw = await fs.readFile(telemetryFilePath, "utf8");
+		const parsed = JSON.parse(raw);
+		if (parsed.buckets && typeof parsed.buckets === "object") bucketCounts = new Map(Object.entries(parsed.buckets).map(([key, value]) => [Number(key), value]).filter(([key, value]) => Number.isFinite(key) && typeof value === "number" && value >= 0));
+		if (parsed.version === 2 && parsed.modelBuckets && typeof parsed.modelBuckets === "object") loadModelBuckets(parsed.modelBuckets);
+	} catch {}
+	pruneBuckets();
+	startPeriodicPersistence();
+}
+function recordAcceptedRequest(timestamp = Date.now()) {
+	acceptedSinceStart += 1;
+	const bucket = getBucketStart(timestamp);
+	bucketCounts.set(bucket, (bucketCounts.get(bucket) ?? 0) + 1);
+	pruneBuckets(timestamp);
+}
+function recordSettledRequest(model, opts) {
+	const normalizedModel = model.trim() || "unknown";
+	applySettledTelemetry(getOrCreateModelStats(modelStatsSinceStart, normalizedModel), opts);
+	applySettledTelemetry(getOrCreateModelStats(getOrCreateModelBucket(getBucketStart(opts.startedAt)), normalizedModel), opts);
+	pruneBuckets(opts.startedAt);
+}
+function getRequestTelemetrySnapshot(now = Date.now()) {
+	pruneBuckets(now);
+	const buckets = buildFilledBuckets(now);
+	const totalLast7d = buckets.reduce((sum, bucket) => sum + bucket.count, 0);
+	return {
+		acceptedSinceStart,
+		bucketSizeMinutes: BUCKET_MS / (60 * 1e3),
+		windowDays: WINDOW_MS / (1440 * 60 * 1e3),
+		totalLast7d,
+		buckets,
+		modelsSinceStart: buildModelSnapshots(modelStatsSinceStart.entries()),
+		modelsLast7d: buildLast7dModelSnapshots(now)
+	};
+}
+async function persistRequestTelemetry() {
+	pruneBuckets();
+	const file = {
+		version: 2,
+		buckets: Object.fromEntries([...bucketCounts.entries()].map(([key, value]) => [String(key), value])),
+		modelBuckets: Object.fromEntries([...modelBucketStats.entries()].map(([bucketTimestamp, bucket]) => [String(bucketTimestamp), Object.fromEntries([...bucket.entries()].map(([model, stats]) => [model, {
+			requestCount: stats.requestCount,
+			successCount: stats.successCount,
+			failureCount: stats.failureCount,
+			totalDurationMs: stats.totalDurationMs,
+			inputTokens: stats.inputTokens,
+			outputTokens: stats.outputTokens,
+			cacheReadInputTokens: stats.cacheReadInputTokens,
+			cacheCreationInputTokens: stats.cacheCreationInputTokens,
+			reasoningTokens: stats.reasoningTokens
+		}]))]))
+	};
+	try {
+		await fs.writeFile(telemetryFilePath, JSON.stringify(file, null, 2), "utf8");
+	} catch {}
+}
+async function shutdownRequestTelemetry() {
+	stopPeriodicPersistence();
+	await persistRequestTelemetry();
+}
+//#endregion
+//#region src/lib/context/activity-summary.ts
+function isActiveRequestState(state) {
+	return state !== "completed" && state !== "failed";
+}
+function summarizeRequestContext(context) {
+	const state = context.state ?? "pending";
+	return {
+		id: context.id,
+		endpoint: context.endpoint,
+		...context.rawPath ? { rawPath: context.rawPath } : {},
+		state,
+		active: isActiveRequestState(state),
+		startTime: context.startTime,
+		durationMs: context.durationMs ?? 0,
+		lastUpdatedAt: Date.now(),
+		model: context.originalRequest?.model,
+		stream: context.originalRequest?.stream,
+		attemptCount: context.attempts?.length ?? 0,
+		currentStrategy: context.currentAttempt?.strategy,
+		queueWaitMs: context.queueWaitMs ?? 0,
+		...context.transport ? { transport: context.transport } : {}
+	};
+}
+function buildHistoryActivityPatch(context) {
+	const snapshot = summarizeRequestContext(context);
+	return {
+		...snapshot.rawPath ? { rawPath: snapshot.rawPath } : {},
+		startedAt: snapshot.startTime,
+		state: snapshot.state,
+		active: snapshot.active,
+		lastUpdatedAt: snapshot.lastUpdatedAt,
+		queueWaitMs: snapshot.queueWaitMs,
+		attemptCount: snapshot.attemptCount,
+		currentStrategy: snapshot.currentStrategy,
+		durationMs: snapshot.durationMs,
+		...snapshot.transport ? { transport: snapshot.transport } : {}
+	};
+}
+//#endregion
 //#region src/lib/models/resolver.ts
 /**
 * Unified model name resolution and normalization.
@@ -3198,13 +3709,16 @@ function createRequestContext(opts) {
 	const startTime = Date.now();
 	const onEvent = opts.onEvent;
 	let _state = "pending";
+	let _sessionId = opts.sessionId;
 	let _originalRequest = null;
 	let _response = null;
 	let _pipelineInfo = null;
 	let _sseEvents = null;
 	let _httpHeaders = null;
 	let _queueWaitMs = 0;
+	const _warningMessages = [];
 	const _attempts = [];
+	let _endTime = null;
 	/** Guard: once complete() or fail() is called, subsequent calls are no-ops */
 	let settled = false;
 	function emit(event) {
@@ -3214,8 +3728,15 @@ function createRequestContext(opts) {
 	}
 	const ctx = {
 		id,
+		get sessionId() {
+			return _sessionId;
+		},
 		tuiLogId: opts.tuiLogId,
+		rawPath: opts.rawPath,
 		startTime,
+		get endTime() {
+			return _endTime;
+		},
 		endpoint: opts.endpoint,
 		get state() {
 			return _state;
@@ -3238,6 +3759,9 @@ function createRequestContext(opts) {
 		get httpHeaders() {
 			return _httpHeaders;
 		},
+		get transport() {
+			return _attempts.findLast((attempt) => attempt.response)?.transport ?? _attempts.at(-1)?.transport ?? null;
+		},
 		get attempts() {
 			return _attempts;
 		},
@@ -3247,6 +3771,12 @@ function createRequestContext(opts) {
 		get queueWaitMs() {
 			return _queueWaitMs;
 		},
+		get warningMessages() {
+			return _warningMessages;
+		},
+		setSessionId(sessionId) {
+			_sessionId = sessionId;
+		},
 		setOriginalRequest(req) {
 			_originalRequest = req;
 			emit({
@@ -3272,6 +3802,15 @@ function createRequestContext(opts) {
 				response: capture.response
 			};
 		},
+		addWarningMessage(warning) {
+			if (_warningMessages.some((existing) => existing.code === warning.code && existing.message === warning.message)) return;
+			_warningMessages.push(warning);
+			emit({
+				type: "updated",
+				context: ctx,
+				field: "warningMessages"
+			});
+		},
 		beginAttempt(attemptOpts) {
 			const attempt = {
 				index: _attempts.length,
@@ -3279,6 +3818,7 @@ function createRequestContext(opts) {
 				wireRequest: null,
 				response: null,
 				error: null,
+				transport: attemptOpts.transport ?? "http",
 				strategy: attemptOpts.strategy,
 				truncation: attemptOpts.truncation,
 				waitMs: attemptOpts.waitMs,
@@ -3298,11 +3838,36 @@ function createRequestContext(opts) {
 		},
 		setAttemptEffectiveRequest(req) {
 			const attempt = ctx.currentAttempt;
-			if (attempt) attempt.effectiveRequest = req;
+			if (attempt) {
+				attempt.effectiveRequest = req;
+				emit({
+					type: "updated",
+					context: ctx,
+					field: "attempts"
+				});
+			}
 		},
 		setAttemptWireRequest(req) {
 			const attempt = ctx.currentAttempt;
-			if (attempt) attempt.wireRequest = req;
+			if (attempt) {
+				attempt.wireRequest = req;
+				emit({
+					type: "updated",
+					context: ctx,
+					field: "attempts"
+				});
+			}
+		},
+		setAttemptTransport(transport) {
+			const attempt = ctx.currentAttempt;
+			if (attempt) {
+				attempt.transport = transport;
+				emit({
+					type: "updated",
+					context: ctx,
+					field: "attempts"
+				});
+			}
 		},
 		setAttemptResponse(response) {
 			const attempt = ctx.currentAttempt;
@@ -3320,6 +3885,11 @@ function createRequestContext(opts) {
 		},
 		addQueueWaitMs(ms) {
 			_queueWaitMs += ms;
+			emit({
+				type: "updated",
+				context: ctx,
+				field: "queueWaitMs"
+			});
 		},
 		transition(newState, meta) {
 			const previousState = _state;
@@ -3334,6 +3904,7 @@ function createRequestContext(opts) {
 		complete(response) {
 			if (settled) return;
 			settled = true;
+			_endTime = Date.now();
 			if (response.model) response.model = normalizeModelId(response.model);
 			_response = response;
 			ctx.setAttemptResponse(response);
@@ -3347,6 +3918,7 @@ function createRequestContext(opts) {
 		fail(model, error) {
 			if (settled) return;
 			settled = true;
+			_endTime = Date.now();
 			const errorMsg = getErrorMessage(error);
 			_response = {
 				success: false,
@@ -3372,11 +3944,23 @@ function createRequestContext(opts) {
 		},
 		toHistoryEntry() {
 			const p = _originalRequest?.payload;
+			const endedAt = _endTime ?? Date.now();
 			const entry = {
 				id,
 				endpoint: opts.endpoint,
-				timestamp: startTime,
-				durationMs: Date.now() - startTime,
+				..._sessionId ? { sessionId: _sessionId } : {},
+				...opts.rawPath ? { rawPath: opts.rawPath } : {},
+				startedAt: startTime,
+				endedAt,
+				state: _state,
+				active: false,
+				lastUpdatedAt: endedAt,
+				queueWaitMs: _queueWaitMs,
+				attemptCount: _attempts.length,
+				currentStrategy: _attempts.at(-1)?.strategy,
+				durationMs: endedAt - startTime,
+				...ctx.transport ? { transport: ctx.transport } : {},
+				..._warningMessages.length > 0 && { warningMessages: [..._warningMessages] },
 				request: {
 					model: _originalRequest?.model,
 					messages: _originalRequest?.messages,
@@ -3402,7 +3986,7 @@ function createRequestContext(opts) {
 					format: ep.format,
 					messageCount: ep.messages.length,
 					messages: ep.messages,
-					system: ep.payload?.system,
+					system: ep.payload.system,
 					payload: ep.payload
 				};
 			}
@@ -3413,7 +3997,7 @@ function createRequestContext(opts) {
 					format: wp.format,
 					messageCount: wp.messages.length,
 					messages: wp.messages,
-					system: wp.payload?.system,
+					system: wp.payload.system,
 					payload: wp.payload,
 					headers: wp.headers
 				};
@@ -3422,10 +4006,11 @@ function createRequestContext(opts) {
 				index: a.index,
 				strategy: a.strategy,
 				durationMs: a.durationMs,
+				transport: a.transport,
 				error: a.error?.message,
 				truncation: a.truncation,
 				sanitization: a.sanitization,
-				effectiveMessageCount: a.effectiveRequest?.messages?.length
+				effectiveMessageCount: a.effectiveRequest?.messages.length
 			}));
 			return entry;
 		}
@@ -3500,7 +4085,7 @@ function createRequestContextManager() {
 					});
 					notifyActiveRequestChanged({
 						action: "state_changed",
-						request: summarizeContext(context),
+						request: summarizeRequestContext(context),
 						activeCount: activeContexts.size
 					});
 				}
@@ -3513,11 +4098,19 @@ function createRequestContextManager() {
 				});
 				break;
 			case "completed":
-				if (rawEvent.entry) emit({
-					type: "completed",
-					context,
-					entry: rawEvent.entry
-				});
+				if (rawEvent.entry) {
+					recordSettledRequest(rawEvent.entry.response?.model ?? rawEvent.entry.request.model ?? "unknown", {
+						startedAt: rawEvent.entry.startedAt,
+						endedAt: rawEvent.entry.endedAt,
+						success: rawEvent.entry.response?.success ?? true,
+						usage: rawEvent.entry.response?.usage
+					});
+					emit({
+						type: "completed",
+						context,
+						entry: rawEvent.entry
+					});
+				}
 				activeContexts.delete(context.id);
 				notifyActiveRequestChanged({
 					action: "completed",
@@ -3526,11 +4119,19 @@ function createRequestContextManager() {
 				});
 				break;
 			case "failed":
-				if (rawEvent.entry) emit({
-					type: "failed",
-					context,
-					entry: rawEvent.entry
-				});
+				if (rawEvent.entry) {
+					recordSettledRequest(rawEvent.entry.response?.model ?? rawEvent.entry.request.model ?? "unknown", {
+						startedAt: rawEvent.entry.startedAt,
+						endedAt: rawEvent.entry.endedAt,
+						success: rawEvent.entry.response?.success ?? false,
+						usage: rawEvent.entry.response?.usage
+					});
+					emit({
+						type: "failed",
+						context,
+						entry: rawEvent.entry
+					});
+				}
 				activeContexts.delete(context.id);
 				notifyActiveRequestChanged({
 					action: "failed",
@@ -3541,28 +4142,16 @@ function createRequestContextManager() {
 			default: break;
 		}
 	}
-	/** Build a lightweight summary of a context for WS broadcast */
-	function summarizeContext(ctx) {
-		return {
-			id: ctx.id,
-			endpoint: ctx.endpoint,
-			state: ctx.state,
-			startTime: ctx.startTime,
-			durationMs: ctx.durationMs,
-			model: ctx.originalRequest?.model,
-			stream: ctx.originalRequest?.stream,
-			attemptCount: ctx.attempts.length,
-			currentStrategy: ctx.currentAttempt?.strategy,
-			queueWaitMs: ctx.queueWaitMs
-		};
-	}
 	return {
 		create(opts) {
 			const ctx = createRequestContext({
 				endpoint: opts.endpoint,
+				sessionId: opts.sessionId,
 				tuiLogId: opts.tuiLogId,
+				rawPath: opts.rawPath,
 				onEvent: handleContextEvent
 			});
+			recordAcceptedRequest(ctx.startTime);
 			activeContexts.set(ctx.id, ctx);
 			emit({
 				type: "created",
@@ -3570,31 +4159,363 @@ function createRequestContextManager() {
 			});
 			notifyActiveRequestChanged({
 				action: "created",
-				request: summarizeContext(ctx),
+				request: summarizeRequestContext(ctx),
 				activeCount: activeContexts.size
 			});
-			return ctx;
+			return ctx;
+		},
+		get(id) {
+			return activeContexts.get(id);
+		},
+		getAll() {
+			return Array.from(activeContexts.values());
+		},
+		get activeCount() {
+			return activeContexts.size;
+		},
+		on(_event, listener) {
+			listeners.add(listener);
+		},
+		off(_event, listener) {
+			listeners.delete(listener);
+		},
+		startReaper,
+		stopReaper,
+		_runReaperOnce: runReaperOnce
+	};
+}
+//#endregion
+//#region src/lib/openai/upstream-ws-connection.ts
+const DEFAULT_IDLE_TIMEOUT_MS = 5 * 6e4;
+const CLOSE_CODE_GOING_AWAY = 1001;
+const TERMINAL_EVENTS$1 = new Set([
+	"response.completed",
+	"response.failed",
+	"response.incomplete",
+	"error"
+]);
+function createUpstreamWsConnection(opts) {
+	const createSocket = opts.createSocket ?? ((url, headers) => new WebSocket$1(url, { headers }));
+	const idleTimeoutMs = opts.idleTimeoutMs ?? DEFAULT_IDLE_TIMEOUT_MS;
+	let socket = null;
+	let busy = false;
+	let statefulMarker;
+	let currentQueue = null;
+	let currentAbortCleanup = null;
+	let idleTimer = null;
+	const clearIdleTimer = () => {
+		if (idleTimer) {
+			clearTimeout(idleTimer);
+			idleTimer = null;
+		}
+	};
+	const scheduleIdleClose = () => {
+		clearIdleTimer();
+		if (!socket || busy || socket.readyState !== socket.OPEN || idleTimeoutMs <= 0) return;
+		idleTimer = setTimeout(() => {
+			socket?.close(CLOSE_CODE_GOING_AWAY, "Idle timeout");
+		}, idleTimeoutMs);
+	};
+	const finishRequest = () => {
+		busy = false;
+		currentAbortCleanup?.();
+		currentAbortCleanup = null;
+		currentQueue?.close();
+		currentQueue = null;
+		scheduleIdleClose();
+	};
+	const failRequest = (error) => {
+		busy = false;
+		currentAbortCleanup?.();
+		currentAbortCleanup = null;
+		currentQueue?.fail(error);
+		currentQueue = null;
+	};
+	const handleMessage = (event) => {
+		if (!(event instanceof MessageEvent)) return;
+		if (!currentQueue) return;
+		clearIdleTimer();
+		try {
+			const parsed = parseWebSocketEvent(event.data);
+			currentQueue.push(parsed);
+			if (parsed.type === "response.completed") statefulMarker = parsed.response.id;
+			if (TERMINAL_EVENTS$1.has(parsed.type)) finishRequest();
+		} catch (error) {
+			failRequest(error instanceof Error ? error : new Error(String(error)));
+		}
+	};
+	const handleError = () => {
+		if (!busy || !currentQueue) return;
+		failRequest(/* @__PURE__ */ new Error("Upstream WebSocket error"));
+	};
+	const handleClose = (event) => {
+		clearIdleTimer();
+		socket?.removeEventListener("message", handleMessage);
+		socket?.removeEventListener("error", handleError);
+		socket?.removeEventListener("close", handleClose);
+		socket = null;
+		opts.onClose?.();
+		if (!busy || !currentQueue) return;
+		const closeEvent = event;
+		failRequest(/* @__PURE__ */ new Error(`Upstream WebSocket closed (${closeEvent.code}: ${closeEvent.reason || "unknown"})`));
+	};
+	return {
+		async connect(connectOpts) {
+			const existingSocket = socket;
+			if (existingSocket && existingSocket.readyState === existingSocket.OPEN) return;
+			if (existingSocket && existingSocket.readyState === existingSocket.CONNECTING) throw new Error("Upstream WebSocket is already connecting");
+			const ws = createSocket(copilotWsUrl(state), opts.headers);
+			socket = ws;
+			ws.addEventListener("message", handleMessage);
+			ws.addEventListener("error", handleError);
+			ws.addEventListener("close", handleClose);
+			await new Promise((resolve, reject) => {
+				const signal = connectOpts?.signal;
+				const activeSocket = ws;
+				const cleanup = () => {
+					activeSocket.removeEventListener("open", onOpen);
+					activeSocket.removeEventListener("error", onOpenError);
+					signal?.removeEventListener("abort", onAbort);
+				};
+				const onOpen = () => {
+					cleanup();
+					resolve();
+				};
+				const onOpenError = () => {
+					cleanup();
+					activeSocket.close(CLOSE_CODE_GOING_AWAY, "Handshake failed");
+					reject(/* @__PURE__ */ new Error("Upstream WebSocket handshake failed"));
+				};
+				const onAbort = () => {
+					cleanup();
+					activeSocket.close(CLOSE_CODE_GOING_AWAY, "Aborted");
+					reject(/* @__PURE__ */ new Error("Upstream WebSocket connection aborted"));
+				};
+				activeSocket.addEventListener("open", onOpen, { once: true });
+				activeSocket.addEventListener("error", onOpenError, { once: true });
+				signal?.addEventListener("abort", onAbort, { once: true });
+				if (signal?.aborted) onAbort();
+			});
+			scheduleIdleClose();
+		},
+		sendRequest(payload, requestOpts) {
+			if (!socket || socket.readyState !== socket.OPEN) throw new Error("Upstream WebSocket is not connected");
+			if (busy) throw new Error("Upstream WebSocket connection is busy");
+			clearIdleTimer();
+			busy = true;
+			currentQueue = createAsyncQueue();
+			const abortSignal = requestOpts?.abortSignal;
+			const onAbort = () => {
+				failRequest(/* @__PURE__ */ new Error("Upstream WebSocket request aborted"));
+			};
+			currentAbortCleanup = () => {
+				abortSignal?.removeEventListener("abort", onAbort);
+			};
+			abortSignal?.addEventListener("abort", onAbort, { once: true });
+			try {
+				const { stream: _stream, ...wire } = payload;
+				socket.send(JSON.stringify({
+					type: "response.create",
+					...wire
+				}));
+			} catch (error) {
+				currentAbortCleanup();
+				currentAbortCleanup = null;
+				failRequest(error instanceof Error ? error : new Error(String(error)));
+			}
+			const queue = currentQueue;
+			return (async function* () {
+				try {
+					yield* queue.iterate();
+				} finally {
+					currentAbortCleanup?.();
+					currentAbortCleanup = null;
+				}
+			})();
+		},
+		get isOpen() {
+			return socket !== null && socket.readyState === socket.OPEN;
+		},
+		get isBusy() {
+			return busy;
+		},
+		get statefulMarker() {
+			return statefulMarker;
+		},
+		get model() {
+			return opts.model;
+		},
+		close() {
+			clearIdleTimer();
+			socket?.close(CLOSE_CODE_GOING_AWAY, "Going away");
+		}
+	};
+}
+function createAsyncQueue() {
+	const values = [];
+	const waiters = [];
+	let closed = false;
+	let failure = null;
+	const drain = () => {
+		while (waiters.length > 0) {
+			if (failure) {
+				waiters.shift()?.reject(failure);
+				continue;
+			}
+			if (values.length > 0) {
+				waiters.shift()?.resolve({
+					done: false,
+					value: values.shift()
+				});
+				continue;
+			}
+			if (closed) {
+				waiters.shift()?.resolve({
+					done: true,
+					value: void 0
+				});
+				continue;
+			}
+			break;
+		}
+	};
+	return {
+		push(value) {
+			if (closed || failure) return;
+			values.push(value);
+			drain();
+		},
+		close() {
+			closed = true;
+			drain();
+		},
+		fail(error) {
+			if (failure) return;
+			failure = error;
+			drain();
+		},
+		async *iterate() {
+			for (;;) {
+				if (failure) throw failure;
+				if (values.length > 0) {
+					yield values.shift();
+					continue;
+				}
+				if (closed) return;
+				const next = await new Promise((resolve, reject) => {
+					waiters.push({
+						resolve,
+						reject
+					});
+					drain();
+				});
+				if (next.done) return;
+				yield next.value;
+			}
+		}
+	};
+}
+function parseWebSocketEvent(input) {
+	let text = null;
+	if (typeof input === "string") text = input;
+	else if (input instanceof ArrayBuffer) text = Buffer.from(input).toString("utf8");
+	else if (ArrayBuffer.isView(input)) text = Buffer.from(input.buffer, input.byteOffset, input.byteLength).toString("utf8");
+	if (text === null) throw new Error("Unsupported upstream WebSocket frame");
+	const parsed = JSON.parse(text);
+	if (isCapiWebSocketError(parsed)) return {
+		type: "error",
+		code: parsed.error.code,
+		message: parsed.error.message,
+		sequence_number: typeof parsed.sequence_number === "number" ? parsed.sequence_number : 0
+	};
+	return parsed;
+}
+function isCapiWebSocketError(input) {
+	if (!input || typeof input !== "object") return false;
+	const record = input;
+	if (record.type !== "error") return false;
+	if (!record.error || typeof record.error !== "object") return false;
+	const error = record.error;
+	return typeof error.code === "string" && typeof error.message === "string";
+}
+//#endregion
+//#region src/lib/openai/upstream-ws.ts
+const MAX_CONSECUTIVE_WS_FALLBACKS = 3;
+let connectionFactory = createUpstreamWsConnection;
+function createUpstreamWsManager() {
+	const connections = /* @__PURE__ */ new Map();
+	let stopped = false;
+	let consecutiveFallbacks = 0;
+	let temporarilyDisabled = false;
+	return {
+		findReusable({ previousResponseId, model }) {
+			if (stopped || temporarilyDisabled) return void 0;
+			for (const connection of connections.values()) {
+				if (!connection.isOpen) continue;
+				if (connection.isBusy) continue;
+				if (connection.statefulMarker !== previousResponseId) continue;
+				if (connection.model !== model) continue;
+				return connection;
+			}
+		},
+		create({ headers, model }) {
+			if (stopped) throw new Error("Upstream WebSocket manager is not accepting new work");
+			const key = randomUUID();
+			const connection = connectionFactory({
+				headers,
+				model,
+				onClose: () => {
+					connections.delete(key);
+				}
+			});
+			connections.set(key, connection);
+			return Promise.resolve(connection);
 		},
-		get(id) {
-			return activeContexts.get(id);
+		stopNew() {
+			stopped = true;
 		},
-		getAll() {
-			return Array.from(activeContexts.values());
+		closeAll() {
+			for (const connection of connections.values()) connection.close();
+			connections.clear();
+		},
+		resetRuntimeState() {
+			stopped = false;
+			consecutiveFallbacks = 0;
+			temporarilyDisabled = false;
+			this.closeAll();
+		},
+		recordSuccessfulStart() {
+			consecutiveFallbacks = 0;
+			temporarilyDisabled = false;
+		},
+		recordFallback() {
+			consecutiveFallbacks += 1;
+			if (consecutiveFallbacks >= MAX_CONSECUTIVE_WS_FALLBACKS) temporarilyDisabled = true;
 		},
 		get activeCount() {
-			return activeContexts.size;
+			let count = 0;
+			for (const connection of connections.values()) if (connection.isOpen) count += 1;
+			return count;
 		},
-		on(_event, listener) {
-			listeners.add(listener);
+		get consecutiveFallbacks() {
+			return consecutiveFallbacks;
 		},
-		off(_event, listener) {
-			listeners.delete(listener);
+		get temporarilyDisabled() {
+			return temporarilyDisabled;
 		},
-		startReaper,
-		stopReaper,
-		_runReaperOnce: runReaperOnce
+		get stopped() {
+			return stopped;
+		}
 	};
 }
+let manager = null;
+function getUpstreamWsManager() {
+	manager ??= createUpstreamWsManager();
+	return manager;
+}
+function peekUpstreamWsManager() {
+	return manager;
+}
 let serverInstance = null;
 let _isShuttingDown = false;
 let shutdownResolve = null;
@@ -3718,6 +4639,7 @@ async function gracefulShutdown(signal, deps) {
 	} catch {}
 	stopRefresh();
 	stopMemoryPressureMonitor();
+	peekUpstreamWsManager()?.stopNew();
 	const wsClients = getWsClientCount();
 	if (wsClients > 0) {
 		closeWsClients();
@@ -3775,6 +4697,7 @@ async function gracefulShutdown(signal, deps) {
 		} catch (error) {
 			consola.error("Error force-closing server:", error);
 		}
+		peekUpstreamWsManager()?.closeAll();
 	}
 	finalize(tracker);
 }
@@ -3783,26 +4706,37 @@ function finalize(tracker) {
 	setPhase("finalized");
 	shutdownDrainAbortController = null;
 	tracker.destroy();
-	consola.info("Shutdown complete");
-	shutdownResolve?.();
+	shutdownRequestTelemetry().finally(() => {
+		consola.info("Shutdown complete");
+		shutdownResolve?.();
+	});
 }
 function handleShutdownSignal(signal, opts) {
 	const shutdownFn = opts?.gracefulShutdownFn ?? ((shutdownSignal) => gracefulShutdown(shutdownSignal));
 	const exitFn = opts?.exitFn ?? ((code) => process.exit(code));
-	if (_isShuttingDown) {
-		if (shutdownPhase === "phase2") {
+	if (_isShuttingDown) switch (shutdownPhase) {
+		case "phase1":
+			consola.warn("Signal received during Phase 1 setup, waiting for shutdown to proceed");
+			return shutdownPromise ?? void 0;
+		case "phase2":
 			consola.warn("Second signal received, escalating shutdown to abort active requests");
 			shutdownDrainAbortController?.abort();
 			return shutdownPromise ?? void 0;
-		}
-		if (shutdownPhase === "phase3") {
+		case "phase3":
 			consola.warn("Additional signal received, escalating shutdown to force-close remaining requests");
 			shutdownDrainAbortController?.abort();
 			return shutdownPromise ?? void 0;
-		}
-		consola.warn("Additional signal received during forced shutdown, exiting immediately");
-		exitFn(1);
-		return shutdownPromise ?? void 0;
+		case "phase4":
+			consola.warn("Additional signal received during forced shutdown, exiting immediately");
+			exitFn(1);
+			return shutdownPromise ?? void 0;
+		case "finalized":
+			consola.info("Signal received after shutdown finalized, ignoring");
+			return shutdownPromise ?? void 0;
+		default:
+			consola.warn("Signal received in unexpected shutdown phase, exiting immediately");
+			exitFn(1);
+			return shutdownPromise ?? void 0;
 	}
 	shutdownPromise = shutdownFn(signal).catch((error) => {
 		consola.error("Fatal error during shutdown:", error);
@@ -4579,54 +5513,8 @@ const setupClaudeCode = defineCommand({
 	}
 });
 //#endregion
-//#region src/lib/serve.ts
-/** Start the HTTP server and return a ServerInstance. */
-async function startServer(options) {
-	if (typeof globalThis.Bun !== "undefined") return startBunServer(options);
-	return startNodeServer(options);
-}
-async function startNodeServer(options) {
-	const { createAdaptorServer } = await import("./dist-B3gFwWti.mjs");
-	const nodeServer = createAdaptorServer({ fetch: options.fetch });
-	await new Promise((resolve, reject) => {
-		nodeServer.once("error", reject);
-		nodeServer.listen({
-			port: options.port,
-			host: options.hostname,
-			exclusive: false
-		}, () => {
-			nodeServer.removeListener("error", reject);
-			resolve();
-		});
-	});
-	return {
-		nodeServer,
-		close(force) {
-			return new Promise((resolve, reject) => {
-				if (force && "closeAllConnections" in nodeServer) nodeServer.closeAllConnections();
-				nodeServer.close((err) => err ? reject(err) : resolve());
-			});
-		}
-	};
-}
-async function startBunServer(options) {
-	const bunServer = Bun.serve({
-		fetch(request, server) {
-			return options.fetch(request, { server });
-		},
-		port: options.port,
-		hostname: options.hostname,
-		idleTimeout: 255,
-		...options.bunWebSocket ? { websocket: options.bunWebSocket } : {}
-	});
-	return { close(force) {
-		bunServer.stop(force ?? false);
-		return Promise.resolve();
-	} };
-}
-//#endregion
 //#region package.json
-var version = "0.8.1-beta.2";
+var version = "0.8.3";
 //#endregion
 //#region src/lib/system-prompt/override.ts
 /**
@@ -5188,7 +6076,9 @@ function handleErrorPersistence(event) {
 const MAX_MESSAGES_IN_DUMP = 50;
 async function writeErrorEntry(entry) {
 	const meta = {
-		timestamp: new Date(entry.timestamp).toISOString(),
+		timestamp: new Date(entry.startedAt).toISOString(),
+		startedAt: new Date(entry.startedAt).toISOString(),
+		endedAt: new Date(entry.endedAt).toISOString(),
 		id: entry.id,
 		endpoint: entry.endpoint,
 		durationMs: entry.durationMs,
@@ -5251,12 +6141,12 @@ function handleHistoryEvent(event) {
 				const orig = event.context.originalRequest;
 				if (!orig) break;
 				const ctx = event.context;
-				const sessionId = getCurrentSession(ctx.endpoint);
 				insertEntry({
 					id: ctx.id,
-					sessionId,
-					timestamp: ctx.startTime,
+					...ctx.sessionId ? { sessionId: ctx.sessionId } : {},
+					...ctx.rawPath ? { rawPath: ctx.rawPath } : {},
 					endpoint: ctx.endpoint,
+					...buildHistoryActivityPatch(ctx),
 					request: {
 						model: orig.model,
 						messages: orig.messages,
@@ -5266,16 +6156,33 @@ function handleHistoryEvent(event) {
 					}
 				});
 			}
+			if (event.field === "attempts" || event.field === "queueWaitMs") updateEntry(event.context.id, buildHistoryActivityPatch(event.context));
+			if (event.field === "warningMessages" && event.context.warningMessages.length > 0) updateEntry(event.context.id, { warningMessages: [...event.context.warningMessages] });
 			if (event.field === "pipelineInfo" && event.context.pipelineInfo) updateEntry(event.context.id, { pipelineInfo: event.context.pipelineInfo });
 			break;
+		case "state_changed":
+			updateEntry(event.context.id, buildHistoryActivityPatch(event.context));
+			break;
 		case "completed":
 		case "failed": {
 			const entryData = event.entry;
 			const response = toHistoryResponse(entryData);
 			updateEntry(entryData.id, {
+				rawPath: entryData.rawPath,
+				sessionId: entryData.sessionId,
+				state: entryData.state,
+				active: entryData.active,
+				lastUpdatedAt: entryData.lastUpdatedAt,
+				queueWaitMs: entryData.queueWaitMs,
+				attemptCount: entryData.attemptCount,
+				currentStrategy: entryData.currentStrategy,
 				response,
+				startedAt: entryData.startedAt,
+				endedAt: entryData.endedAt,
 				durationMs: entryData.durationMs,
+				transport: entryData.transport,
 				sseEvents: entryData.sseEvents,
+				...entryData.warningMessages && { warningMessages: entryData.warningMessages },
 				...entryData.effectiveRequest && { effectiveRequest: {
 					model: entryData.effectiveRequest.model,
 					format: entryData.effectiveRequest.format,
@@ -5317,6 +6224,10 @@ function handleTuiEvent(event) {
 				const attempt = event.context.currentAttempt;
 				if (attempt?.strategy) tuiLogger.updateRequest(tuiLogId, { tags: [attempt.strategy] });
 			}
+			if (event.field === "attempts") {
+				const transportTag = toTransportTag(event.context.currentAttempt?.transport);
+				if (transportTag) tuiLogger.updateRequest(tuiLogId, { tags: [transportTag] });
+			}
 			break;
 		}
 		case "completed": {
@@ -5370,6 +6281,10 @@ function toHistoryResponse(entryData) {
 		headers: entryData.httpHeaders?.response
 	};
 }
+function toTransportTag(transport) {
+	if (transport === "upstream-ws") return "ws";
+	if (transport === "upstream-ws-fallback") return "ws→http";
+}
 function registerContextConsumers(manager) {
 	manager.on("change", handleHistoryEvent);
 	manager.on("change", handleTuiEvent);
@@ -5419,6 +6334,63 @@ function isEndpointSupported(model, endpoint) {
 function isResponsesSupported(model) {
 	return isEndpointSupported(model, ENDPOINT.RESPONSES) || isEndpointSupported(model, ENDPOINT.WS_RESPONSES);
 }
+/**
+* Check if a model explicitly supports upstream WebSocket transport for Responses API.
+*
+* Unlike `isEndpointSupported`, legacy models without `supported_endpoints` do not
+* implicitly gain WebSocket support. We only enable this transport when Copilot has
+* advertised the dedicated `ws:/responses` capability.
+*/
+function isWsResponsesSupported(model) {
+	if (!model?.supported_endpoints) return false;
+	return model.supported_endpoints.includes(ENDPOINT.WS_RESPONSES);
+}
+//#endregion
+//#region src/lib/serve.ts
+/** Start the HTTP server and return a ServerInstance. */
+async function startServer(options) {
+	if (typeof globalThis.Bun !== "undefined") return startBunServer(options);
+	return startNodeServer(options);
+}
+async function startNodeServer(options) {
+	const { createAdaptorServer } = await import("./dist-B3gFwWti.mjs");
+	const nodeServer = createAdaptorServer({ fetch: options.fetch });
+	await new Promise((resolve, reject) => {
+		nodeServer.once("error", reject);
+		nodeServer.listen({
+			port: options.port,
+			host: options.hostname,
+			exclusive: false
+		}, () => {
+			nodeServer.removeListener("error", reject);
+			resolve();
+		});
+	});
+	return {
+		nodeServer,
+		close(force) {
+			return new Promise((resolve, reject) => {
+				if (force && "closeAllConnections" in nodeServer) nodeServer.closeAllConnections();
+				nodeServer.close((err) => err ? reject(err) : resolve());
+			});
+		}
+	};
+}
+async function startBunServer(options) {
+	const bunServer = Bun.serve({
+		fetch(request, server) {
+			return options.fetch(request, { server });
+		},
+		port: options.port,
+		hostname: options.hostname,
+		idleTimeout: 255,
+		...options.bunWebSocket ? { websocket: options.bunWebSocket } : {}
+	});
+	return { close(force) {
+		bunServer.stop(force ?? false);
+		return Promise.resolve();
+	} };
+}
 //#endregion
 //#region src/lib/openai/responses-conversion.ts
 /**
@@ -6012,6 +6984,47 @@ const createResponses = async (payload, opts) => {
 		wire: prepared.wire,
 		headers: sanitizeHeadersForHistory(prepared.headers)
 	});
+	const { wire } = prepared;
+	let usedFallback = false;
+	if (wire.stream && canUseUpstreamWebSocket(opts?.resolvedModel)) {
+		const manager = getUpstreamWsManager();
+		const connection = (typeof wire.previous_response_id === "string" ? manager.findReusable({
+			previousResponseId: wire.previous_response_id,
+			model: wire.model
+		}) : void 0) ?? await manager.create({
+			headers: prepared.headers,
+			model: wire.model
+		});
+		try {
+			if (!connection.isOpen) await connection.connect({ signal: createFetchSignal() });
+			const iterator = connection.sendRequest(wire)[Symbol.asyncIterator]();
+			const first = await awaitFirstEvent(iterator);
+			manager.recordSuccessfulStart();
+			opts?.onTransport?.("upstream-ws");
+			return (async function* () {
+				yield toSseMessage(first);
+				for (;;) {
+					const result = await iterator.next();
+					if (result.done) return;
+					yield toSseMessage(result.value);
+				}
+			})();
+		} catch (error) {
+			manager.recordFallback();
+			opts?.onTransport?.("upstream-ws-fallback");
+			usedFallback = true;
+			connection.close();
+			consola.warn(`[responses] Upstream WS failed before first event, falling back to HTTP (${manager.consecutiveFallbacks}/3): ${error instanceof Error ? error.message : String(error)}`);
+		}
+	}
+	if (!usedFallback) opts?.onTransport?.("http");
+	return createResponsesViaHttp(prepared, opts?.headersCapture);
+};
+function canUseUpstreamWebSocket(model) {
+	const manager = getUpstreamWsManager();
+	return state.upstreamWebSocket && !manager.temporarilyDisabled && !manager.stopped && isWsResponsesSupported(model);
+}
+async function createResponsesViaHttp(prepared, headersCapture) {
 	const { wire, headers } = prepared;
 	const fetchSignal = createFetchSignal();
 	const response = await fetch(`${copilotBaseUrl(state)}/responses`, {
@@ -6020,14 +7033,46 @@ const createResponses = async (payload, opts) => {
 		body: JSON.stringify(wire),
 		signal: fetchSignal
 	});
-	if (opts?.headersCapture) captureHttpHeaders(opts.headersCapture, headers, response);
+	if (headersCapture) captureHttpHeaders(headersCapture, headers, response);
 	if (!response.ok) {
 		consola.error("Failed to create responses", response);
 		throw await HTTPError.fromResponse("Failed to create responses", response, wire.model);
 	}
 	if (wire.stream) return events(response);
 	return await response.json();
-};
+}
+async function awaitFirstEvent(iterator) {
+	const signal = createFetchSignal();
+	if (!signal) {
+		const first = await iterator.next();
+		if (first.done) throw new Error("Upstream WebSocket closed before first event");
+		return first.value;
+	}
+	return await new Promise((resolve, reject) => {
+		const onAbort = () => {
+			signal.removeEventListener("abort", onAbort);
+			reject(/* @__PURE__ */ new Error("Upstream WebSocket timed out before first event"));
+		};
+		signal.addEventListener("abort", onAbort, { once: true });
+		iterator.next().then((result) => {
+			signal.removeEventListener("abort", onAbort);
+			if (result.done) {
+				reject(/* @__PURE__ */ new Error("Upstream WebSocket closed before first event"));
+				return;
+			}
+			resolve(result.value);
+		}).catch((error) => {
+			signal.removeEventListener("abort", onAbort);
+			reject(error instanceof Error ? error : new Error(String(error)));
+		});
+	});
+}
+function toSseMessage(event) {
+	return {
+		event: event.type,
+		data: JSON.stringify(event)
+	};
+}
 //#endregion
 //#region src/lib/request/strategies/network-retry.ts
 /**
@@ -6129,7 +7174,7 @@ function createTokenRefreshStrategy() {
 * centralizes that configuration to avoid duplication.
 */
 /** Create the FormatAdapter for Responses API pipeline execution */
-function createResponsesAdapter(selectedModel, headersCapture, onPrepared) {
+function createResponsesAdapter(selectedModel, headersCapture, onPrepared, onTransport) {
 	return {
 		format: "openai-responses",
 		sanitize: (p) => ({
@@ -6140,10 +7185,11 @@ function createResponsesAdapter(selectedModel, headersCapture, onPrepared) {
 		execute: (p) => executeWithAdaptiveRateLimit(() => createResponses(p, {
 			resolvedModel: selectedModel,
 			headersCapture,
+			onTransport,
 			onPrepared: ({ wire, headers }) => {
 				onPrepared?.({
 					model: typeof wire.model === "string" ? wire.model : p.model,
-					messages: [],
+					messages: extractInputItems(wire.input),
 					payload: wire,
 					headers,
 					format: "openai-responses"
@@ -6160,6 +7206,14 @@ function createResponsesAdapter(selectedModel, headersCapture, onPrepared) {
 function createResponsesStrategies() {
 	return [createNetworkRetryStrategy(), createTokenRefreshStrategy()];
 }
+function extractInputItems(input) {
+	if (typeof input === "string") return [{
+		type: "message",
+		role: "user",
+		content: input
+	}];
+	return input;
+}
 const CALL_PREFIX = "call_";
 const FC_PREFIX = "fc_";
 /**
@@ -6258,7 +7312,9 @@ async function handleResponseCreate(ws, rawPayload) {
 	});
 	const reqCtx = getRequestContextManager().create({
 		endpoint: "openai-responses",
-		tuiLogId
+		sessionId: resolveResponseSessionId(payload.previous_response_id),
+		tuiLogId,
+		rawPath: "/v1/responses"
 	});
 	reqCtx.setOriginalRequest({
 		model: requestedModel,
@@ -6275,6 +7331,8 @@ async function handleResponseCreate(ws, rawPayload) {
 	const headersCapture = {};
 	const adapter = createResponsesAdapter(selectedModel, headersCapture, (wireRequest) => {
 		reqCtx.setAttemptWireRequest(wireRequest);
+	}, (transport) => {
+		reqCtx.setAttemptTransport(transport);
 	});
 	const strategies = createResponsesStrategies();
 	try {
@@ -6312,6 +7370,8 @@ async function handleResponseCreate(ws, rawPayload) {
 				consola.debug("[WS] Skipping unparseable SSE event");
 			}
 		}
+		if (!reqCtx.sessionId && acc.responseId) reqCtx.setSessionId(acc.responseId);
+		registerResponseSession(acc.responseId, reqCtx.sessionId);
 		const responseData = buildResponsesResponseData(acc, resolvedModel);
 		reqCtx.complete(responseData);
 		ws.close(1e3, "done");
@@ -7216,34 +8276,370 @@ function createOpenAIStreamAccumulator() {
 		toolCallMap: /* @__PURE__ */ new Map()
 	};
 }
-/** Accumulate a single parsed OpenAI chunk into the accumulator */
-function accumulateOpenAIStreamEvent(parsed, acc) {
-	if (parsed.model && !acc.model) acc.model = parsed.model;
-	if (parsed.usage) {
-		acc.inputTokens = parsed.usage.prompt_tokens;
-		acc.outputTokens = parsed.usage.completion_tokens;
-		if (parsed.usage.prompt_tokens_details?.cached_tokens !== void 0) acc.cachedTokens = parsed.usage.prompt_tokens_details.cached_tokens;
-		if (parsed.usage.completion_tokens_details?.reasoning_tokens !== void 0) acc.reasoningTokens = parsed.usage.completion_tokens_details.reasoning_tokens;
+/** Accumulate a single parsed OpenAI chunk into the accumulator */
+function accumulateOpenAIStreamEvent(parsed, acc) {
+	if (parsed.model && !acc.model) acc.model = parsed.model;
+	if (parsed.usage) {
+		acc.inputTokens = parsed.usage.prompt_tokens;
+		acc.outputTokens = parsed.usage.completion_tokens;
+		if (parsed.usage.prompt_tokens_details?.cached_tokens !== void 0) acc.cachedTokens = parsed.usage.prompt_tokens_details.cached_tokens;
+		if (parsed.usage.completion_tokens_details?.reasoning_tokens !== void 0) acc.reasoningTokens = parsed.usage.completion_tokens_details.reasoning_tokens;
+	}
+	const choice = parsed.choices[0];
+	if (choice) {
+		if (choice.delta.content) acc.rawContent += choice.delta.content;
+		if (choice.delta.tool_calls) for (const tc of choice.delta.tool_calls) {
+			const idx = tc.index;
+			if (!acc.toolCallMap.has(idx)) acc.toolCallMap.set(idx, {
+				id: tc.id ?? "",
+				name: tc.function?.name ?? "",
+				argumentParts: []
+			});
+			const item = acc.toolCallMap.get(idx);
+			if (item) {
+				if (tc.id) item.id = tc.id;
+				if (tc.function?.name) item.name = tc.function.name;
+				if (tc.function?.arguments) item.argumentParts.push(tc.function.arguments);
+			}
+		}
+		if (choice.finish_reason) acc.finishReason = choice.finish_reason;
+	}
+}
+//#endregion
+//#region src/lib/openai/translate/cc-to-responses.ts
+const DROPPED_PARAMS = [
+	"stop",
+	"n",
+	"frequency_penalty",
+	"presence_penalty",
+	"logit_bias",
+	"logprobs",
+	"seed"
+];
+function splitInstructionsAndConversation(messages) {
+	const systemTexts = [];
+	const conversationMessages = [];
+	for (const message of messages) {
+		if (message.role === "system" || message.role === "developer") {
+			const text = extractTextContent(message.content);
+			if (text) systemTexts.push(text);
+			continue;
+		}
+		conversationMessages.push(message);
+	}
+	return {
+		instructions: systemTexts.length > 0 ? systemTexts.join("\n\n") : void 0,
+		conversationMessages
+	};
+}
+function translateChatCompletionsToResponses(payload) {
+	const droppedParams = DROPPED_PARAMS.filter((key) => payload[key] !== void 0 && payload[key] !== null);
+	const { instructions, conversationMessages } = splitInstructionsAndConversation(payload.messages);
+	return {
+		payload: {
+			model: payload.model,
+			input: translateMessages(conversationMessages),
+			...instructions !== void 0 && { instructions },
+			...payload.temperature !== void 0 && payload.temperature !== null && { temperature: payload.temperature },
+			...payload.top_p !== void 0 && payload.top_p !== null && { top_p: payload.top_p },
+			...payload.max_tokens !== void 0 && payload.max_tokens !== null && { max_output_tokens: payload.max_tokens },
+			...payload.stream !== void 0 && payload.stream !== null && { stream: payload.stream },
+			...payload.parallel_tool_calls !== void 0 && payload.parallel_tool_calls !== null && { parallel_tool_calls: payload.parallel_tool_calls },
+			...payload.user !== void 0 && { user: payload.user },
+			...payload.service_tier !== void 0 && { service_tier: payload.service_tier },
+			...payload.top_logprobs !== void 0 && payload.top_logprobs !== null && { top_logprobs: payload.top_logprobs },
+			...payload.tools && { tools: translateTools(payload.tools) },
+			...payload.tool_choice && { tool_choice: translateToolChoice(payload.tool_choice) },
+			...payload.response_format && { text: { format: translateResponseFormat(payload.response_format) } },
+			...payload.stream_options?.include_usage && { include: ["usage"] }
+		},
+		droppedParams
+	};
+}
+function translateMessages(messages) {
+	const items = [];
+	for (const message of messages) switch (message.role) {
+		case "user":
+			items.push(convertUserMessage(message));
+			break;
+		case "assistant":
+			items.push(...convertAssistantMessage(message));
+			break;
+		case "tool":
+			items.push(convertToolMessage(message));
+			break;
+		default: break;
+	}
+	return items;
+}
+function convertUserMessage(message) {
+	if (typeof message.content === "string") return {
+		type: "message",
+		role: "user",
+		content: [{
+			type: "input_text",
+			text: message.content
+		}]
+	};
+	if (!Array.isArray(message.content)) return {
+		type: "message",
+		role: "user",
+		content: [{
+			type: "input_text",
+			text: ""
+		}]
+	};
+	return {
+		type: "message",
+		role: "user",
+		content: message.content.map((part) => convertUserContentPart(part))
+	};
+}
+function convertUserContentPart(part) {
+	if (part.type === "text") return {
+		type: "input_text",
+		text: part.text
+	};
+	return {
+		type: "input_image",
+		image_url: part.image_url.url,
+		detail: part.image_url.detail
+	};
+}
+function convertAssistantMessage(message) {
+	const items = [];
+	const text = extractTextContent(message.content);
+	if (text) items.push({
+		type: "message",
+		role: "assistant",
+		content: [{
+			type: "output_text",
+			text
+		}]
+	});
+	for (const toolCall of message.tool_calls ?? []) items.push({
+		type: "function_call",
+		id: toolCall.id,
+		call_id: toolCall.id,
+		name: toolCall.function.name,
+		arguments: toolCall.function.arguments
+	});
+	return items;
+}
+function convertToolMessage(message) {
+	let output = "";
+	if (typeof message.content === "string") output = message.content;
+	else if (Array.isArray(message.content)) {
+		const textParts = message.content.filter((part) => part.type === "text").map((part) => part.text);
+		output = textParts.length > 0 ? textParts.join("") : JSON.stringify(message.content);
+	}
+	return {
+		type: "function_call_output",
+		call_id: message.tool_call_id ?? "",
+		output
+	};
+}
+function extractTextContent(content) {
+	if (typeof content === "string") return content;
+	if (!Array.isArray(content)) return "";
+	return content.filter((part) => part.type === "text").map((part) => part.text).join("");
+}
+function translateTools(tools) {
+	return tools.map((tool) => ({
+		type: "function",
+		name: tool.function.name,
+		description: tool.function.description,
+		parameters: tool.function.parameters,
+		strict: tool.function.strict
+	}));
+}
+function translateToolChoice(choice) {
+	if (typeof choice === "string") return choice;
+	return {
+		type: "function",
+		name: choice.function.name
+	};
+}
+function translateResponseFormat(format) {
+	if (format.type === "json_schema") return {
+		type: "json_schema",
+		name: format.json_schema.name,
+		description: format.json_schema.description,
+		schema: format.json_schema.schema,
+		strict: format.json_schema.strict
+	};
+	return { type: format.type };
+}
+//#endregion
+//#region src/lib/openai/translate/responses-to-cc.ts
+function translateResponsesResponseToCC(response) {
+	if (response.status === "failed") throw new HTTPError(response.error?.message ?? "Upstream response failed", 500, JSON.stringify(response.error ?? { status: response.status }), response.model);
+	return {
+		id: response.id,
+		object: "chat.completion",
+		created: response.created_at,
+		model: response.model,
+		choices: [{
+			index: 0,
+			message: extractMessageFromOutput(response.output),
+			finish_reason: mapFinishReason(response.status, response.output, response.incomplete_details),
+			logprobs: null
+		}],
+		...response.usage && { usage: mapUsage(response.usage) },
+		...response.service_tier !== void 0 && { service_tier: response.service_tier }
+	};
+}
+function extractMessageFromOutput(output) {
+	const textParts = [];
+	const toolCalls = [];
+	for (const item of output) {
+		if (item.type === "message") for (const part of item.content) {
+			if (part.type === "output_text") textParts.push(part.text);
+			if (part.type === "refusal") textParts.push(part.refusal);
+		}
+		if (item.type === "function_call") toolCalls.push({
+			id: item.call_id,
+			type: "function",
+			function: {
+				name: item.name,
+				arguments: item.arguments
+			}
+		});
+	}
+	return {
+		role: "assistant",
+		content: textParts.join("") || null,
+		...toolCalls.length > 0 && { tool_calls: toolCalls }
+	};
+}
+function mapFinishReason(status, output, incompleteDetails) {
+	if (output.some((item) => item.type === "function_call")) return "tool_calls";
+	switch (status) {
+		case "completed": return "stop";
+		case "incomplete": return mapIncompleteFinishReason(incompleteDetails);
+		default: return "stop";
 	}
-	const choice = parsed.choices[0];
-	if (choice) {
-		if (choice.delta.content) acc.rawContent += choice.delta.content;
-		if (choice.delta.tool_calls) for (const tc of choice.delta.tool_calls) {
-			const idx = tc.index;
-			if (!acc.toolCallMap.has(idx)) acc.toolCallMap.set(idx, {
-				id: tc.id ?? "",
-				name: tc.function?.name ?? "",
-				argumentParts: []
-			});
-			const item = acc.toolCallMap.get(idx);
-			if (item) {
-				if (tc.id) item.id = tc.id;
-				if (tc.function?.name) item.name = tc.function.name;
-				if (tc.function?.arguments) item.argumentParts.push(tc.function.arguments);
+}
+function mapIncompleteFinishReason(incompleteDetails) {
+	if (incompleteDetails?.reason === "content_filter") return "content_filter";
+	return "length";
+}
+function mapUsage(usage) {
+	return {
+		prompt_tokens: usage.input_tokens,
+		completion_tokens: usage.output_tokens,
+		total_tokens: usage.total_tokens,
+		...usage.input_tokens_details?.cached_tokens !== void 0 && { prompt_tokens_details: { cached_tokens: usage.input_tokens_details.cached_tokens } },
+		...usage.output_tokens_details?.reasoning_tokens !== void 0 && { completion_tokens_details: { reasoning_tokens: usage.output_tokens_details.reasoning_tokens } }
+	};
+}
+//#endregion
+//#region src/lib/openai/translate/responses-to-cc-stream.ts
+function createStreamTranslator(opts) {
+	const state = {
+		sentFirstChunk: false,
+		responseId: "",
+		model: "",
+		toolCallIndexMap: /* @__PURE__ */ new Map(),
+		nextToolCallIndex: 0,
+		toolCallIds: /* @__PURE__ */ new Map(),
+		includeUsage: opts.includeUsage
+	};
+	function translate(event) {
+		switch (event.type) {
+			case "response.created":
+				state.responseId = event.response.id;
+				state.model = event.response.model;
+				state.sentFirstChunk = true;
+				return [buildChunk(state, { role: "assistant" })];
+			case "response.output_text.delta": return [buildChunk(state, { content: event.delta })];
+			case "response.refusal.delta": return [buildChunk(state, { content: event.delta })];
+			case "response.output_item.added": {
+				if (event.item.type !== "function_call") return [];
+				const toolCallIndex = state.nextToolCallIndex++;
+				const callId = event.item.call_id || event.item.id;
+				state.toolCallIndexMap.set(event.output_index, toolCallIndex);
+				state.toolCallIds.set(event.output_index, callId);
+				return [buildChunk(state, { tool_calls: [{
+					index: toolCallIndex,
+					id: callId,
+					type: "function",
+					function: { name: event.item.name }
+				}] })];
+			}
+			case "response.function_call_arguments.delta": {
+				const toolCallIndex = state.toolCallIndexMap.get(event.output_index);
+				if (toolCallIndex === void 0) return [];
+				return [buildChunk(state, { tool_calls: [{
+					index: toolCallIndex,
+					function: { arguments: event.delta }
+				}] })];
 			}
+			case "response.completed": {
+				syncStateFromResponse(state, event.response);
+				const chunks = [buildChunk(state, {}, state.nextToolCallIndex > 0 ? "tool_calls" : "stop")];
+				if (state.includeUsage && event.response.usage) chunks.push(buildUsageChunk(state, event.response));
+				return chunks;
+			}
+			case "response.incomplete":
+				syncStateFromResponse(state, event.response);
+				return [buildChunk(state, {}, mapIncompleteFinishReason(event.response.incomplete_details))];
+			case "response.failed": throw new Error(event.response.error?.message ?? "Upstream response failed");
+			case "error": throw new Error(event.message ?? "Upstream error");
+			default: return [];
 		}
-		if (choice.finish_reason) acc.finishReason = choice.finish_reason;
 	}
+	return {
+		translate,
+		getState: () => state
+	};
+}
+async function* translateResponsesStream(upstream, translator) {
+	for await (const rawEvent of upstream) {
+		if (!rawEvent.data || rawEvent.data === "[DONE]") continue;
+		const event = JSON.parse(rawEvent.data);
+		const chunks = translator.translate(event);
+		for (const chunk of chunks) yield {
+			data: JSON.stringify(chunk),
+			event: "message"
+		};
+	}
+	yield { data: "[DONE]" };
+}
+function syncStateFromResponse(state, response) {
+	if (!state.responseId) state.responseId = response.id;
+	if (!state.model) state.model = response.model;
+}
+function buildChunk(state, delta, finishReason = null) {
+	return {
+		id: state.responseId,
+		object: "chat.completion.chunk",
+		created: Math.floor(Date.now() / 1e3),
+		model: state.model,
+		choices: [{
+			index: 0,
+			delta,
+			finish_reason: finishReason,
+			logprobs: null
+		}]
+	};
+}
+function buildUsageChunk(state, response) {
+	const usage = response.usage;
+	return {
+		id: state.responseId,
+		object: "chat.completion.chunk",
+		created: Math.floor(Date.now() / 1e3),
+		model: state.model,
+		choices: [],
+		...usage && { usage: {
+			prompt_tokens: usage.input_tokens,
+			completion_tokens: usage.output_tokens,
+			total_tokens: usage.total_tokens,
+			...usage.input_tokens_details?.cached_tokens !== void 0 && { prompt_tokens_details: { cached_tokens: usage.input_tokens_details.cached_tokens } },
+			...usage.output_tokens_details?.reasoning_tokens !== void 0 && { completion_tokens_details: { reasoning_tokens: usage.output_tokens_details.reasoning_tokens } }
+		} }
+	};
 }
 //#endregion
 //#region src/lib/request/payload.ts
@@ -7416,6 +8812,7 @@ function createTruncationMarker$1(result) {
 }
 //#endregion
 //#region src/routes/chat-completions/handler.ts
+const DROPPED_CC_PARAMS_WARNING_CODE = "cc_to_responses_dropped_params";
 async function handleChatCompletion(c) {
 	const originalPayload = await c.req.json();
 	const clientModel = originalPayload.model;
@@ -7425,15 +8822,13 @@ async function handleChatCompletion(c) {
 		originalPayload.model = resolvedModel;
 	}
 	const selectedModel = state.modelIndex.get(originalPayload.model);
-	if (!isEndpointSupported(selectedModel, ENDPOINT.CHAT_COMPLETIONS)) {
-		const msg = `Model "${originalPayload.model}" does not support the ${ENDPOINT.CHAT_COMPLETIONS} endpoint`;
-		throw new HTTPError(msg, 400, msg);
-	}
 	originalPayload.messages = await processOpenAIMessages(originalPayload.messages, originalPayload.model);
 	const tuiLogId = c.get("tuiLogId");
 	const reqCtx = getRequestContextManager().create({
 		endpoint: "openai-chat-completions",
-		tuiLogId
+		sessionId: getSessionIdFromHeaders(c.req.raw.headers),
+		tuiLogId,
+		rawPath: c.req.path
 	});
 	reqCtx.setOriginalRequest({
 		model: clientModel,
@@ -7455,13 +8850,25 @@ async function handleChatCompletion(c) {
 		max_tokens: selectedModel?.capabilities?.limits?.max_output_tokens
 	} : sanitizedPayload;
 	if (isNullish(originalPayload.max_tokens)) consola.debug("Set max_tokens to:", JSON.stringify(finalPayload.max_tokens));
-	return executeRequest({
+	if (isEndpointSupported(selectedModel, ENDPOINT.CHAT_COMPLETIONS)) return executeRequest({
 		c,
 		payload: finalPayload,
 		originalPayload,
 		selectedModel,
 		reqCtx
 	});
+	if (isResponsesSupported(selectedModel)) {
+		if (tuiLogId) tuiLogger.updateRequest(tuiLogId, { tags: ["via-responses"] });
+		return executeRequestViaResponses({
+			c,
+			payload: finalPayload,
+			originalPayload,
+			selectedModel,
+			reqCtx
+		});
+	}
+	const msg = `Model "${originalPayload.model}" does not support the ${ENDPOINT.CHAT_COMPLETIONS} endpoint`;
+	throw new HTTPError(msg, 400, msg);
 }
 /**
 * Execute the API call with reactive retry pipeline.
@@ -7470,34 +8877,102 @@ async function handleChatCompletion(c) {
 async function executeRequest(opts) {
 	const { c, payload, originalPayload, selectedModel, reqCtx } = opts;
 	const headersCapture = {};
-	const adapter = {
-		format: "openai-chat-completions",
-		sanitize: (p) => sanitizeOpenAIMessages(p),
-		execute: (p) => executeWithAdaptiveRateLimit(() => createChatCompletions(p, {
-			resolvedModel: selectedModel,
-			headersCapture,
-			onPrepared: ({ wire, headers }) => {
-				reqCtx.setAttemptWireRequest({
-					model: typeof wire.model === "string" ? wire.model : payload.model,
-					messages: Array.isArray(wire.messages) ? wire.messages : [],
-					payload: wire,
-					headers,
-					format: "openai-chat-completions"
-				});
-			}
-		})),
-		logPayloadSize: (p) => logPayloadSizeInfo(p, selectedModel)
-	};
-	const strategies = [
+	return executeRequestWithAdapter({
+		c,
+		payload,
+		originalPayload,
+		selectedModel,
+		reqCtx,
+		adapter: {
+			format: "openai-chat-completions",
+			sanitize: (p) => sanitizeOpenAIMessages(p),
+			execute: (p) => executeWithAdaptiveRateLimit(() => createChatCompletions(p, {
+				resolvedModel: selectedModel,
+				headersCapture,
+				onPrepared: ({ wire, headers }) => {
+					reqCtx.setAttemptWireRequest({
+						model: typeof wire.model === "string" ? wire.model : payload.model,
+						messages: Array.isArray(wire.messages) ? wire.messages : [],
+						payload: wire,
+						headers,
+						format: "openai-chat-completions"
+					});
+				}
+			})),
+			logPayloadSize: (p) => logPayloadSizeInfo(p, selectedModel)
+		},
+		strategies: createChatCompletionsStrategies("Completions"),
+		headersCapture
+	});
+}
+async function executeRequestViaResponses(opts) {
+	const { c, payload, originalPayload, selectedModel, reqCtx } = opts;
+	const headersCapture = {};
+	return executeRequestWithAdapter({
+		c,
+		payload,
+		originalPayload,
+		selectedModel,
+		reqCtx,
+		adapter: {
+			format: "openai-chat-completions",
+			sanitize: (p) => sanitizeOpenAIMessages(p),
+			execute: async (ccPayload) => {
+				const { payload: responsesPayload, droppedParams } = translateChatCompletionsToResponses(ccPayload);
+				if (droppedParams.length > 0) recordDroppedCcParamsWarning(reqCtx, ccPayload.model, droppedParams);
+				const finalPayload = state.normalizeResponsesCallIds ? normalizeCallIds(responsesPayload) : responsesPayload;
+				const result = await executeWithAdaptiveRateLimit(() => createResponses(finalPayload, {
+					resolvedModel: selectedModel,
+					headersCapture,
+					onPrepared: ({ wire, headers }) => {
+						reqCtx.setAttemptWireRequest({
+							model: typeof wire.model === "string" ? wire.model : ccPayload.model,
+							messages: extractInputItems(wire.input),
+							payload: wire,
+							headers,
+							format: "openai-responses"
+						});
+					}
+				}));
+				if (!ccPayload.stream) return {
+					result: translateResponsesResponseToCC(result.result),
+					queueWaitMs: result.queueWaitMs
+				};
+				return {
+					result: translateResponsesStream(result.result, createStreamTranslator({ includeUsage: ccPayload.stream_options?.include_usage ?? false })),
+					queueWaitMs: result.queueWaitMs
+				};
+			},
+			logPayloadSize: (p) => logPayloadSizeInfo(p, selectedModel)
+		},
+		strategies: createChatCompletionsStrategies("Completions(→Responses)"),
+		headersCapture
+	});
+}
+function recordDroppedCcParamsWarning(reqCtx, model, droppedParams) {
+	const message = `Chat Completions -> Responses translation dropped unsupported params: ${droppedParams.join(", ")}`;
+	if (reqCtx.warningMessages.some((warning) => warning.code === DROPPED_CC_PARAMS_WARNING_CODE && warning.message === message)) return;
+	consola.warn(`[CC→Responses] model=${model} ${message}`);
+	reqCtx.addWarningMessage({
+		code: DROPPED_CC_PARAMS_WARNING_CODE,
+		message
+	});
+	if (reqCtx.tuiLogId) tuiLogger.updateRequest(reqCtx.tuiLogId, { tags: ["dropped-params"] });
+}
+function createChatCompletionsStrategies(label) {
+	return [
 		createNetworkRetryStrategy(),
 		createTokenRefreshStrategy(),
 		createAutoTruncateStrategy({
 			truncate: (p, model, truncOpts) => autoTruncateOpenAI(p, model, truncOpts),
 			resanitize: (p) => sanitizeOpenAIMessages(p),
 			isEnabled: () => state.autoTruncate,
-			label: "Completions"
+			label
 		})
 	];
+}
+async function executeRequestWithAdapter(opts) {
+	const { c, payload, originalPayload, selectedModel, reqCtx, adapter, strategies, headersCapture } = opts;
 	let truncateResult;
 	try {
 		const result = await executeRequestPipeline({
@@ -7648,7 +9123,7 @@ chatCompletionRoutes.post("/", async (c) => {
 });
 //#endregion
 //#region src/routes/config/route.ts
-/** Current effective runtime configuration (read-only, sanitized) */
+/** Current effective runtime configuration and editable config.yaml routes */
 const configRoutes = new Hono();
 configRoutes.get("/", (c) => {
 	return c.json({
@@ -7659,13 +9134,21 @@ configRoutes.get("/", (c) => {
 		immutableThinkingMessages: state.immutableThinkingMessages,
 		dedupToolCalls: state.dedupToolCalls,
 		contextEditingMode: state.contextEditingMode,
+		contextEditingTrigger: state.contextEditingTrigger,
+		contextEditingKeepTools: state.contextEditingKeepTools,
+		contextEditingKeepThinking: state.contextEditingKeepThinking,
+		toolSearchEnabled: state.toolSearchEnabled,
+		cacheControlMode: state.cacheControlMode,
+		nonDeferredTools: state.nonDeferredTools,
 		rewriteSystemReminders: serializeRewriteSystemReminders(state.rewriteSystemReminders),
 		stripReadToolResultTags: state.stripReadToolResultTags,
 		systemPromptOverridesCount: state.systemPromptOverrides.length,
 		normalizeResponsesCallIds: state.normalizeResponsesCallIds,
+		upstreamWebSocket: state.upstreamWebSocket,
 		fetchTimeout: state.fetchTimeout,
 		streamIdleTimeout: state.streamIdleTimeout,
 		staleRequestMaxAge: state.staleRequestMaxAge,
+		modelRefreshInterval: state.modelRefreshInterval,
 		shutdownGracefulWait: state.shutdownGracefulWait,
 		shutdownAbortWait: state.shutdownAbortWait,
 		historyLimit: state.historyLimit,
@@ -7674,6 +9157,49 @@ configRoutes.get("/", (c) => {
 		rateLimiter: state.adaptiveRateLimitConfig ?? null
 	});
 });
+configRoutes.get("/yaml", async (c) => {
+	try {
+		const config = await loadRawConfigFile();
+		return c.json(config);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : "Failed to read config.yaml";
+		return c.json({
+			error: "Failed to read config.yaml",
+			details: [{
+				field: "$",
+				message
+			}]
+		}, 500);
+	}
+});
+configRoutes.put("/yaml", async (c) => {
+	let body;
+	try {
+		body = await c.req.json();
+	} catch {
+		return c.json({
+			error: "Invalid JSON body",
+			details: [{
+				field: "$",
+				message: "Request body must be valid JSON"
+			}]
+		}, 400);
+	}
+	const validation = validateConfigBody(body);
+	if (!validation.valid) return c.json({
+		error: "Config validation failed",
+		details: validation.details
+	}, 400);
+	const doc = await loadEditableConfigDocument();
+	mergeConfigIntoDocument(doc, validation.value);
+	await fs.mkdir(PATHS.APP_DIR, { recursive: true });
+	await fs.writeFile(PATHS.CONFIG_YAML, doc.toString(), "utf8");
+	resetConfigCache();
+	resetConfigManagedState();
+	await applyConfigToState();
+	const saved = await loadRawConfigFile();
+	return c.json(saved);
+});
 /**
 * Serialize rewriteSystemReminders for API output.
 * CompiledRewriteRule contains RegExp objects which don't serialize well —
@@ -7688,6 +9214,322 @@ function serializeRewriteSystemReminders(value) {
 		...rule.modelPattern ? { model: rule.modelPattern.source } : {}
 	}));
 }
+const TOP_LEVEL_KEYS = new Set([
+	"proxy",
+	"model_overrides",
+	"stream_idle_timeout",
+	"fetch_timeout",
+	"stale_request_max_age",
+	"model_refresh_interval",
+	"shutdown",
+	"history",
+	"anthropic",
+	"openai-responses",
+	"rate_limiter",
+	"compress_tool_results_before_truncate",
+	"system_prompt_overrides",
+	"system_prompt_prepend",
+	"system_prompt_append"
+]);
+const ANTHROPIC_KEYS = new Set([
+	"strip_server_tools",
+	"dedup_tool_calls",
+	"immutable_thinking_messages",
+	"strip_read_tool_result_tags",
+	"context_editing",
+	"context_editing_trigger",
+	"context_editing_keep_tools",
+	"context_editing_keep_thinking",
+	"tool_search",
+	"cache_control",
+	"auto_cache_control",
+	"non_deferred_tools",
+	"rewrite_system_reminders"
+]);
+const SHUTDOWN_KEYS = new Set(["graceful_wait", "abort_wait"]);
+const HISTORY_KEYS = new Set(["limit", "min_entries"]);
+const RESPONSES_KEYS = new Set(["normalize_call_ids", "upstream_websocket"]);
+const RATE_LIMITER_KEYS = new Set([
+	"retry_interval",
+	"request_interval",
+	"recovery_timeout",
+	"consecutive_successes"
+]);
+const ANTHROPIC_COLLECTION_KEYS = new Set(["rewrite_system_reminders", "non_deferred_tools"]);
+function validateConfigBody(input) {
+	if (!isPlainObject(input)) return {
+		valid: false,
+		details: [{
+			field: "$",
+			message: "Config body must be a JSON object",
+			value: input
+		}]
+	};
+	const body = input;
+	const details = [];
+	validateUnknownKeys(body, TOP_LEVEL_KEYS, "", details);
+	if (hasOwn(body, "proxy")) validateOptionalString(body.proxy, "proxy", details, { validateUrlScheme: true });
+	if (hasOwn(body, "model_overrides")) validateStringMap(body.model_overrides, "model_overrides", details);
+	if (hasOwn(body, "stream_idle_timeout")) validateNonNegativeInteger(body.stream_idle_timeout, "stream_idle_timeout", details);
+	if (hasOwn(body, "fetch_timeout")) validateNonNegativeInteger(body.fetch_timeout, "fetch_timeout", details);
+	if (hasOwn(body, "stale_request_max_age")) validateNonNegativeInteger(body.stale_request_max_age, "stale_request_max_age", details);
+	if (hasOwn(body, "model_refresh_interval")) validateNonNegativeInteger(body.model_refresh_interval, "model_refresh_interval", details);
+	if (hasOwn(body, "compress_tool_results_before_truncate")) validateBoolean(body.compress_tool_results_before_truncate, "compress_tool_results_before_truncate", details);
+	if (hasOwn(body, "system_prompt_prepend")) validateOptionalString(body.system_prompt_prepend, "system_prompt_prepend", details);
+	if (hasOwn(body, "system_prompt_append")) validateOptionalString(body.system_prompt_append, "system_prompt_append", details);
+	if (hasOwn(body, "system_prompt_overrides")) validateRewriteRules(body.system_prompt_overrides, "system_prompt_overrides", details, { allowModel: true });
+	if (hasOwn(body, "shutdown")) validateNestedObject(body.shutdown, "shutdown", SHUTDOWN_KEYS, details, (value, path) => validateNonNegativeInteger(value, path, details));
+	if (hasOwn(body, "history")) validateNestedObject(body.history, "history", HISTORY_KEYS, details, (value, path) => validateNonNegativeInteger(value, path, details));
+	if (hasOwn(body, "openai-responses")) validateNestedObject(body["openai-responses"], "openai-responses", RESPONSES_KEYS, details, (value, path) => validateBoolean(value, path, details));
+	if (hasOwn(body, "rate_limiter")) validateNestedObject(body.rate_limiter, "rate_limiter", RATE_LIMITER_KEYS, details, (value, path) => validateNonNegativeInteger(value, path, details));
+	if (hasOwn(body, "anthropic")) validateAnthropic(body.anthropic, details);
+	if (details.length > 0) return {
+		valid: false,
+		details
+	};
+	return {
+		valid: true,
+		value: input
+	};
+}
+function validateAnthropic(value, details) {
+	if (value === null) return;
+	if (!isPlainObject(value)) {
+		pushDetail(details, "anthropic", "Must be an object or null", value);
+		return;
+	}
+	validateUnknownKeys(value, ANTHROPIC_KEYS, "anthropic", details);
+	if (hasOwn(value, "strip_server_tools")) validateBoolean(value.strip_server_tools, "anthropic.strip_server_tools", details);
+	if (hasOwn(value, "immutable_thinking_messages")) validateBoolean(value.immutable_thinking_messages, "anthropic.immutable_thinking_messages", details);
+	if (hasOwn(value, "strip_read_tool_result_tags")) validateBoolean(value.strip_read_tool_result_tags, "anthropic.strip_read_tool_result_tags", details);
+	if (hasOwn(value, "dedup_tool_calls")) {
+		const allowed = new Set([
+			false,
+			true,
+			"input",
+			"result"
+		]);
+		validateEnum(value.dedup_tool_calls, "anthropic.dedup_tool_calls", allowed, details);
+	}
+	if (hasOwn(value, "context_editing")) validateEnum(value.context_editing, "anthropic.context_editing", new Set([
+		"off",
+		"clear-thinking",
+		"clear-tooluse",
+		"clear-both"
+	]), details);
+	if (hasOwn(value, "context_editing_trigger")) validateNonNegativeInteger(value.context_editing_trigger, "anthropic.context_editing_trigger", details);
+	if (hasOwn(value, "context_editing_keep_tools")) validateNonNegativeInteger(value.context_editing_keep_tools, "anthropic.context_editing_keep_tools", details);
+	if (hasOwn(value, "context_editing_keep_thinking")) validateNonNegativeInteger(value.context_editing_keep_thinking, "anthropic.context_editing_keep_thinking", details);
+	if (hasOwn(value, "tool_search")) validateBoolean(value.tool_search, "anthropic.tool_search", details);
+	if (hasOwn(value, "cache_control")) {
+		const valid = [
+			"disabled",
+			"passthrough",
+			"sanitize",
+			"proxied"
+		];
+		if (!valid.includes(value.cache_control)) details.push({
+			field: "anthropic.cache_control",
+			message: `Must be one of: ${valid.join(", ")}`,
+			value: value.cache_control
+		});
+	}
+	if (hasOwn(value, "auto_cache_control")) validateBoolean(value.auto_cache_control, "anthropic.auto_cache_control (deprecated)", details);
+	if (hasOwn(value, "non_deferred_tools")) validateStringArray(value.non_deferred_tools, "anthropic.non_deferred_tools", details);
+	if (hasOwn(value, "rewrite_system_reminders")) {
+		const rewrite = value.rewrite_system_reminders;
+		if (typeof rewrite === "boolean") return;
+		validateRewriteRules(rewrite, "anthropic.rewrite_system_reminders", details, { allowModel: false });
+	}
+}
+function validateUnknownKeys(object, allowedKeys, parentPath, details) {
+	for (const key of Object.keys(object)) {
+		if (allowedKeys.has(key)) continue;
+		pushDetail(details, parentPath ? `${parentPath}.${key}` : key, "Unknown config field", object[key]);
+	}
+}
+function validateNestedObject(value, field, allowedKeys, details, validateValue) {
+	if (value === null) return;
+	if (!isPlainObject(value)) {
+		pushDetail(details, field, "Must be an object or null", value);
+		return;
+	}
+	validateUnknownKeys(value, allowedKeys, field, details);
+	for (const [key, child] of Object.entries(value)) validateValue(child, `${field}.${key}`);
+}
+function validateStringMap(value, field, details) {
+	if (value === null) return;
+	if (!isPlainObject(value)) {
+		pushDetail(details, field, "Must be an object or null", value);
+		return;
+	}
+	for (const [key, target] of Object.entries(value)) {
+		if (key.trim().length === 0) pushDetail(details, `${field}.${key}`, "Override key must be a non-empty string", key);
+		if (typeof target !== "string" || target.trim().length === 0) pushDetail(details, `${field}.${key}`, "Override target must be a non-empty string", target);
+	}
+}
+function validateStringArray(value, field, details) {
+	if (value === null) return;
+	if (!Array.isArray(value)) {
+		pushDetail(details, field, "Must be an array of strings or null", value);
+		return;
+	}
+	for (const [index, item] of value.entries()) if (typeof item !== "string" || item.trim().length === 0) pushDetail(details, `${field}.${index}`, "Must be a non-empty string", item);
+}
+function validateRewriteRules(value, field, details, options) {
+	if (value === null) return;
+	if (!Array.isArray(value)) {
+		pushDetail(details, field, "Must be an array, boolean, or null", value);
+		return;
+	}
+	for (const [index, item] of value.entries()) {
+		const itemField = `${field}.${index}`;
+		if (!isPlainObject(item)) {
+			pushDetail(details, itemField, "Rule must be an object", item);
+			continue;
+		}
+		validateUnknownKeys(item, options.allowModel ? new Set([
+			"from",
+			"to",
+			"method",
+			"model"
+		]) : new Set([
+			"from",
+			"to",
+			"method"
+		]), itemField, details);
+		if (typeof item.from !== "string" || item.from.length === 0) {
+			pushDetail(details, `${itemField}.from`, "Must be a non-empty string", item.from);
+			continue;
+		}
+		if (typeof item.to !== "string") pushDetail(details, `${itemField}.to`, "Must be a string", item.to);
+		if (item.method !== void 0 && item.method !== "line" && item.method !== "regex") pushDetail(details, `${itemField}.method`, "Must be 'line' or 'regex'", item.method);
+		if (!options.allowModel && hasOwn(item, "model")) pushDetail(details, `${itemField}.model`, "Field is not supported here", item.model);
+		if (options.allowModel && item.model !== void 0 && typeof item.model !== "string") pushDetail(details, `${itemField}.model`, "Must be a string", item.model);
+		if (details.some((detail) => detail.field.startsWith(`${itemField}.`))) continue;
+		if (compileRewriteRule({
+			from: item.from,
+			to: item.to,
+			...item.method ? { method: item.method } : {},
+			...options.allowModel && typeof item.model === "string" ? { model: item.model } : {}
+		}) === null) pushDetail(details, `${itemField}.from`, "Invalid rewrite rule regex", item.from);
+	}
+}
+function validateOptionalString(value, field, details, options) {
+	if (value === null) return;
+	if (typeof value !== "string") {
+		pushDetail(details, field, "Must be a string or null", value);
+		return;
+	}
+	if (options?.validateUrlScheme) validateProxy(value, field, details);
+}
+function validateProxy(value, field, details) {
+	try {
+		const url = new URL(value);
+		if (![
+			"http:",
+			"https:",
+			"socks5:",
+			"socks5h:"
+		].includes(url.protocol)) pushDetail(details, field, "Proxy must use http, https, socks5, or socks5h scheme", value);
+	} catch {
+		pushDetail(details, field, "Proxy must be a valid URL", value);
+	}
+}
+function validateBoolean(value, field, details) {
+	if (value === null) return;
+	if (typeof value !== "boolean") pushDetail(details, field, "Must be a boolean or null", value);
+}
+function validateNonNegativeInteger(value, field, details) {
+	if (value === null) return;
+	if (!Number.isInteger(value) || Number(value) < 0) pushDetail(details, field, "Must be a non-negative integer or null", value);
+}
+function validateEnum(value, field, allowed, details) {
+	if (value === null) return;
+	if (!allowed.has(value)) pushDetail(details, field, `Must be one of: ${[...allowed].map(String).join(", ")}`, value);
+}
+function pushDetail(details, field, message, value) {
+	details.push({
+		field,
+		message,
+		...value !== void 0 ? { value } : {}
+	});
+}
+function hasOwn(object, key) {
+	return Object.prototype.hasOwnProperty.call(object, key);
+}
+function isPlainObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+async function loadEditableConfigDocument() {
+	try {
+		return parseExistingDocument(await fs.readFile(PATHS.CONFIG_YAML, "utf8"));
+	} catch (err) {
+		if (err.code === "ENOENT") return parseDocument("{}\n");
+		throw err;
+	}
+}
+function parseExistingDocument(content) {
+	const doc = parseDocument(content.trim().length > 0 ? content : "{}\n");
+	if (doc.errors.length > 0) throw new Error(doc.errors[0]?.message ?? "Invalid config.yaml");
+	const raw = doc.toJSON();
+	if (raw !== null && raw !== void 0 && (typeof raw !== "object" || Array.isArray(raw))) throw new Error("config.yaml must contain a top-level mapping");
+	return doc;
+}
+function mergeConfigIntoDocument(doc, body) {
+	if (hasOwn(body, "proxy")) setScalar(doc, ["proxy"], body.proxy);
+	if (hasOwn(body, "stream_idle_timeout")) setScalar(doc, ["stream_idle_timeout"], body.stream_idle_timeout);
+	if (hasOwn(body, "fetch_timeout")) setScalar(doc, ["fetch_timeout"], body.fetch_timeout);
+	if (hasOwn(body, "stale_request_max_age")) setScalar(doc, ["stale_request_max_age"], body.stale_request_max_age);
+	if (hasOwn(body, "model_refresh_interval")) setScalar(doc, ["model_refresh_interval"], body.model_refresh_interval);
+	if (hasOwn(body, "compress_tool_results_before_truncate")) setScalar(doc, ["compress_tool_results_before_truncate"], body.compress_tool_results_before_truncate);
+	if (hasOwn(body, "system_prompt_prepend")) setScalar(doc, ["system_prompt_prepend"], body.system_prompt_prepend);
+	if (hasOwn(body, "system_prompt_append")) setScalar(doc, ["system_prompt_append"], body.system_prompt_append);
+	if (hasOwn(body, "model_overrides")) replaceCollection(doc, ["model_overrides"], body.model_overrides);
+	if (hasOwn(body, "system_prompt_overrides")) replaceCollection(doc, ["system_prompt_overrides"], body.system_prompt_overrides);
+	if (hasOwn(body, "rate_limiter")) setNestedScalarContainer(doc, ["rate_limiter"], body.rate_limiter);
+	if (hasOwn(body, "shutdown")) setNestedScalarContainer(doc, ["shutdown"], body.shutdown);
+	if (hasOwn(body, "history")) setNestedScalarContainer(doc, ["history"], body.history);
+	if (hasOwn(body, "openai-responses")) setNestedScalarContainer(doc, ["openai-responses"], body["openai-responses"]);
+	if (hasOwn(body, "anthropic")) {
+		const anthropic = body.anthropic;
+		if (anthropic === null) doc.deleteIn(["anthropic"]);
+		else if (anthropic) {
+			setNestedScalarContainer(doc, ["anthropic"], anthropic, { excludeKeys: ANTHROPIC_COLLECTION_KEYS });
+			if (hasOwn(anthropic, "rewrite_system_reminders")) {
+				const rewrite = anthropic.rewrite_system_reminders;
+				replaceCollection(doc, ["anthropic", "rewrite_system_reminders"], Array.isArray(rewrite) && rewrite.length === 0 ? false : rewrite);
+			}
+			if (hasOwn(anthropic, "non_deferred_tools")) replaceCollection(doc, ["anthropic", "non_deferred_tools"], anthropic.non_deferred_tools);
+		}
+	}
+}
+function setScalar(doc, path, value) {
+	if (value === null || value === void 0) {
+		doc.deleteIn(path);
+		return;
+	}
+	doc.setIn(path, value);
+}
+function setNestedScalarContainer(doc, path, value, options) {
+	if (value === null || value === void 0) {
+		doc.deleteIn(path);
+		return;
+	}
+	if (!isPlainObject(value)) return;
+	for (const [key, child] of Object.entries(value)) {
+		if (options?.excludeKeys?.has(key)) continue;
+		setScalar(doc, [...path, key], child);
+	}
+}
+function replaceCollection(doc, path, value) {
+	if (value === null || value === void 0) {
+		doc.deleteIn(path);
+		return;
+	}
+	doc.deleteIn(path);
+	doc.setIn(path, value);
+}
 //#endregion
 //#region src/lib/openai/embeddings.ts
 const createEmbeddings = async (payload) => {
@@ -7743,7 +9585,9 @@ function handleGetEntries(c) {
 }
 function handleGetEntry(c) {
 	if (!isHistoryEnabled()) return c.json({ error: "History recording is not enabled" }, 400);
-	const entry = getEntry(c.req.param("id"));
+	const id = c.req.param("id");
+	if (!id) return c.json({ error: "Entry id is required" }, 400);
+	const entry = getEntry(id);
 	if (!entry) return c.json({ error: "Entry not found" }, 404);
 	return c.json(entry);
 }
@@ -7782,6 +9626,7 @@ function handleGetSessions(c) {
 function handleGetSession(c) {
 	if (!isHistoryEnabled()) return c.json({ error: "History recording is not enabled" }, 400);
 	const id = c.req.param("id");
+	if (!id) return c.json({ error: "Session id is required" }, 400);
 	const session = getSession(id);
 	if (!session) return c.json({ error: "Session not found" }, 404);
 	const query = c.req.query();
@@ -7796,7 +9641,9 @@ function handleGetSession(c) {
 }
 function handleDeleteSession(c) {
 	if (!isHistoryEnabled()) return c.json({ error: "History recording is not enabled" }, 400);
-	if (!deleteSession(c.req.param("id"))) return c.json({ error: "Session not found" }, 404);
+	const id = c.req.param("id");
+	if (!id) return c.json({ error: "Session id is required" }, 400);
+	if (!deleteSession(id)) return c.json({ error: "Session not found" }, 404);
 	return c.json({
 		success: true,
 		message: "Session deleted"
@@ -7805,6 +9652,7 @@ function handleDeleteSession(c) {
 //#endregion
 //#region src/routes/history/route.ts
 const historyRoutes = new Hono();
+historyRoutes.get("/", (c) => c.redirect("/ui#/v/activity", 302));
 historyRoutes.all("/", (c) => c.json({ error: "Not Found" }, 404));
 /** API endpoints */
 historyRoutes.get("/api/entries", handleGetEntries);
@@ -8535,7 +10383,7 @@ function processToolBlocks(messages, tools) {
 						orphanedToolResultCount++;
 						continue;
 					}
-				} else if (block.type !== "text" && block.type !== "image") {
+				} else if (block.type !== "text" && block.type !== "image" && block.type !== "document") {
 					orphanedToolResultCount++;
 					continue;
 				}
@@ -9082,12 +10930,12 @@ function isAnthropicFeatureUnsupported(modelId, feature) {
 /**
 * Context editing is supported by a broader set of models:
 * - Claude Haiku 4.5
-* - Claude Sonnet 4/4.5
+* - Claude Sonnet 4/4.5/4.6
 * - Claude Opus 4/4.1/4.5/4.6
 */
 function modelSupportsContextEditing(modelId) {
 	const normalized = normalizeForMatching(modelId);
-	return normalized.startsWith("claude-haiku-4-5") || normalized.startsWith("claude-sonnet-4-5") || normalized.startsWith("claude-sonnet-4") || normalized.startsWith("claude-opus-4-5") || normalized.startsWith("claude-opus-4-6") || normalized.startsWith("claude-opus-4-1") || normalized.startsWith("claude-opus-4");
+	return normalized.startsWith("claude-haiku-4-5") || normalized.startsWith("claude-sonnet-4-6") || normalized.startsWith("claude-sonnet-4-5") || normalized === "claude-sonnet-4" || normalized.startsWith("claude-opus-4-5") || normalized.startsWith("claude-opus-4-6") || normalized.startsWith("claude-opus-4-1") || normalized === "claude-opus-41" || normalized === "claude-opus-4";
 }
 /**
 * Check if context editing is enabled for a model.
@@ -9099,11 +10947,12 @@ function isContextEditingEnabled(modelId) {
 }
 /**
 * Tool search is supported by:
+* - Claude Sonnet 4.5/4.6
 * - Claude Opus 4.5/4.6
 */
 function modelSupportsToolSearch(modelId) {
 	const normalized = normalizeForMatching(modelId);
-	return normalized.startsWith("claude-opus-4-5") || normalized.startsWith("claude-opus-4-6");
+	return normalized.startsWith("claude-sonnet-4-5") || normalized.startsWith("claude-sonnet-4-6") || normalized.startsWith("claude-opus-4-5") || normalized.startsWith("claude-opus-4-6");
 }
 /**
 * Check if a model supports adaptive thinking (from model metadata).
@@ -9156,10 +11005,9 @@ function buildAnthropicBetaHeaders(modelId, resolvedModel, opts) {
 */
 function buildContextManagement(mode, hasThinking) {
 	if (mode === "off") return;
-	const triggerType = "input_tokens";
-	const triggerValue = 1e5;
-	const keepCount = 3;
-	const thinkingKeepTurns = 1;
+	const triggerValue = state.contextEditingTrigger;
+	const keepCount = state.contextEditingKeepTools;
+	const thinkingKeepTurns = state.contextEditingKeepThinking;
 	const edits = [];
 	if ((mode === "clear-thinking" || mode === "clear-both") && hasThinking) edits.push({
 		type: "clear_thinking_20251015",
@@ -9171,7 +11019,7 @@ function buildContextManagement(mode, hasThinking) {
 	if (mode === "clear-tooluse" || mode === "clear-both") edits.push({
 		type: "clear_tool_uses_20250919",
 		trigger: {
-			type: triggerType,
+			type: "input_tokens",
 			value: triggerValue
 		},
 		keep: {
@@ -9301,8 +11149,10 @@ function buildHistoryToolStubs(historyToolNames) {
 */
 function processToolPipeline(tools, modelId, messages) {
 	const existingNamesLower = new Set(tools.map((t) => t.name.toLowerCase()));
-	const toolSearchEnabled = modelSupportsToolSearch(modelId);
+	const toolSearchEnabled = state.toolSearchEnabled && modelSupportsToolSearch(modelId);
 	const historyToolNames = toolSearchEnabled ? collectHistoryToolNames(messages) : void 0;
+	const nonDeferred = [];
+	const deferred = [];
 	const result = [];
 	if (toolSearchEnabled) result.push({
 		name: TOOL_SEARCH_TOOL_NAME,
@@ -9311,11 +11161,11 @@ function processToolPipeline(tools, modelId, messages) {
 	});
 	for (const tool of tools) {
 		const normalized = tool.type ? tool : ensureInputSchema(tool);
-		const shouldDefer = toolSearchEnabled && tool.defer_loading !== false && !NON_DEFERRED_TOOL_NAMES.has(tool.name) && !historyToolNames?.has(tool.name);
-		result.push(shouldDefer ? {
+		if (toolSearchEnabled && tool.defer_loading !== false && !NON_DEFERRED_TOOL_NAMES.has(tool.name) && !state.nonDeferredTools.includes(tool.name) && !historyToolNames?.has(tool.name)) deferred.push({
 			...normalized,
 			defer_loading: true
-		} : normalized);
+		});
+		else nonDeferred.push(normalized);
 	}
 	for (const name of CLAUDE_CODE_OFFICIAL_TOOLS) if (!existingNamesLower.has(name.toLowerCase())) {
 		const stub = {
@@ -9323,19 +11173,24 @@ function processToolPipeline(tools, modelId, messages) {
 			description: `Claude Code ${name} tool`,
 			input_schema: EMPTY_INPUT_SCHEMA
 		};
-		result.push(stub);
+		nonDeferred.push(stub);
 	}
 	if (historyToolNames) {
-		const allResultNames = new Set(result.map((t) => t.name));
+		const allResultNames = new Set([
+			...nonDeferred,
+			...deferred,
+			...result
+		].map((t) => t.name));
 		for (const name of historyToolNames) if (!allResultNames.has(name)) {
 			consola.debug(`[ToolPipeline] Injecting stub for history-referenced tool: ${name}`);
-			result.push({
+			nonDeferred.push({
 				name,
 				description: `Stub for tool referenced in conversation history`,
 				input_schema: EMPTY_INPUT_SCHEMA
 			});
 		}
 	}
+	result.push(...nonDeferred, ...deferred);
 	const deferredCount = result.filter((t) => t.defer_loading === true).length;
 	const injectedCount = result.length - tools.length;
 	if (deferredCount > 0 || injectedCount > 0) consola.debug(`[ToolPipeline] ${result.length} tools (${deferredCount} deferred, ${injectedCount} injected, tool_search: ${toolSearchEnabled})`);
@@ -9422,10 +11277,13 @@ function stripServerTools(tools) {
 }
 //#endregion
 //#region src/lib/anthropic/request-preparation.ts
-const COPILOT_REJECTED_FIELDS = new Set(["output_config", "inference_geo"]);
+const COPILOT_REJECTED_FIELDS = new Set(["inference_geo"]);
+const CACHE_CONTROL_BREAKPOINT_LIMIT = 4;
+const EPHEMERAL_CACHE_CONTROL = { type: "ephemeral" };
 function prepareAnthropicRequest(payload, opts) {
 	const wire = buildWirePayload(payload);
-	adjustThinkingBudget(wire);
+	adjustThinkingBudget(wire, opts?.resolvedModel);
+	applyCacheControlMode(wire);
 	const model = wire.model;
 	const messages = wire.messages;
 	const thinking = wire.thinking;
@@ -9469,18 +11327,139 @@ function buildWirePayload(payload) {
 	if (wire.tools) wire.tools = stripServerTools(wire.tools);
 	return wire;
 }
-function adjustThinkingBudget(wire) {
+function adjustThinkingBudget(wire, resolvedModel) {
 	const thinking = wire.thinking;
 	if (!thinking || thinking.type === "disabled" || thinking.type === "adaptive") return;
 	const budgetTokens = thinking.budget_tokens;
 	if (!budgetTokens) return;
+	let adjusted = budgetTokens;
+	const minBudget = resolvedModel?.capabilities?.supports?.min_thinking_budget;
+	const maxBudget = resolvedModel?.capabilities?.supports?.max_thinking_budget;
 	const maxTokens = wire.max_tokens;
-	if (budgetTokens >= maxTokens) {
-		const adjusted = maxTokens - 1;
+	if (typeof minBudget === "number" && adjusted < minBudget) adjusted = minBudget;
+	if (typeof maxBudget === "number" && adjusted > maxBudget) adjusted = maxBudget;
+	if (typeof maxTokens === "number" && adjusted >= maxTokens) adjusted = maxTokens - 1;
+	if (adjusted !== budgetTokens) {
 		wire.thinking.budget_tokens = adjusted;
 		consola.debug(`[DirectAnthropic] Capped thinking.budget_tokens: ${budgetTokens} → ${adjusted} (max_tokens=${maxTokens})`);
 	}
 }
+/**
+* Dispatch cache_control handling based on the configured mode.
+* - disabled:    strip all cache_control from the wire payload
+* - passthrough: leave everything as-is
+* - sanitize:    normalize all cache_control to { type: "ephemeral" }
+* - proxied:     strip client cache_control then auto-inject breakpoints
+*/
+function applyCacheControlMode(wire) {
+	switch (state.cacheControlMode) {
+		case "disabled":
+			walkCacheControl(wire, () => void 0);
+			break;
+		case "passthrough": break;
+		case "sanitize":
+			walkCacheControl(wire, () => EPHEMERAL_CACHE_CONTROL);
+			break;
+		case "proxied":
+			walkCacheControl(wire, () => void 0);
+			addToolsAndSystemCacheControl(wire);
+			break;
+	}
+}
+function addToolsAndSystemCacheControl(wire) {
+	let remaining = CACHE_CONTROL_BREAKPOINT_LIMIT - countExistingCacheBreakpoints(wire);
+	if (remaining <= 0) return;
+	const toolResult = addToolCacheControl(wire.tools, remaining);
+	if (toolResult.changed) {
+		wire.tools = toolResult.tools;
+		remaining = toolResult.remaining;
+	}
+	if (remaining <= 0) return;
+	const systemResult = addSystemCacheControl(wire.system, remaining);
+	if (systemResult.changed) wire.system = systemResult.system;
+}
+function countExistingCacheBreakpoints(wire) {
+	return countCacheControlOccurrences(wire.messages) + countCacheControlOccurrences(wire.system) + countCacheControlOccurrences(wire.tools);
+}
+function countCacheControlOccurrences(value) {
+	if (Array.isArray(value)) return value.reduce((count, item) => count + countCacheControlOccurrences(item), 0);
+	if (!value || typeof value !== "object") return 0;
+	const record = value;
+	let count = record.cache_control ? 1 : 0;
+	for (const nested of Object.values(record)) if (nested !== record.cache_control) count += countCacheControlOccurrences(nested);
+	return count;
+}
+function addToolCacheControl(tools, remaining) {
+	if (!tools || remaining <= 0) return {
+		tools,
+		remaining,
+		changed: false
+	};
+	const lastNonDeferredIndex = findLastIndex(tools, (tool) => tool.defer_loading !== true);
+	if (lastNonDeferredIndex < 0 || tools[lastNonDeferredIndex].cache_control) return {
+		tools,
+		remaining,
+		changed: false
+	};
+	const updatedTools = [...tools];
+	updatedTools[lastNonDeferredIndex] = {
+		...updatedTools[lastNonDeferredIndex],
+		cache_control: EPHEMERAL_CACHE_CONTROL
+	};
+	return {
+		tools: updatedTools,
+		remaining: remaining - 1,
+		changed: true
+	};
+}
+function addSystemCacheControl(system, remaining) {
+	if (!Array.isArray(system) || remaining <= 0) return {
+		system,
+		changed: false
+	};
+	const lastSystemIndex = system.length - 1;
+	if (lastSystemIndex < 0 || system[lastSystemIndex].cache_control) return {
+		system,
+		changed: false
+	};
+	const updatedSystem = [...system];
+	updatedSystem[lastSystemIndex] = {
+		...updatedSystem[lastSystemIndex],
+		cache_control: EPHEMERAL_CACHE_CONTROL
+	};
+	return {
+		system: updatedSystem,
+		changed: true
+	};
+}
+function findLastIndex(items, predicate) {
+	for (let index = items.length - 1; index >= 0; index--) if (predicate(items[index])) return index;
+	return -1;
+}
+/**
+* Walk all cache_control occurrences in the wire payload (system, messages, tools)
+* and apply a handler. The handler receives the existing cache_control value and returns:
+* - undefined: delete the cache_control field
+* - an object: replace the cache_control field with this value
+*/
+function walkCacheControl(wire, handler) {
+	for (const key of [
+		"system",
+		"messages",
+		"tools"
+	]) if (Array.isArray(wire[key])) walkCacheControlArray(wire[key], handler);
+}
+function walkCacheControlArray(items, handler) {
+	for (const item of items) {
+		if (!item || typeof item !== "object") continue;
+		if ("cache_control" in item && item.cache_control) {
+			const replacement = handler(item.cache_control);
+			if (replacement === void 0) delete item.cache_control;
+			else item.cache_control = replacement;
+		}
+		if (Array.isArray(item.content)) walkCacheControlArray(item.content, handler);
+	}
+}
 //#endregion
 //#region src/lib/anthropic/client.ts
 /**
@@ -10193,7 +12172,9 @@ async function handleMessages(c) {
 	consola.debug(`[AnthropicRouting] ${anthropicPayload.model}: ${routingDecision.reason}`);
 	const reqCtx = getRequestContextManager().create({
 		endpoint: "anthropic-messages",
-		tuiLogId
+		sessionId: getSessionIdFromHeaders(c.req.raw.headers),
+		tuiLogId,
+		rawPath: c.req.path
 	});
 	reqCtx.setOriginalRequest({
 		model: clientModelName ?? anthropicPayload.model,
@@ -10459,39 +12440,18 @@ messagesRoutes.post("/count_tokens", async (c) => {
 //#endregion
 //#region src/routes/models/route.ts
 const modelsRoutes = new Hono();
-const EPOCH_ISO = (/* @__PURE__ */ new Date(0)).toISOString();
-function formatModel(model) {
-	return {
-		id: model.id,
-		object: "model",
-		type: "model",
-		created: 0,
-		created_at: EPOCH_ISO,
-		owned_by: model.vendor,
-		display_name: model.name,
-		capabilities: model.capabilities
-	};
-}
-function formatModelDetail(model) {
-	return {
-		...formatModel(model),
-		version: model.version,
-		preview: model.preview,
-		model_picker_enabled: model.model_picker_enabled,
-		model_picker_category: model.model_picker_category,
-		supported_endpoints: model.supported_endpoints,
-		billing: model.billing
-	};
+/** Strip internal fields that should not be exposed to external consumers. */
+function stripInternalFields(model) {
+	const { request_headers: _requestHeaders, ...rest } = model;
+	return rest;
 }
 modelsRoutes.get("/", async (c) => {
 	try {
 		if (!state.models) await cacheModels();
-		const formatter = c.req.query("detail") === "true" ? formatModelDetail : formatModel;
-		const models = state.models?.data.map((m) => formatter(m));
+		const models = state.models?.data.map(stripInternalFields);
 		return c.json({
-			object: "list",
-			data: models,
-			has_more: false
+			object: state.models?.object ?? "list",
+			data: models
 		});
 	} catch (error) {
 		return forwardError(c, error);
@@ -10508,7 +12468,7 @@ modelsRoutes.get("/:model", async (c) => {
 			param: "model",
 			code: "model_not_found"
 		} }, 404);
-		return c.json(formatModelDetail(model));
+		return c.json(stripInternalFields(model));
 	} catch (error) {
 		return forwardError(c, error);
 	}
@@ -10533,7 +12493,9 @@ async function handleResponses(c) {
 	const tuiLogId = c.get("tuiLogId");
 	const reqCtx = getRequestContextManager().create({
 		endpoint: "openai-responses",
-		tuiLogId
+		sessionId: getSessionIdFromHeaders(c.req.raw.headers) ?? resolveResponseSessionId(payload.previous_response_id),
+		tuiLogId,
+		rawPath: c.req.path
 	});
 	reqCtx.setOriginalRequest({
 		model: clientModel,
@@ -10560,6 +12522,8 @@ async function handleDirectResponses(opts) {
 	const headersCapture = {};
 	const adapter = createResponsesAdapter(selectedModel, headersCapture, (wireRequest) => {
 		reqCtx.setAttemptWireRequest(wireRequest);
+	}, (transport) => {
+		reqCtx.setAttemptTransport(transport);
 	});
 	const strategies = createResponsesStrategies();
 	try {
@@ -10576,6 +12540,8 @@ async function handleDirectResponses(opts) {
 		const response = pipelineResult.response;
 		if (!payload.stream) {
 			const responsesResponse = response;
+			if (!reqCtx.sessionId && responsesResponse.id) reqCtx.setSessionId(responsesResponse.id);
+			registerResponseSession(responsesResponse.id, reqCtx.sessionId);
 			const content = responsesOutputToContent(responsesResponse.output);
 			reqCtx.complete({
 				success: true,
@@ -10628,6 +12594,8 @@ async function handleDirectResponses(opts) {
 						} catch {}
 					}
 				}
+				if (!reqCtx.sessionId && acc.responseId) reqCtx.setSessionId(acc.responseId);
+				registerResponseSession(acc.responseId, reqCtx.sessionId);
 				const responseData = buildResponsesResponseData(acc, payload.model);
 				reqCtx.complete(responseData);
 			} catch (error) {
@@ -10675,7 +12643,18 @@ statusRoutes.get("/", async (c) => {
 	const now = Date.now();
 	const limiter = getAdaptiveRateLimiter();
 	const limiterStatus = limiter?.getStatus();
+	let serverStatus;
+	if (getIsShuttingDown()) serverStatus = "shutting_down";
+	else if (state.copilotToken && state.githubToken) serverStatus = "healthy";
+	else serverStatus = "unhealthy";
+	const rateLimiter = limiter && limiterStatus ? {
+		enabled: true,
+		...limiterStatus,
+		config: limiter.getConfig()
+	} : { enabled: false };
 	const memStats = getMemoryPressureStats();
+	const requestTelemetry = getRequestTelemetrySnapshot(now);
+	const upstreamWs = peekUpstreamWsManager();
 	let activeCount = 0;
 	try {
 		activeCount = getRequestContextManager().activeCount;
@@ -10692,7 +12671,7 @@ statusRoutes.get("/", async (c) => {
 		};
 	} catch {}
 	return c.json({
-		status: getIsShuttingDown() ? "shutting_down" : state.copilotToken && state.githubToken ? "healthy" : "unhealthy",
+		status: serverStatus,
 		uptime: serverStartTime > 0 ? Math.floor((now - serverStartTime) / 1e3) : 0,
 		version,
 		vsCodeVersion: state.vsCodeVersion ?? null,
@@ -10704,11 +12683,8 @@ statusRoutes.get("/", async (c) => {
 		},
 		quota,
 		activeRequests: { count: activeCount },
-		rateLimiter: limiterStatus ? {
-			enabled: true,
-			...limiterStatus,
-			config: limiter.getConfig()
-		} : { enabled: false },
+		rateLimiter,
+		requestTelemetry,
 		memory: {
 			heapUsedMB: memStats.heapUsedMB,
 			heapLimitMB: memStats.heapLimitMB,
@@ -10720,6 +12696,12 @@ statusRoutes.get("/", async (c) => {
 		models: {
 			totalCount: state.models?.data.length ?? 0,
 			availableCount: state.modelIds.size
+		},
+		upstream_websocket: {
+			enabled: state.upstreamWebSocket,
+			active_connections: upstreamWs?.activeCount ?? 0,
+			consecutive_fallbacks: upstreamWs?.consecutiveFallbacks ?? 0,
+			temporarily_disabled: upstreamWs?.temporarilyDisabled ?? false
 		}
 	});
 });
@@ -10760,7 +12742,29 @@ function getMimeType(path) {
 }
 //#endregion
 //#region src/routes/ui/route.ts
-const uiRoutes = new Hono();
+const UI_MOUNT_PREFIX = "/ui";
+const TEXT_RESPONSE_TYPES = [
+	"text/html",
+	"text/css",
+	"text/javascript",
+	"application/javascript",
+	"application/x-javascript"
+];
+const JAVASCRIPT_RESPONSE_TYPES = [
+	"text/javascript",
+	"application/javascript",
+	"application/x-javascript"
+];
+const VITE_DEV_PATH_PREFIXES = [
+	"/@vite",
+	"/@fs/",
+	"/@id/",
+	"/src/",
+	"/node_modules/",
+	"/__vite_ping",
+	"/__open-in-editor",
+	"/vite.svg"
+];
 /**
 * Resolve a UI directory that exists at runtime.
 * In dev mode this file lives at src/routes/ui/ — 3 levels below project root.
@@ -10771,6 +12775,68 @@ function resolveUiDir(subpath) {
 	return candidates.find((candidate) => existsSync(candidate)) ?? candidates[0];
 }
 const uiDir = resolveUiDir("history-v3/dist");
+function stripTrailingSlash(pathname) {
+	return pathname !== "/" ? pathname.replace(/\/+$/, "") : pathname;
+}
+function escapeRegExp(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function joinUrlPath(basePathname, requestPathname) {
+	const normalizedBase = stripTrailingSlash(basePathname);
+	const normalizedRequest = requestPathname.startsWith("/") ? requestPathname : `/${requestPathname}`;
+	if (normalizedBase === "/") return normalizedRequest;
+	return `${normalizedBase}${normalizedRequest}`;
+}
+function stripUiMountPrefix(pathname) {
+	if (pathname === UI_MOUNT_PREFIX) return "/";
+	if (pathname.startsWith(`${UI_MOUNT_PREFIX}/`)) return pathname.slice(3);
+	return pathname;
+}
+function isTextResponse(contentType) {
+	return TEXT_RESPONSE_TYPES.some((value) => contentType?.includes(value));
+}
+function isJavaScriptResponse(contentType) {
+	return JAVASCRIPT_RESPONSE_TYPES.some((value) => contentType?.includes(value));
+}
+function rewriteBaseUrlLiteral(content) {
+	return content.replace(/("BASE_URL"\s*:\s*")\/(")/g, `$1${UI_MOUNT_PREFIX}/$2`);
+}
+function rewriteQuotedPathPrefixes(content, fromPrefix, toPrefix) {
+	const quotePattern = new RegExp(`(["'\`])${escapeRegExp(fromPrefix)}`, "g");
+	return content.replace(quotePattern, `$1${toPrefix}`);
+}
+function rewriteParenthesizedPathPrefixes(content, fromPrefix, toPrefix) {
+	const parenthesizedPattern = new RegExp(`(\\()${escapeRegExp(fromPrefix)}`, "g");
+	return content.replace(parenthesizedPattern, `$1${toPrefix}`);
+}
+function rewriteProxyTextResponse(content, externalUiUrl, contentType) {
+	const externalBase = new URL(externalUiUrl);
+	const externalBasePath = stripTrailingSlash(externalBase.pathname);
+	const rewrittenBase = rewriteBaseUrlLiteral(content);
+	const rewriteBareParenthesizedPaths = !isJavaScriptResponse(contentType);
+	return VITE_DEV_PATH_PREFIXES.reduce((current, vitePathPrefix) => {
+		const externalPathPrefix = externalBasePath === "/" ? vitePathPrefix : `${externalBasePath}${vitePathPrefix}`;
+		const localPathPrefix = `${UI_MOUNT_PREFIX}${vitePathPrefix}`;
+		const absoluteExternalPrefix = `${externalBase.origin}${externalPathPrefix}`;
+		const rewrittenQuotedRelative = rewriteQuotedPathPrefixes(rewriteQuotedPathPrefixes(current, absoluteExternalPrefix, localPathPrefix), externalPathPrefix, localPathPrefix);
+		if (!rewriteBareParenthesizedPaths) return rewrittenQuotedRelative;
+		return rewriteParenthesizedPathPrefixes(rewriteParenthesizedPathPrefixes(rewrittenQuotedRelative, absoluteExternalPrefix, localPathPrefix), externalPathPrefix, localPathPrefix);
+	}, rewrittenBase);
+}
+function rewriteLocationHeader(location, externalUiUrl) {
+	const externalBase = new URL(externalUiUrl);
+	const resolvedLocation = new URL(location, externalBase);
+	if (!(resolvedLocation.origin === externalBase.origin)) return location;
+	const externalBasePath = stripTrailingSlash(externalBase.pathname);
+	return `${UI_MOUNT_PREFIX}${externalBasePath === "/" ? resolvedLocation.pathname : resolvedLocation.pathname.startsWith(`${externalBasePath}/`) || resolvedLocation.pathname === externalBasePath ? resolvedLocation.pathname.slice(externalBasePath.length) || "/" : resolvedLocation.pathname}${resolvedLocation.search}${resolvedLocation.hash}`;
+}
+function normalizeExternalUiUrl(externalUiUrl) {
+	const url = new URL(externalUiUrl);
+	if (!["http:", "https:"].includes(url.protocol)) throw new Error(`Unsupported external UI URL protocol: ${url.protocol}. Use http:// or https://`);
+	if (url.search || url.hash) throw new Error("--external-ui-url must not include query parameters or hash fragments");
+	const normalizedPathname = stripTrailingSlash(url.pathname);
+	return `${url.origin}${normalizedPathname === "/" ? "" : normalizedPathname}`;
+}
 async function serveIndexHtml(c) {
 	try {
 		await access(join(uiDir, "index.html"), constants.R_OK);
@@ -10780,7 +12846,7 @@ async function serveIndexHtml(c) {
 		return c.notFound();
 	}
 }
-async function serveAsset(c) {
+async function serveStaticAsset(c) {
 	const assetsIdx = c.req.path.indexOf("/assets/");
 	if (assetsIdx === -1) return c.notFound();
 	const filePath = c.req.path.slice(assetsIdx);
@@ -10797,14 +12863,59 @@ async function serveAsset(c) {
 		return c.notFound();
 	}
 }
-uiRoutes.get("/", serveIndexHtml);
-uiRoutes.get("/assets/*", serveAsset);
+async function proxyExternalUiRequest(c, externalUiUrl) {
+	const requestUrl = new URL(c.req.url);
+	const externalBase = new URL(externalUiUrl);
+	const upstreamUrl = new URL(externalBase);
+	upstreamUrl.pathname = joinUrlPath(externalBase.pathname, stripUiMountPrefix(c.req.path));
+	upstreamUrl.search = requestUrl.search;
+	const requestHeaders = new Headers(c.req.raw.headers);
+	requestHeaders.set("host", upstreamUrl.host);
+	requestHeaders.set("x-forwarded-host", requestUrl.host);
+	requestHeaders.set("x-forwarded-proto", requestUrl.protocol.replace(":", ""));
+	const body = c.req.method === "GET" || c.req.method === "HEAD" ? void 0 : await c.req.raw.arrayBuffer();
+	const upstreamResponse = await fetch(upstreamUrl, {
+		method: c.req.method,
+		headers: requestHeaders,
+		body,
+		redirect: "manual"
+	});
+	const responseHeaders = new Headers(upstreamResponse.headers);
+	const location = responseHeaders.get("location");
+	if (location) responseHeaders.set("location", rewriteLocationHeader(location, externalUiUrl));
+	if (isTextResponse(responseHeaders.get("content-type"))) {
+		const rewritten = rewriteProxyTextResponse(await upstreamResponse.text(), externalUiUrl, responseHeaders.get("content-type"));
+		responseHeaders.delete("content-length");
+		return new Response(rewritten, {
+			status: upstreamResponse.status,
+			statusText: upstreamResponse.statusText,
+			headers: responseHeaders
+		});
+	}
+	return new Response(upstreamResponse.body, {
+		status: upstreamResponse.status,
+		statusText: upstreamResponse.statusText,
+		headers: responseHeaders
+	});
+}
+function createUiRoutes(options = {}) {
+	const uiRoutes = new Hono();
+	if (options.externalUiUrl) {
+		const normalizedExternalUiUrl = normalizeExternalUiUrl(options.externalUiUrl);
+		uiRoutes.all("/", (c) => proxyExternalUiRequest(c, normalizedExternalUiUrl));
+		uiRoutes.all("/*", (c) => proxyExternalUiRequest(c, normalizedExternalUiUrl));
+		return uiRoutes;
+	}
+	uiRoutes.get("/", serveIndexHtml);
+	uiRoutes.get("/assets/*", serveStaticAsset);
+	return uiRoutes;
+}
 //#endregion
 //#region src/routes/index.ts
 /**
 * Register all HTTP routes on the given Hono app.
 */
-function registerHttpRoutes(app) {
+function registerHttpRoutes(app, options = {}) {
 	app.route("/chat/completions", chatCompletionRoutes);
 	app.route("/models", modelsRoutes);
 	app.route("/embeddings", embeddingsRoutes);
@@ -10820,7 +12931,7 @@ function registerHttpRoutes(app) {
 	app.route("/api/config", configRoutes);
 	app.route("/api/logs", logsRoutes);
 	app.route("/history", historyRoutes);
-	app.route("/ui", uiRoutes);
+	app.route("/ui", createUiRoutes(options));
 }
 /**
 * Register all WebSocket routes on the given Hono app.
@@ -10831,41 +12942,44 @@ function registerWsRoutes(app, wsUpgrade) {
 }
 //#endregion
 //#region src/server.ts
-const server = new Hono();
-server.onError((error, c) => {
-	if (c.req.header("upgrade")?.toLowerCase() === "websocket") {
-		consola.debug("WebSocket error:", error);
-		return c.text("", 500);
-	}
-	consola.error(`Unhandled route error in ${c.req.method} ${c.req.path}:`, error);
-	return forwardError(c, error);
-});
-const browserProbePaths = new Set(["/favicon.ico", "/.well-known/appspecific/com.chrome.devtools.json"]);
-server.notFound((c) => {
-	if (browserProbePaths.has(c.req.path)) return c.body(null, 204);
-	return c.json({ error: "Not Found" }, 404);
-});
-server.use(async (_c, next) => {
-	await applyConfigToState();
-	await ensureValidCopilotToken();
-	await next();
-});
-server.use(tuiMiddleware());
-server.use(cors());
-server.use(trimTrailingSlash());
-server.get("/", (c) => c.text("Server running"));
-server.get("/health", (c) => {
-	const healthy = Boolean(state.copilotToken && state.githubToken);
-	return c.json({
-		status: healthy ? "healthy" : "unhealthy",
-		checks: {
-			copilotToken: Boolean(state.copilotToken),
-			githubToken: Boolean(state.githubToken),
-			models: Boolean(state.models)
-		}
-	}, healthy ? 200 : 503);
-});
-registerHttpRoutes(server);
+function createServer(options = {}) {
+	const server = new Hono();
+	server.onError((error, c) => {
+		if (c.req.header("upgrade")?.toLowerCase() === "websocket") {
+			consola.debug("WebSocket error:", error);
+			return c.text("", 500);
+		}
+		consola.error(`Unhandled route error in ${c.req.method} ${c.req.path}:`, error);
+		return forwardError(c, error);
+	});
+	const browserProbePaths = new Set(["/favicon.ico", "/.well-known/appspecific/com.chrome.devtools.json"]);
+	server.notFound((c) => {
+		if (browserProbePaths.has(c.req.path)) return c.body(null, 204);
+		return c.json({ error: "Not Found" }, 404);
+	});
+	server.use(async (_c, next) => {
+		await applyConfigToState();
+		await ensureValidCopilotToken();
+		await next();
+	});
+	server.use(tuiMiddleware());
+	server.use(cors());
+	server.use(trimTrailingSlash());
+	server.get("/", (c) => c.text("Server running"));
+	server.get("/health", (c) => {
+		const healthy = Boolean(state.copilotToken && state.githubToken);
+		return c.json({
+			status: healthy ? "healthy" : "unhealthy",
+			checks: {
+				copilotToken: Boolean(state.copilotToken),
+				githubToken: Boolean(state.githubToken),
+				models: Boolean(state.models)
+			}
+		}, healthy ? 200 : 503);
+	});
+	registerHttpRoutes(server, { externalUiUrl: options.externalUiUrl });
+	return server;
+}
 //#endregion
 //#region src/start.ts
 /** Format limit values as "Xk" or "?" if not available */
@@ -10917,6 +13031,13 @@ async function runServer(options) {
 		consola.error(`Invalid account type: "${options.accountType}". Must be one of: ${VALID_ACCOUNT_TYPES.join(", ")}`);
 		process.exit(1);
 	}
+	let externalUiUrl;
+	if (options.externalUiUrl) try {
+		externalUiUrl = normalizeExternalUiUrl(options.externalUiUrl);
+	} catch (error) {
+		consola.error(error instanceof Error ? error.message : String(error));
+		process.exit(1);
+	}
 	if (options.verbose) {
 		consola.level = 5;
 		setCliState({ verbose: true });
@@ -10948,11 +13069,13 @@ async function runServer(options) {
 	});
 	initHistory(true, state.historyLimit);
 	startMemoryPressureMonitor();
+	await initRequestTelemetry();
 	const contextManager = initRequestContextManager();
 	registerContextConsumers(contextManager);
 	setConnectedDataFactory(() => contextManager.getAll().map((ctx) => ({
 		id: ctx.id,
 		endpoint: ctx.endpoint,
+		rawPath: ctx.rawPath,
 		state: ctx.state,
 		startTime: ctx.startTime,
 		durationMs: ctx.durationMs,
@@ -10971,11 +13094,14 @@ async function runServer(options) {
 		process.exit(1);
 	}
 	consola.info(`Available models:\n${state.models?.data.map((m) => formatModelInfo(m)).join("\n")}`);
+	const stopModelRefreshLoop = startModelRefreshLoop();
 	await loadPersistedLimits();
 	const serverUrl = `http://${options.host ?? "localhost"}:${options.port}`;
+	const server = createServer({ externalUiUrl });
 	const wsAdapter = await createWebSocketAdapter(server);
 	registerWsRoutes(server, wsAdapter.upgradeWebSocket);
-	consola.info(`Web UI: ${serverUrl}/ui`);
+	if (externalUiUrl) consola.info(`Web UI: ${serverUrl}/ui (proxied from ${externalUiUrl})`);
+	else consola.info(`Web UI: ${serverUrl}/ui`);
 	const bunWebSocket = typeof globalThis.Bun !== "undefined" ? (await import("hono/bun")).websocket : void 0;
 	let serverInstance;
 	try {
@@ -10994,7 +13120,11 @@ async function runServer(options) {
 	setServerInstance(serverInstance);
 	setupShutdownHandlers();
 	if (wsAdapter.injectWebSocket && serverInstance.nodeServer) wsAdapter.injectWebSocket(serverInstance.nodeServer);
-	await waitForShutdown();
+	try {
+		await waitForShutdown();
+	} finally {
+		stopModelRefreshLoop();
+	}
 }
 const start = defineCommand({
 	meta: {
@@ -11053,6 +13183,10 @@ const start = defineCommand({
 			type: "boolean",
 			default: true,
 			description: "Reactive auto-truncate: retries with truncated payload on limit errors (disable with --no-auto-truncate)"
+		},
+		"external-ui-url": {
+			type: "string",
+			description: "Proxy /ui to an external frontend dev/build server (for example http://localhost:5173)"
 		}
 	},
 	run({ args }) {
@@ -11078,7 +13212,9 @@ const start = defineCommand({
 			"http-proxy-from-env",
 			"httpProxyFromEnv",
 			"auto-truncate",
-			"autoTruncate"
+			"autoTruncate",
+			"external-ui-url",
+			"externalUiUrl"
 		]);
 		const unknownArgs = Object.keys(args).filter((key) => !knownArgs.has(key));
 		if (unknownArgs.length > 0) consola.warn(`Unknown argument(s): ${unknownArgs.map((a) => `--${a}`).join(", ")}`);
@@ -11092,7 +13228,8 @@ const start = defineCommand({
 			showGitHubToken: args["show-github-token"],
 			proxy: args.proxy,
 			httpProxyFromEnv: args["http-proxy-from-env"],
-			autoTruncate: args["auto-truncate"]
+			autoTruncate: args["auto-truncate"],
+			externalUiUrl: args["external-ui-url"]
 		});
 	}
 });