@jeffreycao/copilot-api 1.9.15 → 1.10.1

package/dist/{server-DkUKa2I6.js → server-DpVPS3zt.js}

@@ -1,9 +1,10 @@
 import { t as PATHS } from "./paths-DC-mqCY3.js";
-import { A as compactAutoContinuePromptStarts, C as prepareForCompact, D as requestContext, E as generateTraceId, F as state, N as compactSystemPromptStarts, O as resolveTraceId$1, T as prepareMessageProxyHeaders, c as getUUID, d as sleep, f as getCopilotUsage, g as copilotHeaders, h as copilotBaseUrl, j as compactMessageSections, l as isNullish, m as forwardError, n as cacheModels, o as generateRequestIdFromPayload, p as HTTPError, s as getRootSessionId, u as parseUserIdMetadata, w as prepareInteractionHeaders } from "./utils-Cj-ToKA6.js";
-import { a as getProviderConfig, c as isMessagesApiEnabled, i as getExtraPromptForModel, l as isResponsesApiContextManagementModel, n as getClaudeTokenMultiplier, o as getReasoningEffortForModel, r as getConfig, s as getSmallModel, t as getAnthropicApiKey, u as isResponsesApiWebSearchEnabled } from "./config-DrfmMOO-.js";
+import { D as generateTraceId, E as prepareMessageProxyHeaders, I as state, M as compactMessageSections, O as requestContext, P as compactSystemPromptStarts, T as prepareInteractionHeaders, _ as copilotWebSocketHeaders, c as getUUID, d as sleep, f as getCopilotUsage, g as copilotHeaders, h as copilotBaseUrl, j as compactAutoContinuePromptStarts, k as resolveTraceId$1, l as isNullish, m as forwardError, n as cacheModels, o as generateRequestIdFromPayload, p as HTTPError, s as getRootSessionId, u as parseUserIdMetadata, w as prepareForCompact } from "./utils-C5ej0z8n.js";
+import { a as getConfig, c as getReasoningEffortForModel, d as isResponsesApiContextManagementModel, f as isResponsesApiWebSearchEnabled, i as getClaudeTokenMultiplier, l as getSmallModel, o as getExtraPromptForModel, p as isResponsesApiWebSocketEnabled, r as getAnthropicApiKey, s as getProviderConfig, t as getProxyEnvDispatcher, u as isMessagesApiEnabled } from "./proxy-De0Po8kG.js";
 import consola from "consola";
 import fs from "node:fs/promises";
 import path from "node:path";
+import { createHash } from "node:crypto";
 import { Hono } from "hono";
 import { cors } from "hono/cors";
 import { logger } from "hono/logger";
@@ -11,6 +12,7 @@ import fs$1, { readFileSync } from "node:fs";
 import { streamSSE } from "hono/streaming";
 import util from "node:util";
 import { events } from "fetch-event-stream";
+import { WebSocket } from "undici";
 //#region src/lib/request-auth.ts
 function normalizeApiKeys(apiKeys) {
 	if (!Array.isArray(apiKeys)) {
@@ -502,19 +504,14 @@ async function flushTokenUsageEvents() {
 }
 function getPeriodRange(period, now = /* @__PURE__ */ new Date()) {
 	const start = new Date(now);
+	start.setHours(0, 0, 0, 0);
 	switch (period) {
-		case "day":
-			start.setHours(0, 0, 0, 0);
-			break;
-		case "week": {
-			const daysSinceMonday = (start.getDay() + 6) % 7;
-			start.setDate(start.getDate() - daysSinceMonday);
-			start.setHours(0, 0, 0, 0);
+		case "day": break;
+		case "week":
+			start.setDate(start.getDate() - 6);
 			break;
-		}
 		case "month":
-			start.setDate(1);
-			start.setHours(0, 0, 0, 0);
+			start.setDate(start.getDate() - 29);
 			break;
 		default: break;
 	}
@@ -527,7 +524,7 @@ function getPeriodRange(period, now = /* @__PURE__ */ new Date()) {
 			end.setDate(end.getDate() + 7);
 			break;
 		case "month":
-			end.setMonth(end.getMonth() + 1);
+			end.setDate(end.getDate() + 30);
 			break;
 		default: break;
 	}
@@ -536,6 +533,26 @@ function getPeriodRange(period, now = /* @__PURE__ */ new Date()) {
 		startMs: start.getTime()
 	};
 }
+function formatLocalDate(date) {
+	return `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, "0")}-${String(date.getDate()).padStart(2, "0")}`;
+}
+function createDailyIntervals(range) {
+	const intervals = [];
+	const cursor = new Date(range.startMs);
+	while (cursor.getTime() < range.endMs) {
+		const startMs = cursor.getTime();
+		const next = new Date(cursor);
+		next.setDate(next.getDate() + 1);
+		const endMs = Math.min(next.getTime(), range.endMs);
+		intervals.push({
+			date: formatLocalDate(cursor),
+			endMs,
+			startMs
+		});
+		cursor.setTime(endMs);
+	}
+	return intervals;
+}
 function createEmptyTotals() {
 	return {
 		cache_creation_input_tokens: 0,
@@ -546,6 +563,14 @@ function createEmptyTotals() {
 		total_tokens: 0
 	};
 }
+function addTotals(target, next) {
+	target.cache_creation_input_tokens += next.cache_creation_input_tokens;
+	target.cache_read_input_tokens += next.cache_read_input_tokens;
+	target.input_tokens += next.input_tokens;
+	target.output_tokens += next.output_tokens;
+	target.request_count += next.request_count;
+	target.total_tokens += next.total_tokens;
+}
 function createEmptySummary(period) {
 	const range = getPeriodRange(period);
 	return {
@@ -560,6 +585,27 @@ function createEmptySummary(period) {
 		totals: createEmptyTotals()
 	};
 }
+function createEmptyDailySummary(period) {
+	const range = getPeriodRange(period);
+	return {
+		byModel: [],
+		days: createDailyIntervals(range).map((interval) => ({
+			byModel: [],
+			date: interval.date,
+			end_ms: interval.endMs,
+			start_ms: interval.startMs,
+			totals: createEmptyTotals()
+		})),
+		period,
+		range: {
+			end_ms: range.endMs,
+			end_utc: new Date(range.endMs).toISOString(),
+			start_ms: range.startMs,
+			start_utc: new Date(range.startMs).toISOString()
+		},
+		totals: createEmptyTotals()
+	};
+}
 function createEmptyEventsPage(input) {
 	const range = getPeriodRange(input.period);
 	return {
@@ -577,6 +623,14 @@ function createEmptyEventsPage(input) {
 		total_pages: 1
 	};
 }
+function rangePayload(range) {
+	return {
+		end_ms: range.endMs,
+		end_utc: new Date(range.endMs).toISOString(),
+		start_ms: range.startMs,
+		start_utc: new Date(range.startMs).toISOString()
+	};
+}
 function numberFromRow(row, key) {
 	const value = row?.[key];
 	return typeof value === "number" && Number.isFinite(value) ? value : 0;
@@ -591,6 +645,12 @@ function totalsFromRow(row) {
 		total_tokens: numberFromRow(row, "total_tokens")
 	};
 }
+function modelSummaryFromRow(row) {
+	return {
+		...totalsFromRow(row),
+		model: typeof row.model === "string" ? row.model : "unknown"
+	};
+}
 function stringFromRow(row, key) {
 	const value = row[key];
 	return typeof value === "string" ? value : "";
@@ -618,12 +678,8 @@ function usageEventFromRow(row) {
 		user_id: stringFromRow(row, "user_id")
 	};
 }
-async function getTokenUsageSummary(period) {
-	if (!isTokenUsageStorageEnabled()) return createEmptySummary(period);
-	await flushTokenUsageEvents();
-	const range = getPeriodRange(period);
-	const db = await getDb();
-	const totalsRow = db.prepare(`
+function getTotalsRow(db, range) {
+	return db.prepare(`
     SELECT
       COUNT(*) AS request_count,
       COALESCE(SUM(input_tokens), 0) AS input_tokens,
@@ -634,8 +690,9 @@ async function getTokenUsageSummary(period) {
     FROM token_usage_events
     WHERE created_at_ms >= ? AND created_at_ms < ?
   `).get(range.startMs, range.endMs);
-	return {
-		byModel: db.prepare(`
+}
+function getModelRows(db, range) {
+	return db.prepare(`
     SELECT
       model,
       COUNT(*) AS request_count,
@@ -650,20 +707,47 @@ async function getTokenUsageSummary(period) {
     ORDER BY
       total_tokens DESC,
       model ASC
-  `).all(range.startMs, range.endMs).map((row) => ({
-			...totalsFromRow(row),
-			model: typeof row.model === "string" ? row.model : "unknown"
-		})),
+  `).all(range.startMs, range.endMs);
+}
+function createDailyBucket(interval, rows) {
+	const byModel = rows.map((row) => modelSummaryFromRow(row));
+	const totals = createEmptyTotals();
+	for (const model of byModel) addTotals(totals, model);
+	return {
+		byModel,
+		date: interval.date,
+		end_ms: interval.endMs,
+		start_ms: interval.startMs,
+		totals
+	};
+}
+async function getTokenUsageSummary(period) {
+	if (!isTokenUsageStorageEnabled()) return createEmptySummary(period);
+	await flushTokenUsageEvents();
+	const range = getPeriodRange(period);
+	const db = await getDb();
+	const totalsRow = getTotalsRow(db, range);
+	return {
+		byModel: getModelRows(db, range).map((row) => modelSummaryFromRow(row)),
 		period,
-		range: {
-			end_ms: range.endMs,
-			end_utc: new Date(range.endMs).toISOString(),
-			start_ms: range.startMs,
-			start_utc: new Date(range.startMs).toISOString()
-		},
+		range: rangePayload(range),
 		totals: totalsFromRow(totalsRow)
 	};
 }
+async function getTokenUsageDailySummary(period) {
+	if (!isTokenUsageStorageEnabled()) return createEmptyDailySummary(period);
+	await flushTokenUsageEvents();
+	const range = getPeriodRange(period);
+	const db = await getDb();
+	const intervals = createDailyIntervals(range);
+	return {
+		byModel: getModelRows(db, range).map((row) => modelSummaryFromRow(row)),
+		days: intervals.map((interval) => createDailyBucket(interval, getModelRows(db, interval))),
+		period,
+		range: rangePayload(range),
+		totals: totalsFromRow(getTotalsRow(db, range))
+	};
+}
 async function getTokenUsageEventsPage(input) {
 	if (!isTokenUsageStorageEnabled()) return createEmptyEventsPage(input);
 	await flushTokenUsageEvents();
@@ -831,10 +915,14 @@ const copilotRateLimitHeaders = {
 	session: "x-usage-ratelimit-session",
 	weekly: "x-usage-ratelimit-weekly"
 };
+const copilotQuotaSnapshotKeys = {
+	session: "5Hour-Session-RateLimits",
+	weekly: "Weekly-Session-RateLimits"
+};
 const hasGetMethod = (headers) => {
 	return "get" in headers && typeof headers.get === "function";
 };
-const getHeaderValue = (headers, headerName) => {
+const getHeaderValue$1 = (headers, headerName) => {
 	if (hasGetMethod(headers)) return headers.get(headerName);
 	const normalizedHeaderName = headerName.toLowerCase();
 	return Object.entries(headers).find(([key]) => key.toLowerCase() === normalizedHeaderName)?.[1] ?? null;
@@ -851,7 +939,7 @@ const parseCopilotRateLimitHeader = (headerValue) => {
 };
 const getCopilotRateLimitUsage = (headers, type) => {
 	const headerName = copilotRateLimitHeaders[type];
-	const headerValue = getHeaderValue(headers, headerName);
+	const headerValue = getHeaderValue$1(headers, headerName);
 	if (!headerValue) return null;
 	const parsed = parseCopilotRateLimitHeader(headerValue);
 	if (!parsed) return null;
@@ -860,15 +948,39 @@ const getCopilotRateLimitUsage = (headers, type) => {
 		...parsed
 	};
 };
+const getCopilotRateLimitUsageFromSnapshots = (snapshots, type) => {
+	const snapshot = snapshots?.[copilotQuotaSnapshotKeys[type]];
+	if (!isCopilotQuotaSnapshot(snapshot)) return null;
+	return {
+		remaining: String(snapshot.percent_remaining),
+		resetAt: snapshot.reset_date,
+		type
+	};
+};
 const logCopilotRateLimits = (headers) => {
 	for (const type of copilotRateLimitTypes) {
 		const usage = getCopilotRateLimitUsage(headers, type);
 		if (!usage) continue;
-		const d = new Date(usage.resetAt);
-		const dateStr = Number.isNaN(d.getTime()) ? usage.resetAt : d.toLocaleString();
-		consola.info(`Copilot ${usage.type} quota remaining: ${usage.remaining}, resets at: ${dateStr}`);
+		logCopilotRateLimitUsage(usage);
+	}
+};
+const logCopilotQuotaSnapshots = (snapshots) => {
+	for (const type of copilotRateLimitTypes) {
+		const usage = getCopilotRateLimitUsageFromSnapshots(snapshots, type);
+		if (!usage) continue;
+		logCopilotRateLimitUsage(usage);
 	}
 };
+const logCopilotRateLimitUsage = (usage) => {
+	const d = new Date(usage.resetAt);
+	const dateStr = Number.isNaN(d.getTime()) ? usage.resetAt : d.toLocaleString();
+	consola.info(`Copilot ${usage.type} quota remaining: ${usage.remaining}, resets at: ${dateStr}`);
+};
+const isCopilotQuotaSnapshot = (value) => {
+	if (!value || typeof value !== "object") return false;
+	const record = value;
+	return typeof record.entitlement === "string" && typeof record.percent_remaining === "number" && typeof record.overage_permitted === "boolean" && typeof record.overage_count === "number" && typeof record.reset_date === "string";
+};
 //#endregion
 //#region src/services/copilot/create-chat-completions.ts
 const createChatCompletions = async (payload, options) => {
@@ -2426,9 +2538,76 @@ const adjustInputTokens = (providerConfig, usage) => {
 	usage.input_tokens = Math.max(0, (usage.input_tokens ?? 0) - (usage.cache_read_input_tokens ?? 0) - (usage.cache_creation_input_tokens ?? 0));
 	debugJson(logger$4, "provider.messages.adjusted_usage:", usage);
 };
+const responsesUtilsDependencies = {
+	isResponsesApiContextManagementModel,
+	isResponsesApiWebSocketEnabled
+};
+const getResponsesRequestOptions = (payload) => {
+	return {
+		vision: hasVisionInput(payload),
+		initiator: hasAgentInitiator(payload) ? "agent" : "user"
+	};
+};
+const getResponsesTransportForModel = (selectedModel, options = {}) => {
+	const supportedEndpoints = selectedModel?.supported_endpoints ?? [];
+	const useWebSocket = responsesUtilsDependencies.isResponsesApiWebSocketEnabled();
+	if (options.compactType !== 1 && useWebSocket && supportedEndpoints.includes("ws:/responses")) return "websocket";
+	if (supportedEndpoints.includes("/responses")) return "http";
+	return null;
+};
+const hasAgentInitiator = (payload) => {
+	const lastItem = getPayloadItems(payload).at(-1);
+	if (!lastItem) return false;
+	if (!("role" in lastItem) || !lastItem.role) return true;
+	return (typeof lastItem.role === "string" ? lastItem.role.toLowerCase() : "") === "assistant";
+};
+const hasVisionInput = (payload) => {
+	return getPayloadItems(payload).some((item) => containsVisionContent(item));
+};
+const resolveResponsesCompactThreshold = (maxPromptTokens) => {
+	if (typeof maxPromptTokens === "number" && maxPromptTokens > 0) return Math.floor(maxPromptTokens * .9);
+	return 5e4;
+};
+const createCompactionContextManagement = (compactThreshold) => [{
+	type: "compaction",
+	compact_threshold: compactThreshold
+}];
+const applyResponsesApiContextManagement = (payload, maxPromptTokens) => {
+	if (payload.context_management !== void 0) return;
+	if (!responsesUtilsDependencies.isResponsesApiContextManagementModel(payload.model)) return;
+	payload.context_management = createCompactionContextManagement(resolveResponsesCompactThreshold(maxPromptTokens));
+};
+const compactInputByLatestCompaction = (payload) => {
+	if (!Array.isArray(payload.input) || payload.input.length === 0) return;
+	const latestCompactionMessageIndex = getLatestCompactionMessageIndex(payload.input);
+	if (latestCompactionMessageIndex === void 0) return;
+	payload.input = payload.input.slice(latestCompactionMessageIndex);
+};
+const getLatestCompactionMessageIndex = (input) => {
+	for (let index = input.length - 1; index >= 0; index -= 1) if (isCompactionInputItem(input[index])) return index;
+};
+const isCompactionInputItem = (value) => {
+	return "type" in value && typeof value.type === "string" && value.type === "compaction";
+};
+const getPayloadItems = (payload) => {
+	const result = [];
+	const { input } = payload;
+	if (Array.isArray(input)) result.push(...input);
+	return result;
+};
+const containsVisionContent = (value) => {
+	if (!value) return false;
+	if (Array.isArray(value)) return value.some((entry) => containsVisionContent(entry));
+	if (typeof value !== "object") return false;
+	const record = value;
+	if ((typeof record.type === "string" ? record.type.toLowerCase() : void 0) === "input_image") return true;
+	if (Array.isArray(record.content)) return record.content.some((entry) => containsVisionContent(entry));
+	return false;
+};
 //#endregion
 //#region src/services/copilot/create-responses.ts
-const createResponses = async (payload, { vision, initiator, subagentMarker, requestId, sessionId, compactType }) => {
+const RESPONSES_WEBSOCKET_IDLE_TIMEOUT_MS = 6e4;
+const createResponses = async (payload, { vision, initiator, subagentMarker, requestId, sessionId, compactType, transport = "http" }) => {
 	if (!state.copilotToken) throw new Error("Copilot token not found");
 	const headers = {
 		...copilotHeaders(state, requestId, vision),
@@ -2438,6 +2617,17 @@ const createResponses = async (payload, { vision, initiator, subagentMarker, req
 	prepareForCompact(headers, compactType);
 	payload.service_tier = void 0;
 	consola.log(`<-- model: ${payload.model}`);
+	if ((compactType === 1 ? "http" : transport) === "websocket") {
+		const stream = createPooledResponsesWebSocketStream(prepareResponsesWebSocketRequest(payload, headers, {
+			requestId,
+			subagentMarker
+		}));
+		if (payload.stream) return stream;
+		return await consumeResponsesWebSocketStream(stream);
+	}
+	return await createHttpResponses(payload, headers);
+};
+const createHttpResponses = async (payload, headers) => {
 	const response = await fetch(`${copilotBaseUrl(state)}/responses`, {
 		method: "POST",
 		headers,
@@ -2451,6 +2641,264 @@ const createResponses = async (payload, { vision, initiator, subagentMarker, req
 	if (payload.stream) return events(response);
 	return await response.json();
 };
+const prepareResponsesWebSocketRequest = (payload, preparedHeaders, options) => {
+	const initiator = getResponsesWebSocketInitiator(preparedHeaders);
+	return {
+		headers: copilotWebSocketHeaders(preparedHeaders),
+		poolKey: buildResponsesWebSocketPoolKey(payload, options),
+		payload: buildResponsesWebSocketPayload(payload, initiator)
+	};
+};
+const buildResponsesWebSocketPoolKey = (payload, { requestId, subagentMarker }) => {
+	const tokenFingerprint = state.copilotToken ? createHash("sha256").update(state.copilotToken).digest("hex").slice(0, 16) : "missing-token";
+	const subagentKey = subagentMarker ? [
+		subagentMarker.session_id,
+		subagentMarker.agent_id,
+		subagentMarker.agent_type
+	].join(":") : "main";
+	return [
+		tokenFingerprint,
+		payload.model,
+		requestId,
+		subagentKey
+	].map(encodePoolKeyPart).join("|");
+};
+const getResponsesWebSocketInitiator = (preparedHeaders) => {
+	return getHeaderValue(preparedHeaders, "x-initiator")?.toLowerCase() === "agent" ? "agent" : "user";
+};
+const createPooledResponsesWebSocketStream = (request) => runResponsesWebSocketPoolRequest(request);
+const buildResponsesWebSocketPayload = (payload, initiator) => {
+	const websocketPayload = {
+		...payload,
+		type: "response.create",
+		initiator
+	};
+	delete websocketPayload.stream;
+	delete websocketPayload["background"];
+	delete websocketPayload.service_tier;
+	return websocketPayload;
+};
+const buildResponsesWebSocketUrl = (baseUrl) => {
+	const url = new URL(`${baseUrl.replace(/\/+$/u, "")}/responses`);
+	if (url.protocol === "https:") url.protocol = "wss:";
+	else if (url.protocol === "http:") url.protocol = "ws:";
+	return url.toString();
+};
+const responsesWebSocketPool = /* @__PURE__ */ new Map();
+const runResponsesWebSocketPoolRequest = async function* (request) {
+	const entry = getResponsesWebSocketPoolEntry(request);
+	const release = await acquireResponsesWebSocketPoolEntry(request.poolKey, entry);
+	try {
+		const websocket = await entry.websocketPromise;
+		websocket.send(JSON.stringify(request.payload));
+		for await (const data of createWebSocketMessageStream(websocket)) {
+			const chunk = createResponsesWebSocketStreamChunk(data);
+			yield chunk;
+			if (isTerminalResponsesStreamChunk(chunk)) return;
+		}
+		removeResponsesWebSocketPoolEntry(request.poolKey, entry);
+		throw new Error("Responses websocket ended without a terminal response");
+	} catch (error) {
+		removeResponsesWebSocketPoolEntry(request.poolKey, entry);
+		throw toError(error);
+	} finally {
+		release();
+	}
+};
+const getResponsesWebSocketPoolEntry = (request) => {
+	const existing = responsesWebSocketPool.get(request.poolKey);
+	if (existing && !existing.closed) {
+		clearResponsesWebSocketIdleTimer(existing);
+		return existing;
+	}
+	const entry = createResponsesWebSocketPoolEntry(request);
+	responsesWebSocketPool.set(request.poolKey, entry);
+	return entry;
+};
+const createResponsesWebSocketPoolEntry = (request) => {
+	const entry = {
+		closed: false,
+		idleTimer: null,
+		lock: Promise.resolve(),
+		websocketPromise: openResponsesWebSocket({
+			headers: request.headers,
+			url: buildResponsesWebSocketUrl(copilotBaseUrl(state))
+		})
+	};
+	entry.websocketPromise.then((websocket) => {
+		websocket.addEventListener("close", () => {
+			removeResponsesWebSocketPoolEntry(request.poolKey, entry);
+		});
+		websocket.addEventListener("error", () => {
+			removeResponsesWebSocketPoolEntry(request.poolKey, entry);
+		});
+	}).catch(() => {
+		removeResponsesWebSocketPoolEntry(request.poolKey, entry);
+	});
+	return entry;
+};
+const acquireResponsesWebSocketPoolEntry = async (poolKey, entry) => {
+	clearResponsesWebSocketIdleTimer(entry);
+	let releaseCurrent;
+	const previousLock = entry.lock;
+	entry.lock = new Promise((resolve) => {
+		releaseCurrent = resolve;
+	});
+	await previousLock;
+	clearResponsesWebSocketIdleTimer(entry);
+	let released = false;
+	return () => {
+		if (released) return;
+		released = true;
+		releaseCurrent();
+		if (!entry.closed) scheduleResponsesWebSocketIdleClose(poolKey, entry);
+	};
+};
+const scheduleResponsesWebSocketIdleClose = (poolKey, entry) => {
+	clearResponsesWebSocketIdleTimer(entry);
+	entry.idleTimer = setTimeout(() => {
+		removeResponsesWebSocketPoolEntry(poolKey, entry);
+	}, RESPONSES_WEBSOCKET_IDLE_TIMEOUT_MS);
+	unrefTimer(entry.idleTimer);
+};
+const clearResponsesWebSocketIdleTimer = (entry) => {
+	if (entry.idleTimer) {
+		clearTimeout(entry.idleTimer);
+		entry.idleTimer = null;
+	}
+};
+const removeResponsesWebSocketPoolEntry = (poolKey, entry) => {
+	if (responsesWebSocketPool.get(poolKey) !== entry) return;
+	responsesWebSocketPool.delete(poolKey);
+	entry.closed = true;
+	clearResponsesWebSocketIdleTimer(entry);
+	entry.websocketPromise.then(closeResponsesWebSocket).catch(() => {});
+};
+const unrefTimer = (timer) => {
+	if (typeof timer === "object" && "unref" in timer && typeof timer.unref === "function") timer.unref();
+};
+const openResponsesWebSocket = async ({ headers, url }) => await new Promise((resolve, reject) => {
+	const dispatcher = getProxyEnvDispatcher();
+	const websocket = new WebSocket(url, dispatcher ? {
+		dispatcher,
+		headers
+	} : { headers });
+	const cleanup = () => {
+		websocket.removeEventListener("open", onOpen);
+		websocket.removeEventListener("error", onError);
+	};
+	const onOpen = () => {
+		cleanup();
+		resolve(websocket);
+	};
+	const onError = () => {
+		cleanup();
+		reject(/* @__PURE__ */ new Error("Failed to create responses websocket"));
+	};
+	websocket.addEventListener("open", onOpen);
+	websocket.addEventListener("error", onError);
+});
+const createWebSocketMessageStream = async function* (websocket) {
+	const queue = [];
+	let closed = false;
+	let error = null;
+	let notify = null;
+	const wake = () => {
+		notify?.();
+		notify = null;
+	};
+	const onMessage = (event) => {
+		queue.push(normalizeWebSocketMessageData(event.data));
+		wake();
+	};
+	const onClose = () => {
+		closed = true;
+		wake();
+	};
+	const onError = () => {
+		error = /* @__PURE__ */ new Error("Responses websocket stream error");
+		wake();
+	};
+	websocket.addEventListener("message", onMessage);
+	websocket.addEventListener("close", onClose);
+	websocket.addEventListener("error", onError);
+	try {
+		while (true) {
+			const item = queue.shift();
+			if (item) {
+				yield await item;
+				continue;
+			}
+			if (error) throw toError(error);
+			if (closed) break;
+			await new Promise((resolve) => {
+				notify = resolve;
+			});
+		}
+	} finally {
+		websocket.removeEventListener("message", onMessage);
+		websocket.removeEventListener("close", onClose);
+		websocket.removeEventListener("error", onError);
+	}
+};
+const normalizeWebSocketMessageData = async (data) => {
+	if (typeof data === "string") return data;
+	if (data instanceof ArrayBuffer) return new TextDecoder().decode(data);
+	if (ArrayBuffer.isView(data)) {
+		const view = data;
+		return new TextDecoder().decode(new Uint8Array(view.buffer, view.byteOffset, view.byteLength));
+	}
+	if (isTextReadable(data)) return await data.text();
+	return String(data);
+};
+const isTextReadable = (value) => {
+	if (!value || typeof value !== "object" || !("text" in value)) return false;
+	return typeof value.text === "function";
+};
+const toError = (value) => {
+	if (value instanceof Error) return value;
+	return new Error(String(value));
+};
+const getHeaderValue = (headers, headerName) => {
+	const normalizedHeaderName = headerName.toLowerCase();
+	return Object.entries(headers).find(([key]) => key.toLowerCase() === normalizedHeaderName)?.[1];
+};
+const encodePoolKeyPart = (value) => encodeURIComponent(value);
+const createResponsesWebSocketStreamChunk = (data) => {
+	if (data === "[DONE]") return { data };
+	try {
+		const parsed = JSON.parse(data);
+		if (parsed.type === "response.completed") logCopilotQuotaSnapshots(parsed.copilot_quota_snapshots);
+		return {
+			data: JSON.stringify(parsed),
+			event: typeof parsed.type === "string" ? parsed.type : void 0,
+			id: typeof parsed.id === "string" ? parsed.id : void 0
+		};
+	} catch {
+		return { data };
+	}
+};
+const isTerminalResponsesStreamChunk = (chunk) => {
+	if (!chunk.data || chunk.data === "[DONE]") return false;
+	try {
+		const parsed = JSON.parse(chunk.data);
+		return parsed.type === "response.completed" || parsed.type === "response.failed" || parsed.type === "response.incomplete" || parsed.type === "error";
+	} catch {
+		return false;
+	}
+};
+const consumeResponsesWebSocketStream = async (stream) => {
+	for await (const chunk of stream) {
+		if (!chunk.data || chunk.data === "[DONE]") continue;
+		const event = JSON.parse(chunk.data);
+		if (event.type === "error") throw new Error(event.message);
+		if (event.type === "response.completed" || event.type === "response.failed" || event.type === "response.incomplete") return event.response;
+	}
+	throw new Error("Responses websocket ended without a terminal response");
+};
+const closeResponsesWebSocket = (websocket) => {
+	if (websocket.readyState === WebSocket.CONNECTING || websocket.readyState === WebSocket.OPEN) websocket.close();
+};
 //#endregion
 //#region src/routes/messages/responses-translation.ts
 const MESSAGE_TYPE = "message";
@@ -3307,63 +3755,6 @@ const extractFunctionCallDetails = (rawEvent) => {
 	};
 };
 //#endregion
-//#region src/routes/responses/utils.ts
-const getResponsesRequestOptions = (payload) => {
-	return {
-		vision: hasVisionInput(payload),
-		initiator: hasAgentInitiator(payload) ? "agent" : "user"
-	};
-};
-const hasAgentInitiator = (payload) => {
-	const lastItem = getPayloadItems(payload).at(-1);
-	if (!lastItem) return false;
-	if (!("role" in lastItem) || !lastItem.role) return true;
-	return (typeof lastItem.role === "string" ? lastItem.role.toLowerCase() : "") === "assistant";
-};
-const hasVisionInput = (payload) => {
-	return getPayloadItems(payload).some((item) => containsVisionContent(item));
-};
-const resolveResponsesCompactThreshold = (maxPromptTokens) => {
-	if (typeof maxPromptTokens === "number" && maxPromptTokens > 0) return Math.floor(maxPromptTokens * .9);
-	return 5e4;
-};
-const createCompactionContextManagement = (compactThreshold) => [{
-	type: "compaction",
-	compact_threshold: compactThreshold
-}];
-const applyResponsesApiContextManagement = (payload, maxPromptTokens) => {
-	if (payload.context_management !== void 0) return;
-	if (!isResponsesApiContextManagementModel(payload.model)) return;
-	payload.context_management = createCompactionContextManagement(resolveResponsesCompactThreshold(maxPromptTokens));
-};
-const compactInputByLatestCompaction = (payload) => {
-	if (!Array.isArray(payload.input) || payload.input.length === 0) return;
-	const latestCompactionMessageIndex = getLatestCompactionMessageIndex(payload.input);
-	if (latestCompactionMessageIndex === void 0) return;
-	payload.input = payload.input.slice(latestCompactionMessageIndex);
-};
-const getLatestCompactionMessageIndex = (input) => {
-	for (let index = input.length - 1; index >= 0; index -= 1) if (isCompactionInputItem(input[index])) return index;
-};
-const isCompactionInputItem = (value) => {
-	return "type" in value && typeof value.type === "string" && value.type === "compaction";
-};
-const getPayloadItems = (payload) => {
-	const result = [];
-	const { input } = payload;
-	if (Array.isArray(input)) result.push(...input);
-	return result;
-};
-const containsVisionContent = (value) => {
-	if (!value) return false;
-	if (Array.isArray(value)) return value.some((entry) => containsVisionContent(entry));
-	if (typeof value !== "object") return false;
-	const record = value;
-	if ((typeof record.type === "string" ? record.type.toLowerCase() : void 0) === "input_image") return true;
-	if (Array.isArray(record.content)) return record.content.some((entry) => containsVisionContent(entry));
-	return false;
-};
-//#endregion
 //#region src/services/copilot/create-messages.ts
 const INTERLEAVED_THINKING_BETA = "interleaved-thinking-2025-05-14";
 const allowedAnthropicBetas = new Set([
@@ -3657,6 +4048,11 @@ const prepareMessagesApiPayload = (payload, selectedModel) => {
 const COPILOT_CONTEXT_CACHE_SYSTEM_MARKER_LIMIT = 2;
 const COPILOT_CONTEXT_CACHE_NON_SYSTEM_MARKER_LIMIT = 2;
 const COPILOT_CONTEXT_CACHE_CONTROL = { type: "ephemeral" };
+const messagesApiFlowDependencies = {
+	createChatCompletions,
+	createMessages,
+	createResponses
+};
 const handleWithChatCompletions = async (c, anthropicPayload, options) => {
 	const { logger, subagentMarker, requestId, sessionId, compactType } = options;
 	const openAIPayload = translateToOpenAI(anthropicPayload);
@@ -3668,7 +4064,7 @@ const handleWithChatCompletions = async (c, anthropicPayload, options) => {
 		payload: anthropicPayload
 	});
 	debugJson(logger, "Translated OpenAI request payload:", openAIPayload);
-	const response = await createChatCompletions(openAIPayload, {
+	const response = await messagesApiFlowDependencies.createChatCompletions(openAIPayload, {
 		subagentMarker,
 		requestId,
 		sessionId,
@@ -3731,9 +4127,11 @@ const handleWithResponsesApi = async (c, anthropicPayload, options) => {
 	compactInputByLatestCompaction(responsesPayload);
 	debugJson(logger, "Translated Responses payload:", responsesPayload);
 	const { vision, initiator } = getResponsesRequestOptions(responsesPayload);
-	const response = await createResponses(responsesPayload, {
+	const transport = getResponsesTransportForModel(selectedModel, { compactType: requestOptions.compactType }) ?? "http";
+	const response = await messagesApiFlowDependencies.createResponses(responsesPayload, {
 		vision,
 		initiator,
+		transport,
 		...requestOptions
 	});
 	if (responsesPayload.stream && isAsyncIterable$1(response)) {
@@ -3798,7 +4196,7 @@ const handleWithMessagesApi = async (c, anthropicPayload, options) => {
 		payload: anthropicPayload
 	});
 	debugJson(logger, "Translated Messages payload:", anthropicPayload);
-	const response = await createMessages(anthropicPayload, anthropicBetaHeader, {
+	const response = await messagesApiFlowDependencies.createMessages(anthropicPayload, anthropicBetaHeader, {
 		subagentMarker,
 		requestId,
 		sessionId,
@@ -3961,7 +4359,7 @@ async function handleCompletion(c) {
 		compactType,
 		logger: logger$3
 	});
-	if (shouldUseResponsesApi(selectedModel)) return await messagesFlowHandlers.handleWithResponsesApi(c, anthropicPayload, {
+	if (shouldUseResponsesApi(selectedModel, compactType)) return await messagesFlowHandlers.handleWithResponsesApi(c, anthropicPayload, {
 		subagentMarker,
 		selectedModel,
 		requestId,
@@ -3977,10 +4375,9 @@ async function handleCompletion(c) {
 		logger: logger$3
 	});
 }
-const RESPONSES_ENDPOINT$1 = "/responses";
 const MESSAGES_ENDPOINT = "/v1/messages";
-const shouldUseResponsesApi = (selectedModel) => {
-	return selectedModel?.supported_endpoints?.includes(RESPONSES_ENDPOINT$1) ?? false;
+const shouldUseResponsesApi = (selectedModel, compactType) => {
+	return Boolean(getResponsesTransportForModel(selectedModel, { compactType }));
 };
 const shouldUseMessagesApi = (selectedModel) => {
 	if (!isMessagesApiEnabled()) return false;
@@ -4113,9 +4510,14 @@ const handleItemId = (parsed, tracker) => {
 //#endregion
 //#region src/routes/responses/handler.ts
 const logger$1 = createHandlerLogger("responses-handler");
-const RESPONSES_ENDPOINT = "/responses";
+const responsesHandlerDependencies = {
+	checkRateLimit,
+	createResponses,
+	getConfig,
+	isResponsesApiWebSearchEnabled
+};
 const handleResponses = async (c) => {
-	await checkRateLimit(state);
+	await responsesHandlerDependencies.checkRateLimit(state);
 	const payload = await c.req.json();
 	debugJson(logger$1, "Responses request payload:", payload);
 	const requestId = generateRequestIdFromPayload({ messages: payload.input });
@@ -4129,10 +4531,11 @@ const handleResponses = async (c) => {
 	});
 	useFunctionApplyPatch(payload);
 	removeUnsupportedTools(payload);
-	if (!isResponsesApiWebSearchEnabled()) removeWebSearchTool(payload);
+	if (!responsesHandlerDependencies.isResponsesApiWebSearchEnabled()) removeWebSearchTool(payload);
 	compactInputByLatestCompaction(payload);
 	const selectedModel = state.models?.data.find((model) => model.id === payload.model);
-	if (!(selectedModel?.supported_endpoints?.includes(RESPONSES_ENDPOINT) ?? false)) return c.json({ error: {
+	const responsesTransport = getResponsesTransportForModel(selectedModel);
+	if (!responsesTransport) return c.json({ error: {
 		message: "This model does not support the responses endpoint. Please choose a different model.",
 		type: "invalid_request_error"
 	} }, 400);
@@ -4140,11 +4543,12 @@ const handleResponses = async (c) => {
 	debugJson(logger$1, "Translated Responses payload:", payload);
 	const { vision, initiator } = getResponsesRequestOptions(payload);
 	if (state.manualApprove) await awaitApproval();
-	const response = await createResponses(payload, {
+	const response = await responsesHandlerDependencies.createResponses(payload, {
 		vision,
 		initiator,
 		requestId,
-		sessionId
+		sessionId,
+		transport: responsesTransport
 	});
 	if (isStreamingRequested(payload) && isAsyncIterable(response)) {
 		logger$1.debug("Forwarding native Responses stream");
@@ -4184,7 +4588,7 @@ const parseResponsesStreamEvent = (chunk) => {
 	}
 };
 const useFunctionApplyPatch = (payload) => {
-	if (getConfig().useFunctionApplyPatch ?? true) {
+	if (responsesHandlerDependencies.getConfig().useFunctionApplyPatch ?? true) {
 		logger$1.debug("Using function tool apply_patch for responses");
 		if (Array.isArray(payload.tools)) {
 			const toolsArr = payload.tools;
@@ -4258,6 +4662,10 @@ tokenUsageRoute.get("/", async (c) => {
 	const summary = await getTokenUsageSummary(parsePeriod(c.req.query("period")));
 	return c.json(summary);
 });
+tokenUsageRoute.get("/daily", async (c) => {
+	const summary = await getTokenUsageDailySummary(parsePeriod(c.req.query("period")));
+	return c.json(summary);
+});
 tokenUsageRoute.get("/events", async (c) => {
 	const period = parsePeriod(c.req.query("period"));
 	const eventsPage = await getTokenUsageEventsPage({
@@ -4327,4 +4735,4 @@ server.route("/:provider/v1/models", providerModelRoutes);
 //#endregion
 export { server };
 
-//# sourceMappingURL=server-DkUKa2I6.js.map
+//# sourceMappingURL=server-DpVPS3zt.js.map