@nick3/copilot-api 1.9.15 → 1.10.7

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

@@ -1,21 +1,23 @@
-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 isDeferredToolName, c as parseMcpToolSearchSentinel, i as isBridgeToolSearchName, l as selectDeferredToolsByNames, o as listDeferredToolNames, r as formatToolSearchBridgeArguments, s as normalizeToolSearchBridgeArguments, t as BRIDGE_TOOL_SEARCH_NAME, u as shouldEnableResponsesToolSearch } from "./tool-search-BrN7M0Dd.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-YVh74m0I.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 +352,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 +376,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 +385,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,17 +693,29 @@ 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.";
 const PDF_FILE_READ_PREFIX = "PDF file read:";
+const getBlockCacheControl = (block) => {
+	if (!block || block.type === "thinking") return;
+	const cacheControl = block.cache_control;
+	if (!cacheControl || typeof cacheControl !== "object") return;
+	return cacheControl;
+};
+const getLastMessageContentCacheControl = (lastMessage) => {
+	if (!lastMessage || !Array.isArray(lastMessage.content)) return;
+	const cacheControl = getBlockCacheControl(lastMessage.content.at(-1));
+	return cacheControl ? { ...cacheControl } : void 0;
+};
+const applyLastMessageCacheControl = (anthropicPayload, lastMessageCacheControl) => {
+	const cacheControl = lastMessageCacheControl ?? { type: "ephemeral" };
+	const lastMessage = anthropicPayload.messages.at(-1);
+	if (!lastMessage || !Array.isArray(lastMessage.content)) return;
+	const lastBlock = lastMessage.content.at(-1);
+	if (!lastBlock || lastBlock.type === "thinking" || lastBlock.cache_control) return;
+	lastBlock.cache_control = { ...cacheControl };
+};
 const getCompactCandidateText = (message) => {
 	if (message.role !== "user") return "";
 	if (typeof message.content === "string") return message.content;
@@ -1734,6 +1776,7 @@ const CONFIG_KEYS = new Set([
 	"modelRefreshIntervalHours",
 	"sessionAffinityRetentionDays",
 	"useMessagesApi",
+	"useResponsesApiWebSocket",
 	"useResponsesApiWebSearch",
 	"devMode",
 	"quotaRefresh"
@@ -2225,6 +2268,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 +4506,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 +4580,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 +4633,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 +4670,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 +4686,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 +4719,337 @@ 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 translatedTools = convertAnthropicTools(payload.tools);
-	const toolChoice = convertAnthropicToolChoice(payload.tool_choice);
-	const { sessionId: promptCacheKey } = parseUserIdMetadata(payload.metadata?.user_id);
-	return {
+	const toolSearchEnabled = shouldEnableResponsesToolSearch({
+		model: payload.model,
+		tools: payload.tools
+	});
+	const translationState = {
+		originalTools: payload.tools ?? [],
+		toolSearchEnabled,
+		toolUseNameById: /* @__PURE__ */ new Map()
+	};
+	for (const message of payload.messages) input.push(...translateMessage(message, payload.model, applyPhase, translationState));
+	const hasOriginalTools = Array.isArray(payload.tools) && payload.tools.length > 0;
+	const translatedTools = convertAnthropicTools(payload.tools, toolSearchEnabled);
+	const toolChoice = convertAnthropicToolChoice(payload.tool_choice, toolSearchEnabled);
+	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 +5059,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 +5068,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}`;
@@ -4701,11 +5088,11 @@ const decodeCompactionCarrierSignature = (signature) => {
 		};
 	}
 };
-const translateMessage = (message, model, applyPhase) => {
-	if (message.role === "user") return translateUserMessage(message);
-	return translateAssistantMessage(message, model, applyPhase);
+const translateMessage = (message, model, applyPhase, state) => {
+	if (message.role === "user") return translateUserMessage(message, state);
+	return translateAssistantMessage(message, model, applyPhase, state);
 };
-const translateUserMessage = (message) => {
+const translateUserMessage = (message, state) => {
 	if (typeof message.content === "string") return [createMessage("user", message.content)];
 	if (!Array.isArray(message.content)) return [];
 	const items = [];
@@ -4713,7 +5100,7 @@ const translateUserMessage = (message) => {
 	for (const block of message.content) {
 		if (block.type === "tool_result") {
 			flushPendingContent(pendingContent, items, { role: "user" });
-			items.push(createFunctionCallOutput(block));
+			items.push(createToolCallOutput(block, state));
 			continue;
 		}
 		const converted = translateUserContentBlock(block);
@@ -4722,7 +5109,7 @@ const translateUserMessage = (message) => {
 	flushPendingContent(pendingContent, items, { role: "user" });
 	return items;
 };
-const translateAssistantMessage = (message, model, applyPhase) => {
+const translateAssistantMessage = (message, model, applyPhase, state) => {
 	const assistantPhase = resolveAssistantPhase(model, message.content, applyPhase);
 	if (typeof message.content === "string") return [createMessage("assistant", message.content, assistantPhase)];
 	if (!Array.isArray(message.content)) return [];
@@ -4730,11 +5117,12 @@ const translateAssistantMessage = (message, model, applyPhase) => {
 	const pendingContent = [];
 	for (const block of message.content) {
 		if (block.type === "tool_use") {
+			state.toolUseNameById.set(block.id, block.name);
 			flushPendingContent(pendingContent, items, {
 				role: "assistant",
 				phase: assistantPhase
 			});
-			items.push(createFunctionToolCall(block));
+			items.push(createToolCall(block, state));
 			continue;
 		}
 		if (block.type === "thinking" && block.signature) {
@@ -4852,19 +5240,79 @@ const parseReasoningSignature$1 = (signature) => {
 		id: signature.slice(splitIndex + 1)
 	};
 };
-const createFunctionToolCall = (block) => ({
+const createFunctionToolCall = (block, state) => ({
 	type: "function_call",
 	call_id: block.id,
 	name: block.name,
 	arguments: JSON.stringify(block.input),
+	status: "completed",
+	...state.toolSearchEnabled && isDeferredToolName(block.name) ? { namespace: block.name } : {}
+});
+const createToolSearchCall = (block) => ({
+	type: "tool_search_call",
+	call_id: block.id,
+	arguments: normalizeToolSearchBridgeArguments(block.input),
+	execution: "client",
 	status: "completed"
 });
+const createToolCall = (block, state) => {
+	if (state.toolSearchEnabled && isBridgeToolSearchName(block.name)) return createToolSearchCall(block);
+	return createFunctionToolCall(block, state);
+};
 const createFunctionCallOutput = (block) => ({
 	type: "function_call_output",
 	call_id: block.tool_use_id,
 	output: convertToolResultContent(block.content),
 	status: block.is_error ? "incomplete" : "completed"
 });
+const createToolCallOutput = (block, state) => {
+	const toolUseName = state.toolUseNameById.get(block.tool_use_id);
+	if (state.toolSearchEnabled && isBridgeToolSearchName(toolUseName ?? "")) return createToolSearchOutput(block, state.originalTools);
+	return createFunctionCallOutput(block);
+};
+const createToolSearchOutput = (block, originalTools) => {
+	const referencedToolNames = resolveToolSearchReferencedToolNames(block.content, originalTools);
+	return {
+		type: "tool_search_output",
+		call_id: block.tool_use_id,
+		tools: referencedToolNames.map((toolName) => convertDeferredToolToNamespace(resolveDeferredTool(toolName, originalTools))),
+		execution: "client",
+		status: block.is_error ? "incomplete" : "completed"
+	};
+};
+const resolveToolSearchReferencedToolNames = (content, originalTools) => {
+	const explicitReferences = extractToolReferenceNames(content);
+	if (explicitReferences.length > 0) return uniqueToolNames(explicitReferences);
+	const sentinel = extractMcpToolSearchSentinel(content);
+	if (sentinel) return selectDeferredToolsByNames(sentinel.names, originalTools).map((tool) => tool.name);
+	return [];
+};
+const extractToolReferenceNames = (content) => {
+	if (!Array.isArray(content)) return [];
+	return content.flatMap((block) => block.type === "tool_reference" ? [block.tool_name] : []);
+};
+const extractMcpToolSearchSentinel = (content) => {
+	if (typeof content === "string") return parseMcpToolSearchSentinel(content);
+	for (const block of content) {
+		if (block.type !== "text") continue;
+		const sentinel = parseMcpToolSearchSentinel(block.text);
+		if (sentinel) return sentinel;
+	}
+	return null;
+};
+const resolveDeferredTool = (toolName, originalTools) => {
+	const tool = originalTools.find((candidate) => candidate.name === toolName);
+	if (tool && isDeferredToolName(tool.name)) return tool;
+	throw createInvalidRequestError(`Tool reference '${toolName}' has no corresponding deferred tool definition`);
+};
+const uniqueToolNames = (toolNames) => [...new Set(toolNames)];
+const createInvalidRequestError = (message) => new HTTPError(message, new Response(JSON.stringify({ error: {
+	message,
+	type: "invalid_request_error"
+} }), {
+	status: 400,
+	headers: { "content-type": "application/json" }
+}));
 const translateSystemPrompt = (system, model) => {
 	if (!system) return null;
 	const extraPrompt = getExtraPromptForModel(model);
@@ -4875,31 +5323,83 @@ const translateSystemPrompt = (system, model) => {
 	}).join(" ");
 	return text.length > 0 ? text : null;
 };
-const convertAnthropicTools = (tools) => {
+const convertAnthropicTools = (tools, toolSearchEnabled) => {
 	if (!tools || tools.length === 0) return null;
-	return tools.map((tool) => ({
+	const converted = [];
+	let addedToolSearch = false;
+	const searchableToolNames = toolSearchEnabled ? listDeferredToolNames(tools) : [];
+	for (const tool of tools) {
+		if (isBridgeToolSearchName(tool.name)) {
+			if (toolSearchEnabled && !addedToolSearch) {
+				converted.push(createResponsesToolSearchDefinition(searchableToolNames));
+				addedToolSearch = true;
+			}
+			continue;
+		}
+		if (toolSearchEnabled && isDeferredToolName(tool.name)) {
+			converted.push(convertDeferredToolToNamespace(tool));
+			continue;
+		}
+		converted.push(convertToolToFunction(tool));
+	}
+	return converted;
+};
+const createResponsesToolSearchDefinition = (searchableToolNames) => ({
+	type: "tool_search",
+	execution: "client",
+	description: "Load deferred tools by exact name before using them. Return only the searchable tool names you need for the next step.",
+	parameters: {
+		type: "object",
+		properties: { names: {
+			type: "array",
+			description: "Exact deferred tool names to load.",
+			items: {
+				type: "string",
+				enum: searchableToolNames
+			},
+			minItems: 1
+		} },
+		required: ["names"],
+		additionalProperties: false
+	}
+});
+const convertToolToFunction = (tool) => ({
+	type: "function",
+	name: tool.name,
+	parameters: normalizeToolSchema(tool.input_schema),
+	strict: false,
+	...tool.description ? { description: tool.description } : {}
+});
+const convertDeferredToolToNamespace = (tool) => ({
+	type: "namespace",
+	name: tool.name,
+	...tool.description ? { description: tool.description } : {},
+	tools: [{
 		type: "function",
 		name: tool.name,
 		parameters: normalizeToolSchema(tool.input_schema),
 		strict: false,
+		defer_loading: true,
 		...tool.description ? { description: tool.description } : {}
-	}));
-};
-const convertAnthropicToolChoice = (choice) => {
+	}]
+});
+const convertAnthropicToolChoice = (choice, toolSearchEnabled) => {
 	if (!choice) return "auto";
 	switch (choice.type) {
 		case "auto": return "auto";
 		case "any": return "required";
-		case "tool": return choice.name ? {
-			type: "function",
-			name: choice.name
-		} : "auto";
+		case "tool":
+			if (toolSearchEnabled && choice.name && isBridgeToolSearchName(choice.name)) return "auto";
+			return choice.name ? {
+				type: "function",
+				name: choice.name
+			} : "auto";
 		case "none": return "none";
 		default: return "auto";
 	}
 };
-const translateResponsesResultToAnthropic = (response) => {
-	const contentBlocks = mapOutputToAnthropicContent(response.output);
+const translateResponsesResultToAnthropic = (response, options) => {
+	const contentBlocks = mapOutputToAnthropicContent(response.output, options);
 	const usage = mapResponsesUsage(response);
 	let anthropicContent = fallbackContentBlocks(response.output_text);
 	if (contentBlocks.length > 0) anthropicContent = contentBlocks;
@@ -4915,7 +5415,7 @@ const translateResponsesResultToAnthropic = (response) => {
 		usage
 	};
 };
-const mapOutputToAnthropicContent = (output) => {
+const mapOutputToAnthropicContent = (output, options) => {
 	const contentBlocks = [];
 	for (const item of output) switch (item.type) {
 		case "reasoning": {
@@ -4932,6 +5432,12 @@ const mapOutputToAnthropicContent = (output) => {
 			if (toolUseBlock) contentBlocks.push(toolUseBlock);
 			break;
 		}
+		case "tool_search_call": {
+			const toolUseBlock = createToolSearchUseContentBlock(item, options?.toolSearchName);
+			if (toolUseBlock) contentBlocks.push(toolUseBlock);
+			break;
+		}
+		case "tool_search_output": break;
 		case "message": {
 			const combinedText = combineMessageTextContent(item.content);
 			if (combinedText.length > 0) contentBlocks.push({
@@ -4993,15 +5499,29 @@ const extractReasoningText = (item) => {
 };
 const createToolUseContentBlock = (call) => {
 	const toolId = call.call_id;
-	if (!call.name || !toolId) return null;
-	const input = parseFunctionCallArguments(call.arguments);
+	const toolName = resolveToolUseName(call);
+	if (!toolName || !toolId) return null;
+	return {
+		type: "tool_use",
+		id: toolId,
+		name: toolName,
+		input: parseFunctionCallArguments(call.arguments)
+	};
+};
+const createToolSearchUseContentBlock = (call, toolSearchName = BRIDGE_TOOL_SEARCH_NAME) => {
+	const toolId = call.call_id;
+	if (!toolId) return null;
 	return {
 		type: "tool_use",
 		id: toolId,
-		name: call.name,
-		input
+		name: toolSearchName,
+		input: parseToolSearchArguments(call.arguments)
 	};
 };
+const resolveToolUseName = (call) => {
+	if (typeof call.namespace === "string" && call.namespace.length > 0) return call.namespace;
+	return call.name;
+};
 const createCompactionThinkingBlock = (item) => {
 	if (!item.id || !item.encrypted_content) return null;
 	return {
@@ -5027,6 +5547,9 @@ const parseFunctionCallArguments = (rawArguments) => {
 	}
 	return { raw_arguments: rawArguments };
 };
+const parseToolSearchArguments = (argumentsValue) => {
+	return formatToolSearchBridgeArguments(argumentsValue);
+};
 const fallbackContentBlocks = (outputText) => {
 	if (!outputText) return [];
 	return [{
@@ -5037,7 +5560,7 @@ const fallbackContentBlocks = (outputText) => {
 const mapResponsesStopReason = (response) => {
 	const { status, incomplete_details: incompleteDetails } = response;
 	if (status === "completed") {
-		if (response.output.some((item) => item.type === "function_call")) return "tool_use";
+		if (response.output.some((item) => item.type === "function_call" || item.type === "tool_search_call")) return "tool_use";
 		return "end_turn";
 	}
 	if (status === "incomplete") {
@@ -5971,14 +6494,15 @@ const updateWhitespaceRunState = (previousCount, chunk) => {
 		exceeded: false
 	};
 };
-const createResponsesStreamState = () => ({
+const createResponsesStreamState = (options) => ({
 	messageStartSent: false,
 	messageCompleted: false,
 	nextContentBlockIndex: 0,
 	blockIndexByKey: /* @__PURE__ */ new Map(),
 	openBlocks: /* @__PURE__ */ new Set(),
 	blockHasDelta: /* @__PURE__ */ new Set(),
-	functionCallStateByOutputIndex: /* @__PURE__ */ new Map()
+	functionCallStateByOutputIndex: /* @__PURE__ */ new Map(),
+	toolSearchName: options?.toolSearchName ?? "mcp__tool_search__search"
 });
 const translateResponsesStreamEvent = (rawEvent, state) => {
 	switch (rawEvent.type) {
@@ -6003,7 +6527,7 @@ const handleResponseCreated = (rawEvent, state) => {
 };
 const handleOutputItemAdded$1 = (rawEvent, state) => {
 	const events = new Array();
-	const functionCallDetails = extractFunctionCallDetails(rawEvent);
+	const functionCallDetails = extractFunctionCallDetails(rawEvent, state);
 	if (!functionCallDetails) return events;
 	const { outputIndex, toolCallId, name, initialArguments } = functionCallDetails;
 	const blockIndex = openFunctionCallBlock(state, {
@@ -6030,6 +6554,28 @@ const handleOutputItemDone$1 = (rawEvent, state) => {
 	const item = rawEvent.item;
 	const itemType = item.type;
 	const outputIndex = rawEvent.output_index;
+	if (itemType === "tool_search_call") {
+		const blockIndex = openFunctionCallBlock(state, {
+			outputIndex,
+			toolCallId: item.call_id,
+			name: state.toolSearchName,
+			events
+		});
+		const finalArguments = stringifyToolSearchArguments(item.arguments);
+		if (!state.blockHasDelta.has(blockIndex) && finalArguments) {
+			events.push({
+				type: "content_block_delta",
+				index: blockIndex,
+				delta: {
+					type: "input_json_delta",
+					partial_json: finalArguments
+				}
+			});
+			state.blockHasDelta.add(blockIndex);
+		}
+		state.functionCallStateByOutputIndex.delete(outputIndex);
+		return events;
+	}
 	if (itemType === "compaction") {
 		if (!item.id || !item.encrypted_content) return events;
 		const blockIndex = openThinkingBlockIfNeeded(state, outputIndex, events);
@@ -6365,24 +6911,47 @@ const openFunctionCallBlock = (state, params) => {
 	}
 	return blockIndex;
 };
-const extractFunctionCallDetails = (rawEvent) => {
+const extractFunctionCallDetails = (rawEvent, state) => {
 	const item = rawEvent.item;
-	if (item.type !== "function_call") return;
+	const itemType = item.type;
+	if (itemType === "tool_search_call") return {
+		outputIndex: rawEvent.output_index,
+		toolCallId: item.call_id,
+		name: state.toolSearchName,
+		initialArguments: ""
+	};
+	if (itemType !== "function_call") return;
 	return {
 		outputIndex: rawEvent.output_index,
 		toolCallId: item.call_id,
-		name: item.name,
+		name: resolveToolUseName(item),
 		initialArguments: item.arguments
 	};
 };
-//#endregion
-//#region src/routes/responses/utils.ts
+const stringifyToolSearchArguments = (argumentsValue) => {
+	try {
+		return JSON.stringify(formatToolSearchBridgeArguments(argumentsValue));
+	} catch {
+		return;
+	}
+};
+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 +6976,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 +7246,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 +7346,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();
@@ -6800,11 +7378,13 @@ async function handleCompletion(c) {
 	const originalRequestModel = anthropicPayload.model;
 	if (anthropicBeta && isWarmupProbeRequest(anthropicPayload)) anthropicPayload.model = getSmallModel();
 	if (compactType !== 0) logger$3.debug("Compact request type:", compactType);
+	const lastMessageCacheControl = getLastMessageContentCacheControl(anthropicPayload.messages.at(-1));
 	if (compactType === 1 && shouldCompactUseSmallModel()) anthropicPayload.model = getSmallModel();
 	if (compactType === 0) {
 		stripToolReferenceTurnBoundary(anthropicPayload);
 		mergeToolResultForClaude(anthropicPayload);
 	}
+	applyLastMessageCacheControl(anthropicPayload, lastMessageCacheControl);
 	const upstreamRequestId = generateRequestIdFromPayload(anthropicPayload, sessionId);
 	logger$3.debug("Generated request ID:", upstreamRequestId);
 	const clientModel = anthropicPayload.model;
@@ -7010,11 +7590,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 +7614,8 @@ const handleWithResponsesApi = async (params) => {
 			subagentMarker,
 			sessionId,
 			compactType,
-			requestId: instr.requestId
+			requestId: instr.requestId,
+			transport
 		}, ctx);
 		instr.confirmAffinity?.();
 		instr.confirmOwnership?.();
@@ -7840,6 +8425,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 +8444,8 @@ const handleResponses = async (c) => {
 		vision,
 		initiator,
 		premiumRemainingBefore,
-		premiumUnlimitedBefore
+		premiumUnlimitedBefore,
+		transport
 	});
 	return handleNonStreamingResponses({
 		c,
@@ -7871,7 +8458,8 @@ const handleResponses = async (c) => {
 		vision,
 		initiator,
 		premiumRemainingBefore,
-		premiumUnlimitedBefore
+		premiumUnlimitedBefore,
+		transport
 	});
 };
 async function observeRequestError(accountId, error, affinity) {
@@ -7979,7 +8567,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 +8575,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 +8764,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 +8775,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 +8927,4 @@ server.route("/:provider/v1/models", providerModelRoutes);
 //#endregion
 export { server };
 
-//# sourceMappingURL=server-BDCnb3Ao.js.map
+//# sourceMappingURL=server-DmDAepfa.js.map