@nick3/copilot-api 1.9.15 → 1.10.4

package/dist/{server-BDCnb3Ao.js → server-DxQsi1x2.js}

@@ -1,21 +1,22 @@
-import { A as captureOutboundHeadersSnapshot, D as prepareMessageProxyHeaders, E as prepareInteractionHeaders, M as requestContext, N as resolveTraceId, O as accountFromState, T as prepareForCompact, _ as HTTPError, b as copilotHeaders, c as getUUID, d as parseUserIdMetadata, f as resolveAffinityKey, g as getCopilotUsage, h as getDeviceCode, k as state, l as isNullish, m as getGitHubUser, o as generateRequestIdFromPayload, p as sleep, s as getRootSessionId, t as pollAccessToken, u as normalizeStableSessionId, v as forwardError, w as normalizeDomain, y as copilotBaseUrl } from "./poll-access-token-CIPDXrcm.js";
-import { a as getAccountClientIdentityByLoginAndApp, b as getCurrentIdentityEnvironment, d as loadRegistry, g as saveRegistry, h as saveAccountToken, l as listAccountsFromRegistry, m as removeAccountToken, p as removeAccountFromRegistry, r as addAccountToRegistry, t as isAccountType } from "./account-DjCbqJ2Q.js";
+import { A as state, D as prepareInteractionHeaders, E as prepareForCompact, I as compactAutoContinuePromptStarts, L as compactMessageSections, N as requestContext, O as prepareMessageProxyHeaders, P as resolveTraceId, S as copilotWebSocketHeaders, T as normalizeDomain, _ as HTTPError, b as copilotHeaders, c as getUUID, d as parseUserIdMetadata, f as resolveAffinityKey, g as getCopilotUsage, h as getDeviceCode, j as captureOutboundHeadersSnapshot, k as accountFromState, l as isNullish, m as getGitHubUser, o as generateRequestIdFromPayload, p as sleep, s as getRootSessionId, t as pollAccessToken, u as normalizeStableSessionId, v as forwardError, y as copilotBaseUrl, z as compactSystemPromptStarts } from "./poll-access-token-BAgM2-7k.js";
+import { a as getAccountClientIdentityByLoginAndApp, b as getCurrentIdentityEnvironment, d as loadRegistry, g as saveRegistry, h as saveAccountToken, l as listAccountsFromRegistry, m as removeAccountToken, p as removeAccountFromRegistry, r as addAccountToRegistry, t as isAccountType } from "./account-COtMmvzU.js";
 import { r as ensurePaths, t as PATHS } from "./paths-CclKwouX.js";
-import { i as getRequestOutboundStore, r as getRedactedHeaderKeys } from "./request-outbound-CxvpSkOn.js";
-import { A as getReasoningEffortForModel, B as shouldCompactUseSmallModel, C as getConfig, D as getModelAliasesInfo, E as getModelAliases, F as isMessagesApiEnabled, I as isResponsesApiContextManagementModel, L as isResponsesApiWebSearchEnabled, M as isAccountAffinityEnabled, N as isForceAgentEnabled, O as getModelRefreshIntervalMs, P as isMessageStartInputTokensFallbackEnabled, R as mergeConfigWithDefaults, S as getClaudeTokenMultiplier, T as getLogLevel, _ as flushPendingCapture, a as accountsManager, b as getAliasTargetSet, c as extractResponsesUsageFromStreamEvent, d as getStatsStore, f as normalizeChatCompletionsUsage, g as copilotFetch, h as toLocalDateString, i as updateQuotaRefreshSchedulerFromConfig, j as getSmallModel, k as getProviderConfig, l as getClientIpInfo, m as normalizeMessagesUsage, o as applySharedSessionAffinityRetention, p as normalizeEmbeddingsUsage, s as extractResponsesUsageFromResult, u as getRequestHistoryStore, v as isDevModeEnabled, w as getExtraPromptForModel, x as getAnthropicApiKey, y as PROVIDER_TYPE_ANTHROPIC, z as resolveModelAlias } from "./quota-refresh-scheduler-runtime-XD2fDa2K.js";
+import { i as getRequestOutboundStore, r as getRedactedHeaderKeys } from "./request-outbound-Pu1kp2x8.js";
+import { A as getModelRefreshIntervalMs, B as isResponsesApiWebSocketEnabled, C as getAnthropicApiKey, D as getLogLevel, E as getExtraPromptForModel, F as isForceAgentEnabled, H as resolveModelAlias, I as isMessageStartInputTokensFallbackEnabled, L as isMessagesApiEnabled, M as getReasoningEffortForModel, N as getSmallModel, O as getModelAliases, P as isAccountAffinityEnabled, R as isResponsesApiContextManagementModel, S as getAliasTargetSet, T as getConfig, U as shouldCompactUseSmallModel, V as mergeConfigWithDefaults, _ as toLocalDateString, b as isDevModeEnabled, c as applySharedSessionAffinityRetention, d as getClientIpInfo, f as getRequestHistoryStore, g as normalizeMessagesUsage, h as normalizeEmbeddingsUsage, j as getProviderConfig, k as getModelAliasesInfo, l as extractResponsesUsageFromResult, m as normalizeChatCompletionsUsage, o as updateQuotaRefreshSchedulerFromConfig, p as getStatsStore, s as accountsManager, t as getProxyEnvDispatcher, u as extractResponsesUsageFromStreamEvent, v as copilotFetch, w as getClaudeTokenMultiplier, x as PROVIDER_TYPE_ANTHROPIC, y as flushPendingCapture, z as isResponsesApiWebSearchEnabled } from "./proxy-BwmADhKh.js";
 import consola from "consola";
 import fs, { readFile } from "node:fs/promises";
 import { createHash, randomUUID, timingSafeEqual } from "node:crypto";
 import * as path$1 from "node:path";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
+import fs$1, { existsSync } from "node:fs";
 import { Hono } from "hono";
 import { cors } from "hono/cors";
 import { logger } from "hono/logger";
-import fs$1, { existsSync } from "node:fs";
 import { streamSSE } from "hono/streaming";
 import { events } from "fetch-event-stream";
 import util from "node:util";
+import { WebSocket } from "undici";
 //#region src/lib/request-auth.ts
 const LEGACY_API_KEY_ENV_VAR = "COPILOT_API_KEY";
 let warnedLegacyEnvFallback = false;
@@ -350,10 +351,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;
@@ -370,7 +375,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;
@@ -379,15 +384,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/lib/request-initiator.ts
 function resolveEffectiveInitiator(baseInitiator, options) {
@@ -663,13 +692,6 @@ const getTokenCount = async (payload, model) => {
 		output: outputTokens
 	};
 };
-const compactSystemPromptStarts = ["You are a helpful AI assistant tasked with summarizing conversations", "You are an anchored context summarization assistant for coding sessions."];
-const compactAutoContinuePromptStarts = [
-	"This session is being continued from a previous conversation that ran out of context. The summary below covers the earlier portion of the conversation.",
-	"Continue if you have next steps, or stop and ask for clarification if you are unsure how to proceed.",
-	"The previous request exceeded the provider's size limit due to large media attachments. The conversation was compacted and media files were removed from context."
-];
-const compactMessageSections = ["Pending Tasks:", "Current Work:"];
 const IDE_EXECUTE_CODE_TOOL = "mcp__ide__executeCode";
 const IDE_GET_DIAGNOSTICS_TOOL = "mcp__ide__getDiagnostics";
 const IDE_GET_DIAGNOSTICS_DESCRIPTION = "Get language diagnostics from VS Code. Returns errors, warnings, information, and hints for files in the workspace.";
@@ -1734,6 +1756,7 @@ const CONFIG_KEYS = new Set([
 	"modelRefreshIntervalHours",
 	"sessionAffinityRetentionDays",
 	"useMessagesApi",
+	"useResponsesApiWebSocket",
 	"useResponsesApiWebSearch",
 	"devMode",
 	"quotaRefresh"
@@ -2225,6 +2248,7 @@ const CONFIG_PATCH_HANDLERS = {
 	modelRefreshIntervalHours: (next, value) => applyOptionalNumber(next, "modelRefreshIntervalHours", value),
 	sessionAffinityRetentionDays: (next, value) => applyOptionalNumber(next, "sessionAffinityRetentionDays", value),
 	useMessagesApi: (next, value) => applyOptionalBoolean(next, "useMessagesApi", value),
+	useResponsesApiWebSocket: (next, value) => applyOptionalBoolean(next, "useResponsesApiWebSocket", value),
 	useResponsesApiWebSearch: (next, value) => applyOptionalBoolean(next, "useResponsesApiWebSearch", value),
 	devMode: applyDevModeConfig,
 	quotaRefresh: applyQuotaRefreshConfig
@@ -4462,6 +4486,11 @@ const parseProviderModelAlias = (model) => {
 		provider
 	};
 };
+const resolveExistingProviderModelAlias = (model, resolveProvider) => {
+	const alias = parseProviderModelAlias(model);
+	if (!alias) return null;
+	return resolveProvider(alias.provider) ? alias : null;
+};
 const createFallbackModel = (modelId) => ({
 	capabilities: {
 		family: "provider",
@@ -4531,6 +4560,9 @@ async function handleProviderCountTokensForProvider(c, options) {
 }
 //#endregion
 //#region src/routes/messages/count-tokens-handler.ts
+const getProviderConfigResolver$1 = (c) => {
+	return c.get("providerConfigResolver") ?? getProviderConfig;
+};
 const resolveCountTokensModel = (modelId, findModel = findEndpointModel) => {
 	const selectedModel = findModel(modelId);
 	if (selectedModel) return {
@@ -4581,7 +4613,8 @@ async function countTokensViaAnthropic(c, payload) {
 */
 async function handleCountTokens(c) {
 	const anthropicPayload = await c.req.json();
-	const providerModelAlias = parseProviderModelAlias(anthropicPayload.model);
+	anthropicPayload.model = resolveModelAlias(anthropicPayload.model);
+	const providerModelAlias = resolveExistingProviderModelAlias(anthropicPayload.model, getProviderConfigResolver$1(c));
 	if (providerModelAlias) {
 		anthropicPayload.model = providerModelAlias.model;
 		return await handleProviderCountTokensForProvider(c, {
@@ -4617,7 +4650,8 @@ async function handleCountTokens(c) {
 }
 //#endregion
 //#region src/services/copilot/create-responses.ts
-const createResponses = async (payload, { vision, initiator, upstreamRequestId, subagentMarker, sessionId, compactType, requestId, fetchImpl }, account) => {
+const RESPONSES_WEBSOCKET_IDLE_TIMEOUT_MS = 6e4;
+const createResponses = async (payload, { vision, initiator, upstreamRequestId, subagentMarker, sessionId, compactType, requestId, fetchImpl, transport = "http" }, account) => {
 	const ctx = account ?? accountFromState();
 	if (!ctx.copilotToken) throw new Error("Copilot token not found");
 	const effectiveInitiator = resolveEffectiveInitiator(initiator, {
@@ -4632,14 +4666,30 @@ const createResponses = async (payload, { vision, initiator, upstreamRequestId,
 	prepareForCompact(headers, compactType);
 	payload.service_tier = void 0;
 	captureOutboundHeadersSnapshot(headers);
-	const response = await copilotFetch(`${copilotBaseUrl(ctx)}/responses`, {
+	consola.log(`<-- model: ${payload.model}`);
+	if ((compactType === 1 ? "http" : transport) === "websocket") {
+		const stream = createPooledResponsesWebSocketStream(prepareResponsesWebSocketRequest(payload, headers, {
+			copilotToken: ctx.copilotToken,
+			requestId: requestId ?? upstreamRequestId ?? "missing-request-id",
+			subagentMarker
+		}), copilotBaseUrl(ctx));
+		if (payload.stream) return stream;
+		return await consumeResponsesWebSocketStream(stream);
+	}
+	return await createHttpResponses(payload, headers, ctx, {
+		fetchImpl,
+		requestId
+	});
+};
+const createHttpResponses = async (payload, headers, account, options) => {
+	const response = await copilotFetch(`${copilotBaseUrl(account)}/responses`, {
 		method: "POST",
 		headers,
 		body: JSON.stringify(payload)
 	}, {
-		requestId,
+		requestId: options.requestId,
 		callSite: "responses",
-		fetchImpl
+		fetchImpl: options.fetchImpl
 	});
 	logCopilotRateLimits(response.headers);
 	if (!response.ok) {
@@ -4649,21 +4699,328 @@ const createResponses = async (payload, { vision, initiator, upstreamRequestId,
 	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, { copilotToken, requestId, subagentMarker }) => {
+	const tokenFingerprint = copilotToken ? createHash("sha256").update(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, baseUrl) => runResponsesWebSocketRequest(request, baseUrl);
+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 responsesWebSocketActiveRequests = /* @__PURE__ */ new Map();
+const runResponsesWebSocketRequest = async function* (request, baseUrl) {
+	const { entry, pooled } = getResponsesWebSocketRequestTarget(request, baseUrl);
+	const release = acquireResponsesWebSocketEntry(request.poolKey, entry, pooled);
+	try {
+		const websocket = await getReadyResponsesWebSocket(request.poolKey, entry, pooled);
+		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 getResponsesWebSocketRequestTarget = (request, baseUrl) => {
+	if (getResponsesWebSocketActiveRequestCount(request.poolKey) > 0) return {
+		entry: createResponsesWebSocketEntry(request, baseUrl),
+		pooled: false
+	};
+	const existing = responsesWebSocketPool.get(request.poolKey);
+	if (existing && !existing.closed) {
+		clearResponsesWebSocketIdleTimer(existing);
+		return {
+			entry: existing,
+			pooled: true
+		};
+	}
+	const entry = createResponsesWebSocketEntry(request, baseUrl);
+	responsesWebSocketPool.set(request.poolKey, entry);
+	return {
+		entry,
+		pooled: true
+	};
+};
+const createResponsesWebSocketEntry = (request, baseUrl) => {
+	const entry = {
+		closed: false,
+		idleTimer: null,
+		requestCount: 0,
+		websocketPromise: openResponsesWebSocket({
+			headers: request.headers,
+			url: buildResponsesWebSocketUrl(baseUrl)
+		})
+	};
+	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 acquireResponsesWebSocketEntry = (poolKey, entry, pooled) => {
+	clearResponsesWebSocketIdleTimer(entry);
+	incrementResponsesWebSocketActiveRequestCount(poolKey);
+	entry.requestCount += 1;
+	let released = false;
+	return () => {
+		if (released) return;
+		released = true;
+		entry.requestCount -= 1;
+		decrementResponsesWebSocketActiveRequestCount(poolKey);
+		if (entry.closed || entry.requestCount > 0) return;
+		if (pooled && responsesWebSocketPool.get(poolKey) === entry) {
+			scheduleResponsesWebSocketIdleClose(poolKey, entry);
+			return;
+		}
+		removeResponsesWebSocketPoolEntry(poolKey, entry);
+	};
+};
+const getReadyResponsesWebSocket = async (poolKey, entry, pooled) => {
+	if (entry.closed) throw new Error("Responses websocket became unavailable before the request started");
+	const websocket = await entry.websocketPromise;
+	if (entry.closed || pooled && responsesWebSocketPool.get(poolKey) !== entry) throw new Error("Responses websocket became unavailable before the request started");
+	if (websocket.readyState !== WebSocket.OPEN) {
+		removeResponsesWebSocketPoolEntry(poolKey, entry);
+		throw new Error("Responses websocket became unavailable before the request started");
+	}
+	return websocket;
+};
+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 getResponsesWebSocketActiveRequestCount = (poolKey) => responsesWebSocketActiveRequests.get(poolKey) ?? 0;
+const incrementResponsesWebSocketActiveRequestCount = (poolKey) => {
+	responsesWebSocketActiveRequests.set(poolKey, getResponsesWebSocketActiveRequestCount(poolKey) + 1);
+};
+const decrementResponsesWebSocketActiveRequestCount = (poolKey) => {
+	const nextCount = getResponsesWebSocketActiveRequestCount(poolKey) - 1;
+	if (nextCount <= 0) {
+		responsesWebSocketActiveRequests.delete(poolKey);
+		return;
+	}
+	responsesWebSocketActiveRequests.set(poolKey, nextCount);
+};
+const removeResponsesWebSocketPoolEntry = (poolKey, entry) => {
+	if (responsesWebSocketPool.get(poolKey) === entry) responsesWebSocketPool.delete(poolKey);
+	if (entry.closed) return;
+	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 createResponsesWebSocketError = (message, event) => {
+	const reason = event?.error ?? event?.message;
+	if (reason === void 0 || reason === "") return new Error(message);
+	const cause = toError(reason);
+	return new Error(`${message}: ${cause.message}`, { cause });
+};
+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 = (event) => {
+		cleanup();
+		reject(createResponsesWebSocketError("Failed to create responses websocket", event));
+	};
+	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 = (event) => {
+		error = createResponsesWebSocketError("Responses websocket stream error", event);
+		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";
 const COMPACTION_SIGNATURE_PREFIX = "cm1#";
 const COMPACTION_SIGNATURE_SEPARATOR = "@";
 const THINKING_TEXT = "Thinking...";
-const translateAnthropicMessagesToResponsesPayload = (payload, modelOverride) => {
-	const model = modelOverride ?? payload.model;
+const buildPromptCacheKey = (basePromptCacheKey, subagentAgentId) => {
+	if (!basePromptCacheKey) return null;
+	const normalizedSubagentAgentId = subagentAgentId?.trim() || null;
+	if (!normalizedSubagentAgentId) return basePromptCacheKey;
+	return `${basePromptCacheKey}:agent:${normalizedSubagentAgentId}`;
+};
+const translateAnthropicMessagesToResponsesPayload = (payload, options = {}) => {
+	const model = options.modelOverride ?? payload.model;
 	const input = [];
 	const applyPhase = shouldApplyPhase(payload.model);
 	for (const message of payload.messages) input.push(...translateMessage(message, payload.model, applyPhase));
+	const hasOriginalTools = Array.isArray(payload.tools) && payload.tools.length > 0;
 	const translatedTools = convertAnthropicTools(payload.tools);
 	const toolChoice = convertAnthropicToolChoice(payload.tool_choice);
-	const { sessionId: promptCacheKey } = parseUserIdMetadata(payload.metadata?.user_id);
-	return {
+	const { sessionId: metadataPromptCacheKey } = parseUserIdMetadata(payload.metadata?.user_id);
+	const sessionAffinity = requestContext.getStore()?.sessionAffinity?.trim() || null;
+	const promptCacheKey = buildPromptCacheKey(metadataPromptCacheKey ?? sessionAffinity, options.subagentAgentId);
+	const responsesPayload = {
 		model,
 		input,
 		instructions: translateSystemPrompt(payload.system, model),
@@ -4673,7 +5030,6 @@ const translateAnthropicMessagesToResponsesPayload = (payload, modelOverride) =>
 		tools: translatedTools,
 		tool_choice: toolChoice,
 		metadata: payload.metadata ? { ...payload.metadata } : null,
-		prompt_cache_key: promptCacheKey,
 		stream: payload.stream ?? null,
 		store: false,
 		parallel_tool_calls: true,
@@ -4683,6 +5039,8 @@ const translateAnthropicMessagesToResponsesPayload = (payload, modelOverride) =>
 		},
 		include: ["reasoning.encrypted_content"]
 	};
+	if (hasOriginalTools) responsesPayload.prompt_cache_key = promptCacheKey;
+	return responsesPayload;
 };
 const encodeCompactionCarrierSignature = (compaction) => {
 	return `${COMPACTION_SIGNATURE_PREFIX}${compaction.encrypted_content}${COMPACTION_SIGNATURE_SEPARATOR}${compaction.id}`;
@@ -6375,14 +6733,23 @@ const extractFunctionCallDetails = (rawEvent) => {
 		initialArguments: item.arguments
 	};
 };
-//#endregion
-//#region src/routes/responses/utils.ts
+const responsesUtilsDependencies = {
+	isResponsesApiContextManagementModel,
+	isResponsesApiWebSocketEnabled
+};
 const getResponsesRequestOptions = (payload) => {
 	return {
 		vision: hasVisionInput$1(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 items = getPayloadItems(payload);
 	if (isForceAgentEnabled()) return items.some((item) => isAgentRole(item));
@@ -6407,7 +6774,7 @@ const createCompactionContextManagement = (compactThreshold) => [{
 }];
 const applyResponsesApiContextManagement = (payload, maxPromptTokens) => {
 	if (payload.context_management !== void 0) return;
-	if (!isResponsesApiContextManagementModel(payload.model)) return;
+	if (!responsesUtilsDependencies.isResponsesApiContextManagementModel(payload.model)) return;
 	payload.context_management = createCompactionContextManagement(resolveResponsesCompactThreshold(maxPromptTokens));
 };
 const compactInputByLatestCompaction = (payload) => {
@@ -6677,6 +7044,14 @@ const logger$3 = createHandlerLogger("messages-handler");
 const CHAT_COMPLETIONS_ENDPOINT = "/chat/completions";
 const RESPONSES_ENDPOINT$1 = "/responses";
 const MESSAGES_ENDPOINT = "/v1/messages";
+const getProviderConfigResolver = (c) => {
+	return c.get("providerConfigResolver") ?? getProviderConfig;
+};
+const resolveProviderTargetModelAlias = (model, providerConfigResolver) => {
+	const targetModel = resolveModelAlias(model);
+	if (targetModel === model) return null;
+	return resolveExistingProviderModelAlias(targetModel, providerConfigResolver);
+};
 function normalizeProviderAliasUsage(usage) {
 	const tokensInput = usage.inputTokens === void 0 ? void 0 : Math.max(0, usage.inputTokens);
 	const tokensCachedInput = usage.cacheReadInputTokens;
@@ -6769,11 +7144,12 @@ async function handleProviderAliasCompletion(c, options) {
 }
 async function handleCompletion(c) {
 	const anthropicPayload = await c.req.json();
-	const providerModelAlias = parseProviderModelAlias(anthropicPayload.model);
-	if (providerModelAlias) return await handleProviderAliasCompletion(c, {
+	const providerConfigResolver = getProviderConfigResolver(c);
+	const providerTargetModelAlias = resolveExistingProviderModelAlias(anthropicPayload.model, providerConfigResolver) ?? resolveProviderTargetModelAlias(anthropicPayload.model, providerConfigResolver);
+	if (providerTargetModelAlias) return await handleProviderAliasCompletion(c, {
 		payload: anthropicPayload,
-		provider: providerModelAlias.provider,
-		providerModel: providerModelAlias.model
+		provider: providerTargetModelAlias.provider,
+		providerModel: providerTargetModelAlias.model
 	});
 	await checkRateLimit(state);
 	const store = getRequestHistoryStore();
@@ -7010,11 +7386,15 @@ const handleWithChatCompletions = async (params) => {
 };
 const handleWithResponsesApi = async (params) => {
 	const { c, anthropicPayload, openAIPayload, subagentMarker, sessionId, selectedModel, instr, compactType } = params;
-	const responsesPayload = translateAnthropicMessagesToResponsesPayload(anthropicPayload, selectedModel.id);
+	const responsesPayload = translateAnthropicMessagesToResponsesPayload(anthropicPayload, {
+		modelOverride: selectedModel.id,
+		subagentAgentId: subagentMarker?.agent_id
+	});
 	applyResponsesApiContextManagement(responsesPayload, selectedModel.capabilities.limits.max_prompt_tokens);
 	compactInputByLatestCompaction(responsesPayload);
 	debugJson(logger$3, "Translated Responses payload:", responsesPayload);
 	const { vision, initiator } = getResponsesRequestOptions(responsesPayload);
+	const transport = getResponsesTransportForModel(selectedModel, { compactType }) ?? "http";
 	const effectiveInitiator = resolveEffectiveInitiator(initiator, {
 		isCompact: compactType !== 0,
 		isSubagent: Boolean(subagentMarker)
@@ -7030,7 +7410,8 @@ const handleWithResponsesApi = async (params) => {
 			subagentMarker,
 			sessionId,
 			compactType,
-			requestId: instr.requestId
+			requestId: instr.requestId,
+			transport
 		}, ctx);
 		instr.confirmAffinity?.();
 		instr.confirmOwnership?.();
@@ -7840,6 +8221,7 @@ const handleResponses = async (c) => {
 	compactInputByLatestCompaction(upstreamPayload);
 	const premiumRemainingBefore = account.premiumRemaining;
 	const premiumUnlimitedBefore = account.unlimited;
+	const transport = getResponsesTransportForModel(selectedModel) ?? "http";
 	const { vision, initiator } = getResponsesRequestOptions(upstreamPayload);
 	request.initiator = initiator;
 	if (state.manualApprove) await awaitApproval();
@@ -7858,7 +8240,8 @@ const handleResponses = async (c) => {
 		vision,
 		initiator,
 		premiumRemainingBefore,
-		premiumUnlimitedBefore
+		premiumUnlimitedBefore,
+		transport
 	});
 	return handleNonStreamingResponses({
 		c,
@@ -7871,7 +8254,8 @@ const handleResponses = async (c) => {
 		vision,
 		initiator,
 		premiumRemainingBefore,
-		premiumUnlimitedBefore
+		premiumUnlimitedBefore,
+		transport
 	});
 };
 async function observeRequestError(accountId, error, affinity) {
@@ -7979,7 +8363,7 @@ function extractUsageFromChunkData(data) {
 	}
 }
 async function handleStreamingResponses(params) {
-	const { c, store, request, payload, selection, clientModel, accountCtx, vision, initiator, premiumRemainingBefore, premiumUnlimitedBefore } = params;
+	const { c, store, request, payload, selection, clientModel, accountCtx, vision, initiator, premiumRemainingBefore, premiumUnlimitedBefore, transport } = params;
 	let response;
 	try {
 		response = await createResponses(payload, {
@@ -7987,7 +8371,8 @@ async function handleStreamingResponses(params) {
 			initiator,
 			upstreamRequestId: request.upstreamRequestId,
 			sessionId: request.upstreamSessionId,
-			requestId: request.requestId
+			requestId: request.requestId,
+			transport
 		}, accountCtx);
 		selection.confirmAffinity?.();
 	} catch (error) {
@@ -8175,7 +8560,7 @@ async function streamResponsesAndLog(params) {
 	}
 }
 async function handleNonStreamingResponses(params) {
-	const { c, store, request, payload, selection, clientModel, accountCtx, vision, initiator, premiumRemainingBefore, premiumUnlimitedBefore } = params;
+	const { c, store, request, payload, selection, clientModel, accountCtx, vision, initiator, premiumRemainingBefore, premiumUnlimitedBefore, transport } = params;
 	const { account, reservation, selectedModel, endpoint, costUnits } = selection;
 	let usage = {};
 	let errorState = { httpStatus: 200 };
@@ -8186,7 +8571,8 @@ async function handleNonStreamingResponses(params) {
 			initiator,
 			upstreamRequestId: request.upstreamRequestId,
 			sessionId: request.upstreamSessionId,
-			requestId: request.requestId
+			requestId: request.requestId,
+			transport
 		}, accountCtx);
 		if (isAsyncIterable$1(response)) throw new Error("Upstream returned a stream unexpectedly");
 		selection.confirmAffinity?.();
@@ -8337,4 +8723,4 @@ server.route("/:provider/v1/models", providerModelRoutes);
 //#endregion
 export { server };
 
-//# sourceMappingURL=server-BDCnb3Ao.js.map
+//# sourceMappingURL=server-DxQsi1x2.js.map