@nick3/copilot-api 1.9.2 → 1.10.4

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

@@ -1,23 +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-Dvk6Ho0R.js";
-import { _ as DEFAULT_IDENTITY_ENTERPRISE_DOMAIN, 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-MllYSdRC.js";
-import { r as ensurePaths, t as PATHS } from "./paths-DGlr310R.js";
-import "./get-copilot-token-4mCKt94e.js";
-import { i as getRequestOutboundStore, r as getRedactedHeaderKeys } from "./request-outbound-qyTeXbzy.js";
-import { A as isMessageStartInputTokensFallbackEnabled, C as getModelAliasesInfo, D as getSmallModel, E as getReasoningEffortForModel, F as resolveModelAlias, I as shouldCompactUseSmallModel, M as isResponsesApiContextManagementModel, N as isResponsesApiWebSearchEnabled, O as isAccountAffinityEnabled, P as mergeConfigWithDefaults, S as getModelAliases, T as getProviderConfig, _ as getAnthropicApiKey, a as getClientIpInfo, b as getExtraPromptForModel, c as normalizeChatCompletionsUsage, d as toLocalDateString, f as copilotFetch, g as getAliasTargetSet, h as PROVIDER_TYPE_ANTHROPIC, i as extractResponsesUsageFromStreamEvent, j as isMessagesApiEnabled, k as isForceAgentEnabled, l as normalizeEmbeddingsUsage, m as isDevModeEnabled, n as applySharedSessionAffinityRetention, o as getRequestHistoryStore, p as flushPendingCapture, r as extractResponsesUsageFromResult, s as getStatsStore, t as accountsManager, u as normalizeMessagesUsage, v as getClaudeTokenMultiplier, w as getModelRefreshIntervalMs, x as getLogLevel, y as getConfig } from "./accounts-manager-BM66oT38.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-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 { randomUUID, timingSafeEqual } from "node:crypto";
+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 { fileURLToPath } from "node:url";
 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;
@@ -88,8 +87,8 @@ function timingSafeKeyCompare(a, b) {
 }
 function createAuthMiddleware(options = {}) {
 	const getApiKeys = options.getApiKeys ?? getConfiguredApiKeys;
-	const allowUnauthenticatedPaths = new Set((options.allowUnauthenticatedPaths ?? ["/"]).map((path$2) => normalizePathname(path$2)));
-	const allowUnauthenticatedPathPrefixes = (options.allowUnauthenticatedPathPrefixes ?? []).map((path$2) => normalizePathname(path$2));
+	const allowUnauthenticatedPaths = new Set((options.allowUnauthenticatedPaths ?? ["/"]).map((path) => normalizePathname(path)));
+	const allowUnauthenticatedPathPrefixes = (options.allowUnauthenticatedPathPrefixes ?? []).map((path) => normalizePathname(path));
 	const allowOptionsBypass = options.allowOptionsBypass ?? true;
 	return async (c, next) => {
 		if (allowOptionsBypass && c.req.method === "OPTIONS") return next();
@@ -103,7 +102,6 @@ function createAuthMiddleware(options = {}) {
 		return next();
 	};
 }
-
 //#endregion
 //#region src/lib/trace.ts
 const traceIdMiddleware = async (c, next) => {
@@ -120,7 +118,6 @@ const traceIdMiddleware = async (c, next) => {
 		await next();
 	});
 };
-
 //#endregion
 //#region src/routes/admin-api/auth-sessions.ts
 function buildOauthUrls(enterpriseDomain) {
@@ -277,7 +274,6 @@ var AuthSessionManager = class {
 	}
 };
 const authSessionManager = new AuthSessionManager();
-
 //#endregion
 //#region src/routes/admin-api/config-writer.ts
 async function writeConfigFile(config) {
@@ -298,7 +294,6 @@ async function writeConfigFile(config) {
 		throw error;
 	}
 }
-
 //#endregion
 //#region src/lib/models.ts
 const getAvailableModels = () => (accountsManager.getFirstAccountModels()?.data ?? []).filter((model) => model.model_picker_enabled || model.capabilities.type === "embeddings");
@@ -349,7 +344,6 @@ const _normalizeSdkModelId = (sdkModelId) => {
 		version: pattern5[1]
 	};
 };
-
 //#endregion
 //#region src/lib/copilot-rate-limit.ts
 const copilotRateLimitTypes = ["session", "weekly"];
@@ -357,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;
@@ -377,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;
@@ -386,23 +384,45 @@ 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) {
 	if (options.isCompact || options.isSubagent) return "agent";
 	return baseInitiator;
 }
-
 //#endregion
 //#region src/services/copilot/create-chat-completions.ts
 function isGpt5MiniFamily(modelId) {
@@ -425,7 +445,7 @@ const getChatInitiator = (messages) => {
 const createChatCompletions = async (payload, account, options) => {
 	const ctx = account ?? accountFromState();
 	if (!ctx.copilotToken) throw new Error("Copilot token not found");
-	const enableVision = payload.messages.some((x) => typeof x.content !== "string" && x.content?.some((x$1) => x$1.type === "image_url"));
+	const enableVision = payload.messages.some((x) => typeof x.content !== "string" && x.content?.some((x) => x.type === "image_url"));
 	const effectiveInitiator = resolveEffectiveInitiator(options?.initiator ?? getChatInitiator(payload.messages), {
 		isCompact: Boolean(options?.compactType),
 		isSubagent: Boolean(options?.subagentMarker)
@@ -444,7 +464,8 @@ const createChatCompletions = async (payload, account, options) => {
 		body: JSON.stringify(upstreamPayload)
 	}, {
 		requestId: options?.requestId,
-		callSite: "chat-completions"
+		callSite: "chat-completions",
+		fetchImpl: options?.fetchImpl
 	});
 	logCopilotRateLimits(response.headers);
 	if (!response.ok) {
@@ -454,7 +475,6 @@ const createChatCompletions = async (payload, account, options) => {
 	if (payload.stream) return events(response);
 	return await response.json();
 };
-
 //#endregion
 //#region src/lib/tokenizer.ts
 const ENCODING_MAP = {
@@ -485,7 +505,10 @@ const calculateToolCallsTokens = (toolCalls, encoder, constants) => {
 const calculateContentPartsTokens = (contentParts, encoder) => {
 	let tokens = 0;
 	for (const part of contentParts) if (part.type === "image_url") tokens += encoder.encode(part.image_url.url).length + 85;
-	else if (part.text) tokens += encoder.encode(part.text).length;
+	else if (part.type === "file") {
+		tokens += encoder.encode(part.file.file_data).length;
+		if (part.file.filename) tokens += encoder.encode(part.file.filename).length;
+	} else if (part.text) tokens += encoder.encode(part.text).length;
 	return tokens;
 };
 /**
@@ -669,29 +692,6 @@ const getTokenCount = async (payload, model) => {
 		output: outputTokens
 	};
 };
-
-//#endregion
-//#region src/lib/compact.ts
-const COMPACT_REQUEST = 1;
-const COMPACT_AUTO_CONTINUE = 2;
-const compactSystemPromptStart = "You are a helpful AI assistant tasked with summarizing conversations";
-const compactOpenCodeSystemPromptStart = "You are an anchored context summarization assistant for coding sessions.";
-const compactSystemPromptStarts = [compactSystemPromptStart, compactOpenCodeSystemPromptStart];
-const compactTextOnlyGuard = "CRITICAL: Respond with TEXT ONLY. Do NOT call any tools.";
-const compactSummaryPromptStart = "Your task is to create a detailed summary of the conversation so far";
-const compactAutoContinueClaudeCodePromptStart = "This session is being continued from a previous conversation that ran out of context. The summary below covers the earlier portion of the conversation.";
-const compactAutoContinueOpenCodePromptStart = "Continue if you have next steps, or stop and ask for clarification if you are unsure how to proceed.";
-const compactAutoContinueOpenCodePromptStart2 = "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 compactAutoContinuePromptStarts = [
-	compactAutoContinueClaudeCodePromptStart,
-	compactAutoContinueOpenCodePromptStart,
-	compactAutoContinueOpenCodePromptStart2
-];
-const compactMessageSections = ["Pending Tasks:", "Current Work:"];
-
-//#endregion
-//#region src/routes/messages/preprocess.ts
-const TOOL_REFERENCE_TURN_BOUNDARY = "Tool loaded.";
 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.";
@@ -704,7 +704,7 @@ const getCompactCandidateText = (message) => {
 const isCompactMessage = (lastMessage) => {
 	const text = getCompactCandidateText(lastMessage);
 	if (!text) return false;
-	return text.includes(compactTextOnlyGuard) && text.includes(compactSummaryPromptStart) && compactMessageSections.some((section) => text.includes(section));
+	return text.includes("CRITICAL: Respond with TEXT ONLY. Do NOT call any tools.") && text.includes("Your task is to create a detailed summary of the conversation so far") && compactMessageSections.some((section) => text.includes(section));
 };
 const isCompactAutoContinueMessage = (lastMessage) => {
 	const text = getCompactCandidateText(lastMessage);
@@ -712,12 +712,12 @@ const isCompactAutoContinueMessage = (lastMessage) => {
 };
 const getCompactType = (anthropicPayload) => {
 	const lastMessage = anthropicPayload.messages.at(-1);
-	if (lastMessage && isCompactMessage(lastMessage)) return COMPACT_REQUEST;
-	if (lastMessage && isCompactAutoContinueMessage(lastMessage)) return COMPACT_AUTO_CONTINUE;
+	if (lastMessage && isCompactMessage(lastMessage)) return 1;
+	if (lastMessage && isCompactAutoContinueMessage(lastMessage)) return 2;
 	const system = anthropicPayload.system;
-	if (typeof system === "string") return compactSystemPromptStarts.some((promptStart) => system.startsWith(promptStart)) ? COMPACT_REQUEST : 0;
+	if (typeof system === "string") return compactSystemPromptStarts.some((promptStart) => system.startsWith(promptStart)) ? 1 : 0;
 	if (!Array.isArray(system)) return 0;
-	if (system.some((msg) => typeof msg.text === "string" && compactSystemPromptStarts.some((promptStart) => msg.text.startsWith(promptStart)))) return COMPACT_REQUEST;
+	if (system.some((msg) => typeof msg.text === "string" && compactSystemPromptStarts.some((promptStart) => msg.text.startsWith(promptStart)))) return 1;
 	return 0;
 };
 const mergeContentWithText = (tr, textBlock) => {
@@ -778,9 +778,9 @@ const assignAttachmentsToToolResults = (target, attachments, options) => {
 	if (attachments.length === 0) return;
 	if (toolResultIndices.length > 0 && toolResultIndices.length === attachments.length) {
 		for (const [index, toolResultIndex] of toolResultIndices.entries()) {
-			const currentAttachments$1 = target.get(toolResultIndex);
-			if (currentAttachments$1) {
-				currentAttachments$1.push(attachments[index]);
+			const currentAttachments = target.get(toolResultIndex);
+			if (currentAttachments) {
+				currentAttachments.push(attachments[index]);
 				continue;
 			}
 			target.set(toolResultIndex, [attachments[index]]);
@@ -872,7 +872,7 @@ const stripToolReferenceTurnBoundary = (anthropicPayload) => {
 	for (const msg of anthropicPayload.messages) {
 		if (msg.role !== "user" || !Array.isArray(msg.content)) continue;
 		if (!msg.content.some((block) => block.type === "tool_result" && hasToolRef(block))) continue;
-		msg.content = msg.content.filter((block) => block.type !== "text" || block.text.trim() !== TOOL_REFERENCE_TURN_BOUNDARY);
+		msg.content = msg.content.filter((block) => block.type !== "text" || block.text.trim() !== "Tool loaded.");
 	}
 };
 const mergeToolResultForClaude = (anthropicPayload, options) => {
@@ -947,7 +947,6 @@ const prepareMessagesApiPayload = (payload, selectedModel) => {
 		payload.output_config = { effort };
 	}
 };
-
 //#endregion
 //#region src/routes/messages/utils.ts
 function mapOpenAIStopReasonToAnthropic(finishReason) {
@@ -959,14 +958,17 @@ function mapOpenAIStopReasonToAnthropic(finishReason) {
 		content_filter: "end_turn"
 	}[finishReason];
 }
-const estimateInputTokens = async (payload, selectedModel, logger$7) => {
+const estimateInputTokens = async (payload, selectedModel, logger) => {
 	try {
 		return (await getTokenCount(payload, selectedModel)).input;
 	} catch (error) {
-		logger$7.warn("Failed to estimate input tokens for message_start", error);
+		logger.warn("Failed to estimate input tokens for message_start", error);
 		return;
 	}
 };
+function stringifyOwnerKeys$1(keys) {
+	return keys && keys.length > 0 ? JSON.stringify(keys) : void 0;
+}
 const isWarmupProbeRequest = (payload) => {
 	const lastMsg = payload.messages.at(-1);
 	if (!lastMsg || lastMsg.role !== "user" || !Array.isArray(lastMsg.content)) return false;
@@ -983,7 +985,7 @@ const isWarmupProbeRequest = (payload) => {
 	return false;
 };
 const handleSelectionFailure = (context) => {
-	const { c, store, requestId, startedAtMs, method, path: path$2, streamRequested, clientModel, clientIp, clientIpSource, userAgent, userId, safetyIdentifier, promptCacheKey, initiator, isSubagent, affinityKeyUsed, affinityKeySource, selectionReason, selection } = context;
+	const { c, store, requestId, startedAtMs, method, path, streamRequested, clientModel, clientIp, clientIpSource, userAgent, userId, safetyIdentifier, promptCacheKey, initiator, isSubagent, affinityKeyUsed, affinityKeySource, selectionReason, responsesItemOwnerLookupKeys, selection } = context;
 	const finishedAtMs = Date.now();
 	store.insert({
 		requestId,
@@ -991,7 +993,7 @@ const handleSelectionFailure = (context) => {
 		finishedAtMs,
 		durationMs: finishedAtMs - startedAtMs,
 		method,
-		path: path$2,
+		path,
 		stream: streamRequested,
 		clientModel,
 		clientIp,
@@ -1004,6 +1006,7 @@ const handleSelectionFailure = (context) => {
 		isSubagent,
 		affinityKeyUsed,
 		affinityKeySource,
+		responsesItemOwnerLookupKeysJson: stringifyOwnerKeys$1(responsesItemOwnerLookupKeys),
 		httpStatus: selection.reason === "MODEL_NOT_SUPPORTED" ? 400 : 429,
 		selectionReason: selectionReason ?? selection.selectionReason,
 		selectionFailureReason: selection.reason
@@ -1027,16 +1030,19 @@ const maybeBlockOriginalModelName = (context) => {
 		}
 	});
 };
-
 //#endregion
 //#region src/routes/messages/non-stream-translation.ts
-const THINKING_TEXT = "Thinking...";
-function translateToOpenAI(payload) {
+const THINKING_TEXT$1 = "Thinking...";
+const COPILOT_TOOL_CONTENT_SUPPORT_TYPE = ["array", "image"];
+function translateToOpenAI(payload, options = {}) {
 	const modelId = payload.model;
 	const thinkingBudget = getThinkingBudget(payload, getAvailableModels().find((m) => m.id === modelId));
 	return {
 		model: modelId,
-		messages: translateAnthropicMessagesToOpenAI(payload, modelId, thinkingBudget),
+		messages: translateAnthropicMessagesToOpenAI(payload, modelId, {
+			supportPdf: options.supportPdf ?? false,
+			toolContentSupportType: options.toolContentSupportType ?? COPILOT_TOOL_CONTENT_SUPPORT_TYPE
+		}),
 		max_tokens: payload.max_tokens,
 		stop: payload.stop_sequences,
 		stream: payload.stream,
@@ -1059,9 +1065,9 @@ function getThinkingBudget(payload, model) {
 		}
 	}
 }
-function translateAnthropicMessagesToOpenAI(payload, modelId, _thinkingBudget) {
+function translateAnthropicMessagesToOpenAI(payload, modelId, capabilities) {
 	const systemMessages = handleSystemPrompt(payload.system);
-	const otherMessages = payload.messages.flatMap((message) => message.role === "user" ? handleUserMessage(message) : handleAssistantMessage(message, modelId));
+	const otherMessages = payload.messages.flatMap((message) => message.role === "user" ? handleUserMessage(message, capabilities) : handleAssistantMessage(message, modelId, capabilities));
 	return [...systemMessages, ...otherMessages];
 }
 function handleSystemPrompt(system) {
@@ -1077,19 +1083,21 @@ function handleSystemPrompt(system) {
 		}).join("\n\n")
 	}];
 }
-function handleUserMessage(message) {
+function handleUserMessage(message, capabilities) {
 	const newMessages = [];
 	if (Array.isArray(message.content)) {
 		const toolResultBlocks = message.content.filter((block) => block.type === "tool_result");
 		const otherBlocks = message.content.filter((block) => block.type !== "tool_result");
-		for (const block of toolResultBlocks) newMessages.push({
-			role: "tool",
-			tool_call_id: block.tool_use_id,
-			content: mapContent(block.content)
-		});
+		const movedToolResultUserMessages = [];
+		for (const block of toolResultBlocks) {
+			const result = handleToolResultBlock(block, capabilities);
+			newMessages.push(result.toolMessage);
+			if (result.movedUserMessage) movedToolResultUserMessages.push(result.movedUserMessage);
+		}
+		newMessages.push(...movedToolResultUserMessages);
 		if (otherBlocks.length > 0) newMessages.push({
 			role: "user",
-			content: mapContent(otherBlocks)
+			content: mapContent(otherBlocks, { supportPdf: capabilities.supportPdf })
 		});
 	} else newMessages.push({
 		role: "user",
@@ -1097,20 +1105,74 @@ function handleUserMessage(message) {
 	});
 	return newMessages;
 }
-function handleAssistantMessage(message, modelId) {
+function handleToolResultBlock(block, capabilities) {
+	if (typeof block.content === "string") return { toolMessage: createToolMessage(block.tool_use_id, block.content) };
+	if (!Array.isArray(block.content)) return { toolMessage: createToolMessage(block.tool_use_id, "") };
+	const support = getToolContentSupport(capabilities);
+	const hasImage = block.content.some((block) => block.type === "image");
+	const hasDocument = block.content.some((block) => block.type === "document");
+	const content = mapContent(block.content, { supportPdf: capabilities.supportPdf });
+	const hasPdfFile = hasDocument && capabilities.supportPdf;
+	const shouldMoveImageToUserMessage = hasImage && !support.image;
+	const shouldMovePdfToUserMessage = hasPdfFile && !support.pdf;
+	if (shouldMoveImageToUserMessage || shouldMovePdfToUserMessage) return {
+		movedUserMessage: createToolResultUserMessage(block, capabilities.supportPdf),
+		toolMessage: createToolMessage(block.tool_use_id, getTextToolContent(content) || "Rich tool result content was moved to a user message because this upstream does not support it in tool messages.")
+	};
+	const hasRichContent = hasImage || hasPdfFile;
+	if (support.array || hasRichContent) return { toolMessage: createToolMessage(block.tool_use_id, content) };
+	return { toolMessage: createToolMessage(block.tool_use_id, getTextToolContent(content)) };
+}
+function getTextToolContent(content) {
+	if (!Array.isArray(content)) return content ?? "";
+	return content.flatMap((part) => part.type === "text" && part.text.length > 0 ? [part.text] : []).join("\n");
+}
+function getToolContentSupport(capabilities) {
+	return {
+		array: capabilities.toolContentSupportType.includes("array"),
+		image: capabilities.toolContentSupportType.includes("image"),
+		pdf: capabilities.supportPdf && capabilities.toolContentSupportType.includes("pdf")
+	};
+}
+function createToolMessage(toolCallId, content) {
+	return {
+		role: "tool",
+		tool_call_id: toolCallId,
+		content
+	};
+}
+function createToolResultUserMessage(block, supportPdf) {
+	const prefix = {
+		type: "text",
+		text: `Tool result for ${block.tool_use_id}:`
+	};
+	const content = mapContent(block.content, { supportPdf });
+	if (Array.isArray(content)) return {
+		role: "user",
+		content: [prefix, ...content]
+	};
+	return {
+		role: "user",
+		content: [prefix, {
+			type: "text",
+			text: content ?? ""
+		}]
+	};
+}
+function handleAssistantMessage(message, modelId, capabilities) {
 	if (!Array.isArray(message.content)) return [{
 		role: "assistant",
 		content: mapContent(message.content)
 	}];
 	const toolUseBlocks = message.content.filter((block) => block.type === "tool_use");
 	let thinkingBlocks = message.content.filter((block) => block.type === "thinking");
-	if (modelId.startsWith("claude")) thinkingBlocks = thinkingBlocks.filter((b) => b.thinking && b.thinking !== THINKING_TEXT && b.signature && !b.signature.includes("@"));
-	const thinkingContents = thinkingBlocks.filter((b) => b.thinking && b.thinking !== THINKING_TEXT).map((b) => b.thinking);
+	if (modelId.startsWith("claude")) thinkingBlocks = thinkingBlocks.filter((b) => b.thinking && b.thinking !== "Thinking..." && b.signature && !b.signature.includes("@"));
+	const thinkingContents = thinkingBlocks.filter((b) => b.thinking && b.thinking !== "Thinking...").map((b) => b.thinking);
 	const allThinkingContent = thinkingContents.length > 0 ? thinkingContents.join("\n\n") : void 0;
 	const signature = thinkingBlocks.find((b) => b.signature)?.signature;
 	return toolUseBlocks.length > 0 ? [{
 		role: "assistant",
-		content: mapContent(message.content),
+		content: mapContent(message.content, { supportPdf: capabilities.supportPdf }),
 		reasoning_text: allThinkingContent,
 		reasoning_opaque: signature,
 		tool_calls: toolUseBlocks.map((toolUse) => ({
@@ -1123,12 +1185,12 @@ function handleAssistantMessage(message, modelId) {
 		}))
 	}] : [{
 		role: "assistant",
-		content: mapContent(message.content),
+		content: mapContent(message.content, { supportPdf: capabilities.supportPdf }),
 		reasoning_text: allThinkingContent,
 		reasoning_opaque: signature
 	}];
 }
-function mapContent(content) {
+function mapContent(content, options = {}) {
 	if (typeof content === "string") return content;
 	if (!Array.isArray(content)) return null;
 	const contentParts = [];
@@ -1146,7 +1208,7 @@ function mapContent(content) {
 			});
 			break;
 		case "document":
-			contentParts.push(createDocumentTextPart());
+			contentParts.push(options.supportPdf ? createDocumentFilePart(block) : createDocumentTextPart());
 			break;
 		case "tool_reference":
 			contentParts.push({
@@ -1155,12 +1217,22 @@ function mapContent(content) {
 			});
 			break;
 	}
+	if (contentParts.length === 0) return "";
 	return contentParts;
 }
 function createDocumentTextPart() {
 	return {
 		type: "text",
-		text: "A PDF document was attached, but this api cannot send PDF inputs directly. Analyze using other tools."
+		text: "PDF/document content is not supported by this Chat Completions upstream. Use the available text extracted from the document."
+	};
+}
+function createDocumentFilePart(block) {
+	return {
+		type: "file",
+		file: {
+			file_data: `data:${block.source.media_type};base64,${block.source.data}`,
+			filename: block.title ?? "document.pdf"
+		}
 	};
 }
 function translateAnthropicToolsToOpenAI(anthropicTools) {
@@ -1205,7 +1277,7 @@ function translateToAnthropic(response) {
 	let stopReason = response.choices[0]?.finish_reason ?? null;
 	for (const choice of response.choices) {
 		const textBlocks = getAnthropicTextBlocks(choice.message.content);
-		const thinkBlocks = getAnthropicThinkBlocks(choice.message.reasoning_text, choice.message.reasoning_opaque);
+		const thinkBlocks = getAnthropicThinkBlocks(getOpenAIReasoningText(choice.message), choice.message.reasoning_opaque);
 		const toolUseBlocks = getAnthropicToolUseBlocks(choice.message.tool_calls);
 		assistantContentBlocks.push(...thinkBlocks, ...textBlocks, ...toolUseBlocks);
 		if (choice.finish_reason === "tool_calls" || stopReason === "stop") stopReason = choice.finish_reason;
@@ -1218,12 +1290,24 @@ function translateToAnthropic(response) {
 		content: assistantContentBlocks,
 		stop_reason: mapOpenAIStopReasonToAnthropic(stopReason),
 		stop_sequence: null,
-		usage: {
-			input_tokens: (response.usage?.prompt_tokens ?? 0) - (response.usage?.prompt_tokens_details?.cached_tokens ?? 0),
-			output_tokens: response.usage?.completion_tokens ?? 0,
-			...response.usage?.prompt_tokens_details?.cached_tokens !== void 0 && { cache_read_input_tokens: response.usage.prompt_tokens_details.cached_tokens }
-		}
+		usage: mapOpenAIChatCompletionUsage(response)
+	};
+}
+function mapOpenAIChatCompletionUsage(response) {
+	const promptDetails = response.usage?.prompt_tokens_details;
+	const promptTokens = response.usage?.prompt_tokens ?? 0;
+	const cachedTokens = promptDetails?.cached_tokens ?? 0;
+	const cacheCreationTokens = promptDetails?.cache_creation_input_tokens ?? 0;
+	const usage = {
+		input_tokens: Math.max(0, promptTokens - cachedTokens - cacheCreationTokens),
+		output_tokens: response.usage?.completion_tokens ?? 0
 	};
+	if (promptDetails?.cache_creation_input_tokens !== void 0) usage.cache_creation_input_tokens = cacheCreationTokens;
+	if (promptDetails?.cached_tokens !== void 0) usage.cache_read_input_tokens = cachedTokens;
+	return usage;
+}
+function getOpenAIReasoningText(message) {
+	return message.reasoning_text ?? message.reasoning_content;
 }
 function getAnthropicTextBlocks(messageContent) {
 	if (typeof messageContent === "string" && messageContent.length > 0) return [{
@@ -1244,7 +1328,7 @@ function getAnthropicThinkBlocks(reasoningText, reasoningOpaque) {
 	}];
 	if (reasoningOpaque && reasoningOpaque.length > 0) return [{
 		type: "thinking",
-		thinking: THINKING_TEXT,
+		thinking: THINKING_TEXT$1,
 		signature: reasoningOpaque
 	}];
 	return [];
@@ -1258,7 +1342,6 @@ function getAnthropicToolUseBlocks(toolCalls) {
 		input: JSON.parse(toolCall.function.arguments)
 	}));
 }
-
 //#endregion
 //#region src/routes/admin-api/replay-translation.ts
 function translateForReplay(input) {
@@ -1276,7 +1359,6 @@ function translateForReplay(input) {
 	if (upstreamEndpoint.includes("/responses")) return rawText;
 	return null;
 }
-
 //#endregion
 //#region src/routes/admin-api/replay.ts
 const replayRoutes = new Hono();
@@ -1596,7 +1678,6 @@ function requireDevMode(c) {
 	} }, 403);
 	return null;
 }
-
 //#endregion
 //#region src/routes/admin-api/route.ts
 const ADMIN_TOKEN = process.env.ADMIN_TOKEN?.trim() || void 0;
@@ -1675,8 +1756,10 @@ const CONFIG_KEYS = new Set([
 	"modelRefreshIntervalHours",
 	"sessionAffinityRetentionDays",
 	"useMessagesApi",
+	"useResponsesApiWebSocket",
 	"useResponsesApiWebSearch",
-	"devMode"
+	"devMode",
+	"quotaRefresh"
 ]);
 const REASONING_EFFORTS = new Set([
 	"none",
@@ -1837,7 +1920,7 @@ function applyProviderType(provider, value, field) {
 	const parsed = parseOptionalString(value.type, `${field}.type`);
 	if ("error" in parsed) return parsed.error;
 	if ("value" in parsed) {
-		if (parsed.value !== PROVIDER_TYPE_ANTHROPIC) return `${field}.type must be "${PROVIDER_TYPE_ANTHROPIC}"`;
+		if (parsed.value !== "anthropic") return `${field}.type must be "${PROVIDER_TYPE_ANTHROPIC}"`;
 		provider.type = PROVIDER_TYPE_ANTHROPIC;
 	}
 }
@@ -2103,6 +2186,48 @@ function applyDevModeConfig(next, value) {
 	}
 	next.devMode = parsed.value;
 }
+const QUOTA_REFRESH_KEYS = new Set([
+	"enabled",
+	"intervalMinutes",
+	"startupDelaySeconds",
+	"staggerMinSeconds",
+	"staggerMaxSeconds"
+]);
+function parseQuotaRefreshConfig(value) {
+	if (value === null || value === void 0) return { clear: true };
+	if (!isPlainObject(value)) return { error: "quotaRefresh must be an object" };
+	for (const key of Object.keys(value)) if (!QUOTA_REFRESH_KEYS.has(key)) return { error: `quotaRefresh.${key} is not supported` };
+	const out = {};
+	if (Object.hasOwn(value, "enabled")) {
+		const parsed = parseOptionalBoolean(value.enabled, "quotaRefresh.enabled");
+		if ("error" in parsed) return parsed;
+		if ("value" in parsed) out.enabled = parsed.value;
+	}
+	for (const key of [
+		"intervalMinutes",
+		"startupDelaySeconds",
+		"staggerMinSeconds",
+		"staggerMaxSeconds"
+	]) {
+		if (!Object.hasOwn(value, key)) continue;
+		const parsed = parseOptionalNonNegativeNumber(value[key], `quotaRefresh.${key}`);
+		if ("error" in parsed) return parsed;
+		if ("value" in parsed) out[key] = parsed.value;
+	}
+	return { value: out };
+}
+function applyQuotaRefreshConfig(next, value) {
+	const parsed = parseQuotaRefreshConfig(value);
+	if ("error" in parsed) return parsed.error;
+	if ("clear" in parsed) {
+		delete next.quotaRefresh;
+		return;
+	}
+	next.quotaRefresh = next.quotaRefresh === void 0 ? parsed.value : {
+		...next.quotaRefresh,
+		...parsed.value
+	};
+}
 const CONFIG_PATCH_HANDLERS = {
 	auth: applyAuthConfig,
 	extraPrompts: applyExtraPrompts,
@@ -2123,8 +2248,10 @@ 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
+	devMode: applyDevModeConfig,
+	quotaRefresh: applyQuotaRefreshConfig
 };
 function applyConfigPatch(base, input) {
 	const next = { ...base };
@@ -2190,6 +2317,7 @@ adminApiRoutes.post("/config", async (c) => {
 		const merged = mergeConfigWithDefaults();
 		accountsManager.setAccountAffinityEnabled(isAccountAffinityEnabled());
 		accountsManager.setModelsRefreshIntervalMs(getModelRefreshIntervalMs());
+		updateQuotaRefreshSchedulerFromConfig();
 		applySharedSessionAffinityRetention();
 		return c.json({
 			...merged,
@@ -2510,7 +2638,7 @@ adminApiRoutes.post("/accounts/:id/reauth", async (c) => {
 		const { oauthApp } = getCurrentIdentityEnvironment();
 		const resolvedEnterpriseDomain = (await getAccountClientIdentityByLoginAndApp(accountId, oauthApp))?.enterpriseDomain;
 		let enterpriseDomain;
-		if (resolvedEnterpriseDomain && resolvedEnterpriseDomain !== DEFAULT_IDENTITY_ENTERPRISE_DOMAIN) enterpriseDomain = resolvedEnterpriseDomain;
+		if (resolvedEnterpriseDomain && resolvedEnterpriseDomain !== "public") enterpriseDomain = resolvedEnterpriseDomain;
 		const result = await authSessionManager.startAuth({
 			accountType: account.accountType,
 			enterpriseDomain,
@@ -2569,14 +2697,14 @@ adminApiRoutes.get("/stats/premium-daily", (c) => {
 			message: "Hourly granularity is only supported for ranges up to 35 days.",
 			type: "bad_request"
 		});
-		const result$1 = statsStore.getHourlyPremiumStats({
+		const result = statsStore.getHourlyPremiumStats({
 			fromMs,
 			toMs,
 			accountId
 		});
 		return c.json({
-			daily: result$1.daily,
-			by_account: result$1.byAccount,
+			daily: result.daily,
+			by_account: result.byAccount,
 			range: {
 				from: resolvedFrom,
 				to: resolvedTo,
@@ -2600,7 +2728,6 @@ adminApiRoutes.get("/stats/premium-daily", (c) => {
 	});
 });
 adminApiRoutes.route("/", replayRoutes);
-
 //#endregion
 //#region src/routes/admin/route.ts
 function resolveAdminDistDir() {
@@ -3239,13 +3366,11 @@ adminRoutes.get("*", async (c) => {
 		return c.html(html);
 	}
 });
-
 //#endregion
 //#region src/lib/approval.ts
 const awaitApproval = async () => {
 	if (!await consola.prompt(`Accept incoming request?`, { type: "confirm" })) throw new HTTPError("Request rejected", Response.json({ message: "Request rejected" }, { status: 403 }));
 };
-
 //#endregion
 //#region src/lib/handler-utils.ts
 function truncate(value, max = 2e3) {
@@ -3354,7 +3479,57 @@ function getUserVisibleErrorMessage(details) {
 function shouldMarkAccountFailed(details) {
 	return details.unauthorized && !details.ownershipMismatch && details.upstreamErrorMessageReadFailed !== true;
 }
-
+//#endregion
+//#region src/lib/process-cleanup.ts
+const cleanupHandlers = /* @__PURE__ */ new Set();
+let cleanupPromise = null;
+let cleanupState = "idle";
+let runtimeInitialized$1 = false;
+function initializeProcessCleanupRuntime() {
+	if (runtimeInitialized$1) return;
+	runtimeInitialized$1 = true;
+	process.once("beforeExit", () => {
+		runProcessCleanups();
+	});
+	process.once("exit", runProcessCleanupsSync);
+	process.once("SIGINT", () => {
+		shutdownProcess(0);
+	});
+	process.once("SIGTERM", () => {
+		shutdownProcess(0);
+	});
+}
+function runProcessCleanupsSync() {
+	if (cleanupState !== "idle") return;
+	cleanupState = "done";
+	for (const handler of Array.from(cleanupHandlers)) try {
+		handler();
+	} catch {}
+}
+async function runProcessCleanups() {
+	if (cleanupPromise) return cleanupPromise;
+	if (cleanupState === "done") return;
+	cleanupState = "running";
+	cleanupPromise = (async () => {
+		for (const handler of Array.from(cleanupHandlers)) await handler();
+		cleanupState = "done";
+	})();
+	return cleanupPromise;
+}
+async function shutdownProcess(exitCode) {
+	try {
+		await runProcessCleanups();
+	} finally {
+		process.exit(exitCode);
+	}
+}
+function registerProcessCleanup(handler) {
+	initializeProcessCleanupRuntime();
+	cleanupHandlers.add(handler);
+	return () => {
+		cleanupHandlers.delete(handler);
+	};
+}
 //#endregion
 //#region src/lib/logger.ts
 const LOG_RETENTION_MS = 10080 * 60 * 1e3;
@@ -3374,9 +3549,6 @@ const logBuffers = /* @__PURE__ */ new Map();
 let runtimeInitialized = false;
 let flushInterval;
 let cleanupInterval;
-let exitHandler;
-let sigintHandler;
-let sigtermHandler;
 const ensureLogDirectory = () => {
 	if (!fs$1.existsSync(logDir)) fs$1.mkdirSync(logDir, { recursive: true });
 };
@@ -3454,18 +3626,7 @@ const initializeLoggerRuntime = () => {
 	maybeUnref(flushInterval);
 	cleanupInterval = setInterval(cleanupOldLogs, CLEANUP_INTERVAL_MS);
 	maybeUnref(cleanupInterval);
-	exitHandler = cleanup;
-	sigintHandler = () => {
-		cleanup();
-		process.exit(0);
-	};
-	sigtermHandler = () => {
-		cleanup();
-		process.exit(0);
-	};
-	process.once("exit", exitHandler);
-	process.once("SIGINT", sigintHandler);
-	process.once("SIGTERM", sigtermHandler);
+	registerProcessCleanup(cleanup);
 };
 const getLogStream = (filePath) => {
 	initializeLoggerRuntime();
@@ -3502,15 +3663,15 @@ const shouldWriteFileLog = (type, logLevel = resolveLogLevel()) => {
 };
 const resolveLogLevel = () => testLogLevelOverride ?? getLogLevel();
 const isDebugFileLoggingEnabled = () => resolveLogLevel() === "debug";
-const debugLazy = (logger$7, factory) => {
+const debugLazy = (logger, factory) => {
 	if (!isDebugFileLoggingEnabled()) return;
-	logger$7.debug(...factory());
+	logger.debug(...factory());
 };
-const debugJson = (logger$7, label, value) => {
-	debugLazy(logger$7, () => [label, JSON.stringify(value)]);
+const debugJson = (logger, label, value) => {
+	debugLazy(logger, () => [label, JSON.stringify(value)]);
 };
-const debugJsonTail = (logger$7, label, { value, tailLength = 400 }) => {
-	debugLazy(logger$7, () => [label, JSON.stringify(value).slice(-tailLength)]);
+const debugJsonTail = (logger, label, { value, tailLength = 400 }) => {
+	debugLazy(logger, () => [label, JSON.stringify(value).slice(-tailLength)]);
 };
 const getConsolaLevel = () => {
 	const logLevel = resolveLogLevel();
@@ -3543,33 +3704,31 @@ const createHandlerLogger = (name) => {
 	} });
 	return instance;
 };
-
 //#endregion
 //#region src/lib/rate-limit.ts
-async function checkRateLimit(state$1) {
-	if (state$1.rateLimitSeconds === void 0) return;
+async function checkRateLimit(state) {
+	if (state.rateLimitSeconds === void 0) return;
 	const now = Date.now();
-	if (!state$1.lastRequestTimestamp) {
-		state$1.lastRequestTimestamp = now;
+	if (!state.lastRequestTimestamp) {
+		state.lastRequestTimestamp = now;
 		return;
 	}
-	const elapsedSeconds = (now - state$1.lastRequestTimestamp) / 1e3;
-	if (elapsedSeconds > state$1.rateLimitSeconds) {
-		state$1.lastRequestTimestamp = now;
+	const elapsedSeconds = (now - state.lastRequestTimestamp) / 1e3;
+	if (elapsedSeconds > state.rateLimitSeconds) {
+		state.lastRequestTimestamp = now;
 		return;
 	}
-	const waitTimeSeconds = Math.ceil(state$1.rateLimitSeconds - elapsedSeconds);
-	if (!state$1.rateLimitWait) {
+	const waitTimeSeconds = Math.ceil(state.rateLimitSeconds - elapsedSeconds);
+	if (!state.rateLimitWait) {
 		consola.warn(`Rate limit exceeded. Need to wait ${waitTimeSeconds} more seconds.`);
 		throw new HTTPError("Rate limit exceeded", Response.json({ message: "Rate limit exceeded" }, { status: 429 }));
 	}
 	const waitTimeMs = waitTimeSeconds * 1e3;
 	consola.warn(`Rate limit reached. Waiting ${waitTimeSeconds} seconds before proceeding...`);
 	await sleep(waitTimeMs);
-	state$1.lastRequestTimestamp = now;
+	state.lastRequestTimestamp = now;
 	consola.info("Rate limit wait completed, proceeding with request");
 }
-
 //#endregion
 //#region src/routes/chat-completions/support.ts
 const CHAT_COMPLETIONS_ENDPOINT$1 = "/chat/completions";
@@ -3579,13 +3738,13 @@ function buildRequestContext$1(c) {
 	const requestId = randomUUID();
 	const startedAtMs = Date.now();
 	const method = c.req.raw.method;
-	const path$2 = new URL(c.req.url, "http://local").pathname;
+	const path = new URL(c.req.url, "http://local").pathname;
 	const { ip: clientIp, source: clientIpSource } = getClientIpInfo(c);
 	return {
 		requestId,
 		startedAtMs,
 		method,
-		path: path$2,
+		path,
 		clientIp,
 		clientIpSource,
 		userAgent: c.req.header("user-agent") ?? void 0
@@ -3678,7 +3837,6 @@ function selectionFailureResponse$2(c, params) {
 		type: "rate_limit_error"
 	} }, 429);
 }
-
 //#endregion
 //#region src/routes/chat-completions/handler.ts
 const logger$6 = createHandlerLogger("chat-completions-handler");
@@ -3746,7 +3904,7 @@ async function handleCompletion$1(c) {
 	request.selectionReason = selection.selectionReason;
 	const premiumRemainingBefore = account.premiumRemaining;
 	const premiumUnlimitedBefore = account.unlimited;
-	if (selectedModel.id === GPT_5_4_MODEL_ID) {
+	if (selectedModel.id === "gpt-5.4") {
 		await accountsManager.finalizeQuota(account, reservation);
 		recordUnsupportedChatCompletionsModel(store, {
 			request,
@@ -4136,7 +4294,6 @@ async function handleNonStreamingRequest(params) {
 	}
 }
 const isNonStreaming$1 = (response) => Object.hasOwn(response, "choices");
-
 //#endregion
 //#region src/routes/chat-completions/route.ts
 const completionRoutes = new Hono();
@@ -4147,7 +4304,6 @@ completionRoutes.post("/", async (c) => {
 		return await forwardError(c, error);
 	}
 });
-
 //#endregion
 //#region src/services/copilot/create-embeddings.ts
 const createEmbeddings = async (payload, account, options) => {
@@ -4167,7 +4323,6 @@ const createEmbeddings = async (payload, account, options) => {
 	if (!response.ok) throw new HTTPError("Failed to create embeddings", response);
 	return await response.json();
 };
-
 //#endregion
 //#region src/routes/embeddings/route.ts
 const embeddingRoutes = new Hono();
@@ -4178,13 +4333,13 @@ embeddingRoutes.post("/", async (c) => {
 		const requestId = randomUUID();
 		const startedAtMs = Date.now();
 		const method = c.req.raw.method;
-		const path$2 = new URL(c.req.url, "http://local").pathname;
+		const path = new URL(c.req.url, "http://local").pathname;
 		const { ip: clientIp, source: clientIpSource } = getClientIpInfo(c);
 		const ctx = {
 			requestId,
 			startedAtMs,
 			method,
-			path: path$2,
+			path,
 			clientIp,
 			clientIpSource,
 			userAgent: c.req.header("user-agent") ?? void 0
@@ -4318,9 +4473,107 @@ async function runEmbeddingsWithAccount({ c, store, ctx, payload, clientModel, s
 		});
 	}
 }
-
+//#endregion
+//#region src/lib/provider-model.ts
+const parseProviderModelAlias = (model) => {
+	const separatorIndex = model.indexOf("/");
+	if (separatorIndex <= 0 || separatorIndex === model.length - 1) return null;
+	const provider = model.slice(0, separatorIndex).trim();
+	const providerModel = model.slice(separatorIndex + 1).trim();
+	if (!provider || !providerModel) return null;
+	return {
+		model: providerModel,
+		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",
+		limits: {},
+		object: "model_capabilities",
+		supports: {},
+		tokenizer: "o200k_base",
+		type: "chat"
+	},
+	id: modelId,
+	model_picker_enabled: false,
+	name: modelId,
+	object: "model",
+	preview: false,
+	vendor: "provider",
+	version: "unknown"
+});
+//#endregion
+//#region src/routes/provider/messages/count-tokens-handler.ts
+const logger$5 = createHandlerLogger("provider-count-tokens-handler");
+const resolveProviderConfig$2 = (c, provider) => {
+	return (c.get("providerConfigResolver") ?? getProviderConfig)(provider);
+};
+async function handleProviderCountTokens(c) {
+	const provider = c.req.param("provider");
+	return await handleProviderCountTokensForProvider(c, {
+		payload: await c.req.json(),
+		provider
+	});
+}
+async function handleProviderCountTokensForProvider(c, options) {
+	const { payload: anthropicPayload, provider } = options;
+	const providerConfig = resolveProviderConfig$2(c, provider);
+	if (!providerConfig) return c.json({ error: {
+		message: `Provider '${provider}' not found or disabled`,
+		type: "invalid_request_error"
+	} }, 404);
+	if (typeof anthropicPayload.model !== "string" || !Array.isArray(anthropicPayload.messages)) return c.json({ error: {
+		message: "Invalid Anthropic messages count_tokens payload",
+		type: "invalid_request_error"
+	} }, 400);
+	const modelId = anthropicPayload.model.trim();
+	const modelConfig = providerConfig.models?.[modelId];
+	const translationOptions = providerConfig.type === "openai-compatible" ? {
+		supportPdf: modelConfig?.supportPdf,
+		toolContentSupportType: modelConfig?.toolContentSupportType ?? []
+	} : void 0;
+	try {
+		const tokenCount = await getTokenCount(translateToOpenAI(anthropicPayload, translationOptions), findEndpointModel(modelId) ?? createFallbackModel(modelId));
+		const finalTokenCount = tokenCount.input + tokenCount.output;
+		logger$5.debug("provider.count_tokens.success", {
+			provider,
+			model: anthropicPayload.model,
+			input_tokens: finalTokenCount
+		});
+		return c.json({ input_tokens: finalTokenCount });
+	} catch (error) {
+		logger$5.error("provider.count_tokens.error", {
+			provider,
+			error
+		});
+		return c.json({ error: {
+			message: "Failed to count provider tokens",
+			type: "internal_server_error"
+		} }, 500);
+	}
+}
 //#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 {
+		fallback: false,
+		model: selectedModel
+	};
+	return {
+		fallback: true,
+		model: createFallbackModel(modelId.trim())
+	};
+};
 /**
 * Forwards token counting to Anthropic's real /v1/messages/count_tokens endpoint.
 * Returns the result on success, or null to fall through to estimation.
@@ -4359,43 +4612,46 @@ async function countTokensViaAnthropic(c, payload) {
 * endpoint for accurate counts. Otherwise falls back to GPT tokenizer estimation.
 */
 async function handleCountTokens(c) {
-	try {
-		const anthropicPayload = await c.req.json();
-		const anthropicResult = await countTokensViaAnthropic(c, anthropicPayload);
-		if (anthropicResult) return anthropicResult;
-		const anthropicBeta = c.req.header("anthropic-beta");
-		const openAIPayload = translateToOpenAI(anthropicPayload);
-		const selectedModel = findEndpointModel(anthropicPayload.model);
-		anthropicPayload.model = selectedModel?.id ?? anthropicPayload.model;
-		if (!selectedModel) {
-			consola.warn("Model not found, returning default token count");
-			return c.json({ input_tokens: 1 });
+	const anthropicPayload = await c.req.json();
+	anthropicPayload.model = resolveModelAlias(anthropicPayload.model);
+	const providerModelAlias = resolveExistingProviderModelAlias(anthropicPayload.model, getProviderConfigResolver$1(c));
+	if (providerModelAlias) {
+		anthropicPayload.model = providerModelAlias.model;
+		return await handleProviderCountTokensForProvider(c, {
+			payload: anthropicPayload,
+			provider: providerModelAlias.provider
+		});
+	}
+	const anthropicResult = await countTokensViaAnthropic(c, anthropicPayload);
+	if (anthropicResult) return anthropicResult;
+	const anthropicBeta = c.req.header("anthropic-beta");
+	const openAIPayload = translateToOpenAI(anthropicPayload);
+	const requestedModel = anthropicPayload.model;
+	const resolve = resolveCountTokensModel(requestedModel);
+	const selectedModel = resolve.model;
+	anthropicPayload.model = selectedModel.id;
+	if (resolve.fallback) consola.warn(`Model '${requestedModel}' not found, using o200k_base fallback tokenizer`);
+	const tokenCount = await getTokenCount(openAIPayload, selectedModel);
+	if (anthropicPayload.tools && anthropicPayload.tools.length > 0) {
+		let addToolSystemPromptCount = false;
+		if (anthropicBeta) {
+			const toolsLength = anthropicPayload.tools.length;
+			addToolSystemPromptCount = !anthropicPayload.tools.some((tool) => tool.name.startsWith("mcp__") || tool.name === "Skill" && toolsLength === 1);
 		}
-		const tokenCount = await getTokenCount(openAIPayload, selectedModel);
-		if (anthropicPayload.tools && anthropicPayload.tools.length > 0) {
-			let addToolSystemPromptCount = false;
-			if (anthropicBeta) {
-				const toolsLength = anthropicPayload.tools.length;
-				addToolSystemPromptCount = !anthropicPayload.tools.some((tool) => tool.name.startsWith("mcp__") || tool.name === "Skill" && toolsLength === 1);
-			}
-			if (addToolSystemPromptCount) {
-				if (anthropicPayload.model.startsWith("claude")) tokenCount.input = tokenCount.input + 346;
-				else if (anthropicPayload.model.startsWith("grok")) tokenCount.input = tokenCount.input + 120;
-			}
+		if (addToolSystemPromptCount) {
+			if (anthropicPayload.model.startsWith("claude")) tokenCount.input = tokenCount.input + 346;
+			else if (anthropicPayload.model.startsWith("grok")) tokenCount.input = tokenCount.input + 120;
 		}
-		let finalTokenCount = tokenCount.input + tokenCount.output;
-		if (anthropicPayload.model.startsWith("claude")) finalTokenCount = Math.round(finalTokenCount * getClaudeTokenMultiplier());
-		consola.info("Token count:", finalTokenCount);
-		return c.json({ input_tokens: finalTokenCount });
-	} catch (error) {
-		consola.error("Error counting tokens:", error);
-		return c.json({ input_tokens: 1 });
 	}
+	let finalTokenCount = tokenCount.input + tokenCount.output;
+	if (anthropicPayload.model.startsWith("claude")) finalTokenCount = Math.round(finalTokenCount * getClaudeTokenMultiplier());
+	consola.info("Token count:", finalTokenCount);
+	return c.json({ input_tokens: finalTokenCount });
 }
-
 //#endregion
 //#region src/services/copilot/create-responses.ts
-const createResponses = async (payload, { vision, initiator, upstreamRequestId, subagentMarker, sessionId, compactType, requestId }, 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, {
@@ -4410,13 +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,
-		callSite: "responses"
+		requestId: options.requestId,
+		callSite: "responses",
+		fetchImpl: options.fetchImpl
 	});
 	logCopilotRateLimits(response.headers);
 	if (!response.ok) {
@@ -4426,22 +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$1 = "Thinking...";
-const translateAnthropicMessagesToResponsesPayload = (payload, modelOverride) => {
-	const model = modelOverride ?? payload.model;
+const THINKING_TEXT = "Thinking...";
+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),
@@ -4451,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,
@@ -4461,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}`;
@@ -4598,8 +5178,8 @@ const createFileContent = (block) => ({
 	filename: block.title ?? "document.pdf"
 });
 const createReasoningContent = (block) => {
-	const { encryptedContent, id } = parseReasoningSignature(block.signature);
-	const thinking = block.thinking === THINKING_TEXT$1 ? "" : block.thinking;
+	const { encryptedContent, id } = parseReasoningSignature$1(block.signature);
+	const thinking = block.thinking === "Thinking..." ? "" : block.thinking;
 	return {
 		id,
 		type: "reasoning",
@@ -4619,7 +5199,7 @@ const createCompactionContent = (block) => {
 		encrypted_content: compaction.encrypted_content
 	};
 };
-const parseReasoningSignature = (signature) => {
+const parseReasoningSignature$1 = (signature) => {
 	const splitIndex = signature.lastIndexOf("@");
 	if (splitIndex <= 0 || splitIndex === signature.length - 1) return {
 		encryptedContent: signature,
@@ -4765,7 +5345,7 @@ const extractReasoningText = (item) => {
 			continue;
 		}
 	};
-	if (!item.summary || item.summary.length === 0) return THINKING_TEXT$1;
+	if (!item.summary || item.summary.length === 0) return THINKING_TEXT;
 	collectFromBlocks(item.summary);
 	return segments.join("").trim();
 };
@@ -4784,7 +5364,7 @@ const createCompactionThinkingBlock = (item) => {
 	if (!item.id || !item.encrypted_content) return null;
 	return {
 		type: "thinking",
-		thinking: THINKING_TEXT$1,
+		thinking: THINKING_TEXT,
 		signature: encodeCompactionCarrierSignature({
 			id: item.id,
 			encrypted_content: item.encrypted_content
@@ -4859,7 +5439,869 @@ const convertToolResultContent = (content) => {
 	}
 	return "";
 };
-
+//#endregion
+//#region src/routes/messages/responses-item-ownership.ts
+function buildResponsesItemOwnershipKey(kind, value) {
+	return `responses-item-owner:${kind}:${createHash("sha256").update(value).digest("hex")}`;
+}
+function extractAnthropicResponsesItemOwnerKeys(payload) {
+	const keys = [];
+	for (const message of payload.messages) {
+		if (message.role !== "assistant" || !Array.isArray(message.content)) continue;
+		for (const block of message.content) {
+			if (block.type !== "thinking" || !block.signature) continue;
+			addSignatureOwnerKeys(keys, block.signature);
+		}
+	}
+	return unique(keys);
+}
+function extractResponsesResultOwnerKeys(result) {
+	const keys = [];
+	for (const item of result.output) addOutputItemOwnerKeys(keys, item);
+	return unique(keys);
+}
+function extractResponsesStreamEventOwnerKeys(event) {
+	if (event.type === "response.output_item.done") {
+		const keys = [];
+		addOutputItemOwnerKeys(keys, event.item);
+		return unique(keys);
+	}
+	if (event.type === "response.completed" || event.type === "response.incomplete") return extractResponsesResultOwnerKeys(event.response);
+	return [];
+}
+function addSignatureOwnerKeys(keys, signature) {
+	if (signature.startsWith("cm1#")) {
+		const compaction = decodeCompactionCarrierSignature(signature);
+		if (compaction) addRawOwnerKeys(keys, compaction.id, compaction.encrypted_content);
+		return;
+	}
+	const reasoning = parseReasoningSignature(signature);
+	if (!reasoning) return;
+	addRawOwnerKeys(keys, reasoning.id, reasoning.encryptedContent);
+}
+function parseReasoningSignature(signature) {
+	const splitIndex = signature.lastIndexOf("@");
+	if (splitIndex <= 0 || splitIndex === signature.length - 1) return;
+	return {
+		encryptedContent: signature.slice(0, splitIndex),
+		id: signature.slice(splitIndex + 1)
+	};
+}
+function addOutputItemOwnerKeys(keys, item) {
+	if (!isOwnerBearingOutputItem(item)) return;
+	addRawOwnerKeys(keys, item.id, item.encrypted_content);
+}
+function isOwnerBearingOutputItem(item) {
+	return item.type === "reasoning" || item.type === "compaction";
+}
+function addRawOwnerKeys(keys, id, encryptedContent) {
+	if (id) keys.push(buildResponsesItemOwnershipKey("id", id));
+	if (encryptedContent) keys.push(buildResponsesItemOwnershipKey("encrypted_content", encryptedContent));
+}
+function unique(values) {
+	return [...new Set(values)];
+}
+//#endregion
+//#region src/routes/messages/stream-translation.ts
+function isToolBlockOpen(state) {
+	if (!state.contentBlockOpen) return false;
+	return Object.values(state.toolCalls).some((tc) => tc.anthropicBlockIndex === state.contentBlockIndex);
+}
+function translateChunkToAnthropicEvents(chunk, state) {
+	const events = [];
+	if (chunk.choices.length === 0) {
+		completePendingMessage(state, events, chunk);
+		return events;
+	}
+	const choice = chunk.choices[0];
+	const { delta } = choice;
+	handleMessageStart(state, events, chunk);
+	handleThinkingText(delta, state, events);
+	handleContent(delta, state, events);
+	handleToolCalls(delta, state, events);
+	handleFinish(choice, state, {
+		events,
+		chunk
+	});
+	return events;
+}
+function flushPendingAnthropicStreamEvents(state) {
+	const events = [];
+	completePendingMessage(state, events);
+	return events;
+}
+function completePendingMessage(state, events, chunk) {
+	if (!state.pendingMessageDelta) return;
+	if (chunk?.usage) state.pendingMessageDelta.usage = getAnthropicUsageFromOpenAIChunk(chunk, state);
+	events.push(state.pendingMessageDelta, { type: "message_stop" });
+	state.pendingMessageDelta = void 0;
+}
+function handleFinish(choice, state, context) {
+	const { events, chunk } = context;
+	if (choice.finish_reason && choice.finish_reason.length > 0) {
+		if (state.contentBlockOpen) {
+			const toolBlockOpen = isToolBlockOpen(state);
+			context.events.push({
+				type: "content_block_stop",
+				index: state.contentBlockIndex
+			});
+			state.contentBlockOpen = false;
+			state.contentBlockIndex++;
+			if (!toolBlockOpen) handleReasoningOpaque(choice.delta, events, state);
+		}
+		flushDeferredContent(state, events);
+		state.pendingMessageDelta = {
+			type: "message_delta",
+			delta: {
+				stop_reason: mapOpenAIStopReasonToAnthropic(choice.finish_reason),
+				stop_sequence: null
+			},
+			usage: getAnthropicUsageFromOpenAIChunk(chunk, state)
+		};
+		if (chunk.usage) completePendingMessage(state, events, chunk);
+	}
+}
+function getAnthropicUsageFromOpenAIChunk(chunk, state) {
+	const { cacheCreationTokens, inputTokens, cacheReadTokens } = getOpenAIChunkUsageTokens(chunk, state);
+	return {
+		input_tokens: inputTokens,
+		output_tokens: chunk.usage?.completion_tokens ?? 0,
+		...chunk.usage?.prompt_tokens_details?.cache_creation_input_tokens !== void 0 && { cache_creation_input_tokens: cacheCreationTokens },
+		...cacheReadTokens !== void 0 && { cache_read_input_tokens: cacheReadTokens }
+	};
+}
+function getOpenAIChunkUsageTokens(chunk, state) {
+	const promptTokens = chunk.usage?.prompt_tokens;
+	const cachedTokens = chunk.usage?.prompt_tokens_details?.cached_tokens ?? 0;
+	const cacheCreationTokens = chunk.usage?.prompt_tokens_details?.cache_creation_input_tokens ?? 0;
+	if (promptTokens !== void 0) return {
+		cacheCreationTokens,
+		cachedTokens,
+		inputTokens: Math.max(0, promptTokens - cachedTokens - cacheCreationTokens),
+		cacheReadTokens: chunk.usage?.prompt_tokens_details?.cached_tokens
+	};
+	const historicalInputTokens = state?.historicalInputTokens;
+	const historicalOutputTokens = state?.historicalOutputTokens ?? 0;
+	return {
+		cacheCreationTokens,
+		cachedTokens,
+		inputTokens: (historicalInputTokens !== void 0 ? historicalInputTokens + historicalOutputTokens : void 0) ?? state?.estimatedInputTokens ?? 0,
+		cacheReadTokens: state?.historicalCachedInputTokens
+	};
+}
+function handleToolCalls(delta, state, events) {
+	if (delta.tool_calls && delta.tool_calls.length > 0) {
+		closeThinkingBlockIfOpen(state, events);
+		handleReasoningOpaqueInToolCalls(state, events, delta);
+		for (const toolCall of delta.tool_calls) {
+			if (toolCall.id && toolCall.function?.name) {
+				if (state.contentBlockOpen) {
+					events.push({
+						type: "content_block_stop",
+						index: state.contentBlockIndex
+					});
+					state.contentBlockIndex++;
+					state.contentBlockOpen = false;
+				}
+				const anthropicBlockIndex = state.contentBlockIndex;
+				state.toolCalls[toolCall.index] = {
+					id: toolCall.id,
+					name: toolCall.function.name,
+					anthropicBlockIndex
+				};
+				events.push({
+					type: "content_block_start",
+					index: anthropicBlockIndex,
+					content_block: {
+						type: "tool_use",
+						id: toolCall.id,
+						name: toolCall.function.name,
+						input: {}
+					}
+				});
+				state.contentBlockOpen = true;
+			}
+			if (toolCall.function?.arguments) {
+				const toolCallInfo = state.toolCalls[toolCall.index];
+				if (toolCallInfo) events.push({
+					type: "content_block_delta",
+					index: toolCallInfo.anthropicBlockIndex,
+					delta: {
+						type: "input_json_delta",
+						partial_json: toolCall.function.arguments
+					}
+				});
+			}
+		}
+	}
+}
+function handleReasoningOpaqueInToolCalls(state, events, delta) {
+	if (state.contentBlockOpen && !isToolBlockOpen(state)) {
+		events.push({
+			type: "content_block_stop",
+			index: state.contentBlockIndex
+		});
+		state.contentBlockIndex++;
+		state.contentBlockOpen = false;
+	}
+	handleReasoningOpaque(delta, events, state);
+}
+function handleContent(delta, state, events) {
+	if (delta.content && delta.content.length > 0) {
+		closeThinkingBlockIfOpen(state, events);
+		if (isToolBlockOpen(state) || hasToolCallDelta(delta)) {
+			state.deferredContent = `${state.deferredContent ?? ""}${delta.content}`;
+			return;
+		}
+		if (!state.contentBlockOpen) {
+			events.push({
+				type: "content_block_start",
+				index: state.contentBlockIndex,
+				content_block: {
+					type: "text",
+					text: ""
+				}
+			});
+			state.contentBlockOpen = true;
+		}
+		events.push({
+			type: "content_block_delta",
+			index: state.contentBlockIndex,
+			delta: {
+				type: "text_delta",
+				text: delta.content
+			}
+		});
+	}
+	if (delta.content === "" && delta.reasoning_opaque && delta.reasoning_opaque.length > 0 && state.thinkingBlockOpen) {
+		events.push({
+			type: "content_block_delta",
+			index: state.contentBlockIndex,
+			delta: {
+				type: "signature_delta",
+				signature: delta.reasoning_opaque
+			}
+		}, {
+			type: "content_block_stop",
+			index: state.contentBlockIndex
+		});
+		state.contentBlockIndex++;
+		state.thinkingBlockOpen = false;
+	}
+}
+function hasToolCallDelta(delta) {
+	return Boolean(delta.tool_calls && delta.tool_calls.length > 0);
+}
+function flushDeferredContent(state, events) {
+	if (!state.deferredContent) return;
+	if (!state.contentBlockOpen) {
+		events.push({
+			type: "content_block_start",
+			index: state.contentBlockIndex,
+			content_block: {
+				type: "text",
+				text: ""
+			}
+		});
+		state.contentBlockOpen = true;
+	}
+	events.push({
+		type: "content_block_delta",
+		index: state.contentBlockIndex,
+		delta: {
+			type: "text_delta",
+			text: state.deferredContent
+		}
+	}, {
+		type: "content_block_stop",
+		index: state.contentBlockIndex
+	});
+	state.deferredContent = void 0;
+	state.contentBlockOpen = false;
+	state.contentBlockIndex++;
+}
+function handleMessageStart(state, events, chunk) {
+	if (!state.messageStartSent) {
+		const { cacheCreationTokens, inputTokens, cacheReadTokens } = getOpenAIChunkUsageTokens(chunk, state);
+		events.push({
+			type: "message_start",
+			message: {
+				id: chunk.id,
+				type: "message",
+				role: "assistant",
+				content: [],
+				model: chunk.model,
+				stop_reason: null,
+				stop_sequence: null,
+				usage: {
+					input_tokens: inputTokens,
+					output_tokens: 0,
+					...chunk.usage?.prompt_tokens_details?.cache_creation_input_tokens !== void 0 && { cache_creation_input_tokens: cacheCreationTokens },
+					...cacheReadTokens !== void 0 && { cache_read_input_tokens: cacheReadTokens }
+				}
+			}
+		});
+		state.messageStartSent = true;
+	}
+}
+function handleReasoningOpaque(delta, events, state) {
+	if (delta.reasoning_opaque && delta.reasoning_opaque.length > 0) {
+		events.push({
+			type: "content_block_start",
+			index: state.contentBlockIndex,
+			content_block: {
+				type: "thinking",
+				thinking: ""
+			}
+		}, {
+			type: "content_block_delta",
+			index: state.contentBlockIndex,
+			delta: {
+				type: "thinking_delta",
+				thinking: THINKING_TEXT$1
+			}
+		}, {
+			type: "content_block_delta",
+			index: state.contentBlockIndex,
+			delta: {
+				type: "signature_delta",
+				signature: delta.reasoning_opaque
+			}
+		}, {
+			type: "content_block_stop",
+			index: state.contentBlockIndex
+		});
+		state.contentBlockIndex++;
+	}
+}
+function handleThinkingText(delta, state, events) {
+	const reasoningText = delta.reasoning_text ?? delta.reasoning_content;
+	if (reasoningText && reasoningText.length > 0) {
+		if (state.contentBlockOpen) {
+			delta.content = reasoningText;
+			delta.reasoning_text = void 0;
+			delta.reasoning_content = void 0;
+			return;
+		}
+		if (!state.thinkingBlockOpen) {
+			events.push({
+				type: "content_block_start",
+				index: state.contentBlockIndex,
+				content_block: {
+					type: "thinking",
+					thinking: ""
+				}
+			});
+			state.thinkingBlockOpen = true;
+		}
+		events.push({
+			type: "content_block_delta",
+			index: state.contentBlockIndex,
+			delta: {
+				type: "thinking_delta",
+				thinking: reasoningText
+			}
+		});
+	}
+}
+function closeThinkingBlockIfOpen(state, events) {
+	if (state.thinkingBlockOpen) {
+		events.push({
+			type: "content_block_delta",
+			index: state.contentBlockIndex,
+			delta: {
+				type: "signature_delta",
+				signature: ""
+			}
+		}, {
+			type: "content_block_stop",
+			index: state.contentBlockIndex
+		});
+		state.contentBlockIndex++;
+		state.thinkingBlockOpen = false;
+	}
+}
+//#endregion
+//#region src/services/providers/anthropic-proxy.ts
+const SHARED_FORWARDABLE_HEADERS = ["accept", "user-agent"];
+const ANTHROPIC_FORWARDABLE_HEADERS = ["anthropic-version", "anthropic-beta"];
+const STRIPPED_RESPONSE_HEADERS = [
+	"connection",
+	"content-encoding",
+	"content-length",
+	"keep-alive",
+	"proxy-authenticate",
+	"proxy-authorization",
+	"te",
+	"trailer",
+	"transfer-encoding",
+	"upgrade"
+];
+function buildProviderUpstreamHeaders(providerConfig, requestHeaders) {
+	const authHeaders = {};
+	if (providerConfig.authType === "authorization") authHeaders.authorization = `Bearer ${providerConfig.apiKey}`;
+	else authHeaders["x-api-key"] = providerConfig.apiKey;
+	const headers = {
+		"content-type": "application/json",
+		accept: "application/json",
+		...authHeaders
+	};
+	for (const headerName of SHARED_FORWARDABLE_HEADERS) {
+		const headerValue = requestHeaders.get(headerName);
+		if (headerValue) headers[headerName] = headerValue;
+	}
+	if (providerConfig.type !== "anthropic") return headers;
+	for (const headerName of ANTHROPIC_FORWARDABLE_HEADERS) {
+		const headerValue = requestHeaders.get(headerName);
+		if (headerValue) headers[headerName] = headerValue;
+	}
+	return headers;
+}
+function createProviderProxyResponse(upstreamResponse) {
+	const headers = new Headers(upstreamResponse.headers);
+	for (const headerName of STRIPPED_RESPONSE_HEADERS) headers.delete(headerName);
+	return new Response(upstreamResponse.body, {
+		headers,
+		status: upstreamResponse.status,
+		statusText: upstreamResponse.statusText
+	});
+}
+async function forwardProviderMessages(providerConfig, payload, requestHeaders, fetchImpl = fetch) {
+	return await fetchImpl(`${providerConfig.baseUrl}/v1/messages`, {
+		method: "POST",
+		headers: buildProviderUpstreamHeaders(providerConfig, requestHeaders),
+		body: JSON.stringify(payload)
+	});
+}
+async function forwardProviderChatCompletions(providerConfig, payload, requestHeaders, fetchImpl = fetch) {
+	return await fetchImpl(`${providerConfig.baseUrl}/v1/chat/completions`, {
+		method: "POST",
+		headers: buildProviderUpstreamHeaders(providerConfig, requestHeaders),
+		body: JSON.stringify(payload)
+	});
+}
+async function forwardProviderModels(providerConfig, requestHeaders, fetchImpl = fetch) {
+	return await fetchImpl(`${providerConfig.baseUrl}/v1/models`, {
+		method: "GET",
+		headers: buildProviderUpstreamHeaders(providerConfig, requestHeaders)
+	});
+}
+//#endregion
+//#region src/routes/provider/messages/handler.ts
+const logger$4 = createHandlerLogger("provider-messages-handler");
+const getProviderFetch$1 = (c) => c.get("providerFetch") ?? fetch;
+const resolveProviderConfig$1 = (c, provider) => {
+	return (c.get("providerConfigResolver") ?? getProviderConfig)(provider);
+};
+const OPENAI_COMPATIBLE_CONTEXT_CACHE_MARKER_LIMIT = 4;
+const OPENAI_COMPATIBLE_CONTEXT_CACHE_CONTROL = { type: "ephemeral" };
+const OPENAI_COMPATIBLE_CONTEXT_CACHE_ROLES = new Set([
+	"system",
+	"user",
+	"assistant",
+	"tool"
+]);
+const writeProviderStreamError = async (stream, message) => {
+	try {
+		await stream.writeSSE({
+			event: "error",
+			data: JSON.stringify({
+				error: {
+					message,
+					type: "api_error"
+				},
+				type: "error"
+			})
+		});
+	} catch (error) {
+		logger$4.warn("Failed to write provider stream error event", error);
+	}
+};
+async function handleProviderMessages(c) {
+	const provider = c.req.param("provider");
+	return await handleProviderMessagesForProvider(c, {
+		payload: await c.req.json(),
+		provider
+	});
+}
+async function handleProviderMessagesForProvider(c, options) {
+	const { instrumentation, payload, provider } = options;
+	const providerConfig = resolveProviderConfig$1(c, provider);
+	if (!providerConfig) {
+		const message = `Provider '${provider}' not found or disabled`;
+		instrumentation?.onError?.({
+			errorMessage: message,
+			errorName: "ProviderNotFoundError",
+			errorStatus: 404,
+			httpStatus: 404
+		});
+		return c.json({ error: {
+			message,
+			type: "invalid_request_error"
+		} }, 404);
+	}
+	try {
+		const modelConfig = providerConfig.models?.[payload.model];
+		applyModelDefaults(payload, modelConfig);
+		debugJson(logger$4, "provider.messages.request", {
+			payload,
+			provider
+		});
+		if (providerConfig.type === "openai-compatible") return await handleOpenAICompatibleProviderMessages(c, {
+			instrumentation,
+			modelConfig,
+			payload,
+			provider,
+			providerConfig
+		});
+		applyMissingExtraBody(payload, { extraBody: modelConfig?.extraBody });
+		const upstreamResponse = await forwardProviderMessages(providerConfig, payload, c.req.raw.headers, getProviderFetch$1(c));
+		if (!upstreamResponse.ok) {
+			logger$4.error("Failed to create responses", upstreamResponse);
+			throw new HTTPError("Failed to create responses", upstreamResponse);
+		}
+		const contentType = upstreamResponse.headers.get("content-type") ?? "";
+		if (Boolean(payload.stream) && contentType.includes("text/event-stream")) return streamProviderMessages({
+			c,
+			instrumentation,
+			payload,
+			provider,
+			providerConfig,
+			upstreamResponse
+		});
+		return respondProviderMessagesJson(c, {
+			body: await upstreamResponse.json(),
+			instrumentation,
+			payload,
+			provider,
+			providerConfig
+		});
+	} catch (error) {
+		logger$4.error("provider.messages.error", {
+			provider,
+			error
+		});
+		throw error;
+	}
+}
+const applyModelDefaults = (payload, modelConfig) => {
+	payload.temperature ??= modelConfig?.temperature;
+	payload.top_p ??= modelConfig?.topP;
+	payload.top_k ??= modelConfig?.topK;
+};
+const applyMissingExtraBody = (payload, options) => {
+	for (const [key, value] of Object.entries(options.extraBody ?? {})) if (!Object.hasOwn(payload, key)) payload[key] = value;
+};
+const handleOpenAICompatibleProviderMessages = async (c, options) => {
+	const { instrumentation, modelConfig, payload, provider, providerConfig } = options;
+	const openAIPayload = createOpenAICompatiblePayload(payload, modelConfig);
+	debugJson(logger$4, "provider.messages.openai_compatible.request", {
+		payload: openAIPayload,
+		provider
+	});
+	const upstreamResponse = await forwardProviderChatCompletions(providerConfig, openAIPayload, c.req.raw.headers, getProviderFetch$1(c));
+	if (!upstreamResponse.ok) {
+		logger$4.error("Failed to create openai-compatible responses", upstreamResponse);
+		throw new HTTPError("Failed to create openai-compatible responses", upstreamResponse);
+	}
+	const contentType = upstreamResponse.headers.get("content-type") ?? "";
+	if (Boolean(openAIPayload.stream) && contentType.includes("text/event-stream")) return streamOpenAICompatibleProviderMessages({
+		c,
+		instrumentation,
+		payload,
+		provider,
+		upstreamResponse
+	});
+	return respondOpenAICompatibleProviderMessagesJson(c, {
+		body: await upstreamResponse.json(),
+		instrumentation,
+		payload,
+		provider
+	});
+};
+const createOpenAICompatiblePayload = (payload, modelConfig) => {
+	const openAIPayload = translateToOpenAI(payload, {
+		supportPdf: modelConfig?.supportPdf,
+		toolContentSupportType: modelConfig?.toolContentSupportType ?? []
+	});
+	if (payload.top_k !== void 0) openAIPayload.top_k = payload.top_k;
+	if (openAIPayload.stream) openAIPayload.stream_options = { include_usage: true };
+	normalizeOpenAICompatibleReasoningContent(openAIPayload);
+	applyOpenAICompatibleRequestOverrides(openAIPayload, {
+		extraBody: modelConfig?.extraBody,
+		source: payload
+	});
+	applyMissingExtraBody(openAIPayload, { extraBody: modelConfig?.extraBody });
+	if (!Object.hasOwn(openAIPayload, "parallel_tool_calls")) openAIPayload.parallel_tool_calls = true;
+	if (modelConfig?.contextCache !== false) applyOpenAICompatibleContextCache(openAIPayload);
+	return openAIPayload;
+};
+const normalizeOpenAICompatibleReasoningContent = (payload) => {
+	for (const message of payload.messages) {
+		if (message.role !== "assistant") continue;
+		if (message.reasoning_content === void 0 && message.reasoning_text !== void 0) message.reasoning_content = message.reasoning_text;
+		delete message.reasoning_text;
+		delete message.reasoning_opaque;
+	}
+};
+const applyOpenAICompatibleRequestOverrides = (payload, options) => {
+	const allowedKeys = new Set(Object.keys(options.extraBody ?? {}));
+	for (const key of allowedKeys) if (Object.hasOwn(options.source, key)) payload[key] = options.source[key];
+};
+const applyOpenAICompatibleContextCache = (payload) => {
+	const messageIndexes = selectContextCacheMessageIndexes(payload.messages);
+	for (const messageIndex of messageIndexes) applyContextCacheControl(payload.messages[messageIndex]);
+};
+const selectContextCacheMessageIndexes = (messages) => {
+	const cacheableIndexes = messages.flatMap((message, index) => isContextCacheMarkerEligible(message) ? [index] : []);
+	const systemIndexes = cacheableIndexes.filter((index) => messages[index]?.role === "system").slice(0, 2);
+	const finalIndexes = cacheableIndexes.filter((index) => messages[index]?.role !== "system").slice(-2);
+	return uniqueIndexes([...systemIndexes, ...finalIndexes]).sort((a, b) => a - b);
+};
+const uniqueIndexes = (indexes) => [...new Set(indexes)].slice(0, OPENAI_COMPATIBLE_CONTEXT_CACHE_MARKER_LIMIT);
+const isContextCacheMarkerEligible = (message) => {
+	if (!OPENAI_COMPATIBLE_CONTEXT_CACHE_ROLES.has(message.role)) return false;
+	if (typeof message.content === "string") return message.content.length > 0;
+	return Array.isArray(message.content) && message.content.length > 0;
+};
+const applyContextCacheControl = (message) => {
+	if (!message) return;
+	if (typeof message.content === "string") {
+		message.content = [{
+			type: "text",
+			text: message.content,
+			cache_control: { ...OPENAI_COMPATIBLE_CONTEXT_CACHE_CONTROL }
+		}];
+		return;
+	}
+	if (!Array.isArray(message.content)) return;
+	const lastPart = message.content.at(-1);
+	if (!lastPart) return;
+	setContextCacheControl(lastPart);
+};
+const setContextCacheControl = (part) => {
+	part.cache_control = { ...OPENAI_COMPATIBLE_CONTEXT_CACHE_CONTROL };
+};
+const streamProviderMessages = ({ c, instrumentation, providerConfig, upstreamResponse }) => {
+	logger$4.debug("provider.messages.streaming");
+	return streamSSE(c, async (stream) => {
+		let usage = {};
+		try {
+			let completed = false;
+			for await (const chunk of events(upstreamResponse)) {
+				logger$4.debug("provider.messages.raw_stream_event:", chunk.data);
+				const eventName = chunk.event;
+				if (eventName === "ping") {
+					await stream.writeSSE({
+						event: "ping",
+						data: "{\"type\":\"ping\"}"
+					});
+					continue;
+				}
+				let data = chunk.data;
+				if (!data) continue;
+				if (chunk.data === "[DONE]") {
+					completed = true;
+					break;
+				}
+				const parsed = parseProviderStreamEvent(data, providerConfig);
+				usage = mergeAnthropicUsage(usage, parsed.usage);
+				data = parsed.data;
+				await stream.writeSSE({
+					event: eventName,
+					data
+				});
+				if (parsed.error || eventName === "error") {
+					instrumentation?.onError?.(parsed.error ?? {
+						errorMessage: data,
+						errorName: "ProviderStreamError",
+						httpStatus: 500
+					});
+					return;
+				}
+				completed ||= parsed.done;
+			}
+			if (!completed) throw new Error("Provider messages stream ended before completion");
+			instrumentation?.onComplete?.(usage);
+		} catch (error) {
+			const details = await extractErrorObservability(error);
+			logger$4.warn("provider.messages.streaming.error", error);
+			instrumentation?.onError?.(details);
+			await writeProviderStreamError(stream, getUserVisibleErrorMessage(details));
+		}
+	});
+};
+const streamOpenAICompatibleProviderMessages = ({ c, instrumentation, upstreamResponse }) => {
+	logger$4.debug("provider.messages.openai_compatible.streaming");
+	return streamSSE(c, async (stream) => {
+		let usage = {};
+		const streamState = {
+			messageStartSent: false,
+			contentBlockIndex: 0,
+			contentBlockOpen: false,
+			toolCalls: {},
+			thinkingBlockOpen: false
+		};
+		try {
+			let completed = false;
+			for await (const chunk of events(upstreamResponse)) {
+				logger$4.debug("provider.messages.openai_compatible.raw_stream_event:", chunk.data);
+				if (chunk.event === "ping") {
+					await stream.writeSSE({
+						event: "ping",
+						data: "{\"type\":\"ping\"}"
+					});
+					continue;
+				}
+				if (!chunk.data) continue;
+				if (chunk.data === "[DONE]") {
+					completed = true;
+					break;
+				}
+				const parsed = parseOpenAICompatibleStreamChunk(chunk.data);
+				if (parsed.usage) usage = normalizeOpenAIUsage(parsed.usage);
+				const events = translateChunkToAnthropicEvents(parsed, streamState);
+				for (const event of events) {
+					const eventData = JSON.stringify(event);
+					debugLazy(logger$4, () => ["provider.messages.openai_compatible.translated_event:", eventData]);
+					await stream.writeSSE({
+						event: event.type,
+						data: eventData
+					});
+					completed ||= event.type === "message_stop";
+				}
+			}
+			for (const event of flushPendingAnthropicStreamEvents(streamState)) {
+				const eventData = JSON.stringify(event);
+				debugLazy(logger$4, () => ["provider.messages.openai_compatible.translated_event:", eventData]);
+				await stream.writeSSE({
+					event: event.type,
+					data: eventData
+				});
+				completed ||= event.type === "message_stop";
+			}
+			if (!completed) throw new Error("OpenAI-compatible provider messages stream ended before completion");
+			instrumentation?.onComplete?.(usage);
+		} catch (error) {
+			const details = await extractErrorObservability(error);
+			logger$4.warn("provider.messages.openai_compatible.streaming.error", error);
+			instrumentation?.onError?.(details);
+			await writeProviderStreamError(stream, getUserVisibleErrorMessage(details));
+		}
+	});
+};
+const parseOpenAICompatibleStreamChunk = (data) => {
+	let parsed;
+	try {
+		parsed = JSON.parse(data);
+	} catch (error) {
+		logger$4.error("provider.messages.openai_compatible.parse_chunk_error", {
+			data,
+			error
+		});
+		throw new Error("Failed to parse OpenAI-compatible stream chunk", { cause: error });
+	}
+	const streamErrorMessage = getOpenAICompatibleStreamErrorMessage(parsed.error);
+	if (streamErrorMessage) throw new Error(streamErrorMessage);
+	return parsed;
+};
+const getOpenAICompatibleStreamErrorMessage = (error) => {
+	if (typeof error === "string") return error;
+	if (!error || typeof error !== "object") return null;
+	const message = error.message;
+	return typeof message === "string" ? message : JSON.stringify(error);
+};
+const parseProviderStreamEvent = (data, providerConfig) => {
+	try {
+		const parsed = JSON.parse(data);
+		if (parsed.type === "message_start") {
+			adjustInputTokens(providerConfig, parsed.message.usage);
+			return {
+				data: JSON.stringify(parsed),
+				done: false,
+				model: parsed.message.model,
+				usage: normalizeAnthropicUsage(parsed.message.usage)
+			};
+		}
+		if (parsed.type === "message_delta") {
+			adjustInputTokens(providerConfig, parsed.usage);
+			return {
+				data: JSON.stringify(parsed),
+				done: false,
+				usage: normalizeAnthropicUsage(parsed.usage)
+			};
+		}
+		if (parsed.type === "message_stop") return {
+			data: JSON.stringify(parsed),
+			done: true,
+			usage: {}
+		};
+		if (parsed.type === "error") return {
+			data: JSON.stringify(parsed),
+			done: false,
+			error: {
+				errorMessage: parsed.error.message,
+				errorName: parsed.error.type,
+				httpStatus: 500
+			},
+			usage: {}
+		};
+		return {
+			data: JSON.stringify(parsed),
+			done: false,
+			usage: {}
+		};
+	} catch (error) {
+		logger$4.error("provider.messages.streaming.adjust_tokens_error", {
+			error,
+			originalData: data
+		});
+		throw new Error("Failed to parse provider messages stream event", { cause: error });
+	}
+};
+const respondProviderMessagesJson = (c, options) => {
+	const { body, instrumentation, providerConfig } = options;
+	adjustInputTokens(providerConfig, body.usage);
+	debugJson(logger$4, "provider.messages.no_stream result:", body);
+	const response = c.json(body);
+	instrumentation?.onComplete?.(normalizeAnthropicUsage(body.usage));
+	return response;
+};
+const respondOpenAICompatibleProviderMessagesJson = (c, options) => {
+	const { body, instrumentation } = options;
+	const anthropicResponse = translateToAnthropic(body);
+	debugJson(logger$4, "provider.messages.openai_compatible.no_stream result:", anthropicResponse);
+	const response = c.json(anthropicResponse);
+	instrumentation?.onComplete?.(normalizeOpenAIUsage(body.usage));
+	return response;
+};
+const normalizeOpenAIUsage = (usage) => {
+	const cacheCreationInputTokens = usage?.prompt_tokens_details?.cache_creation_input_tokens;
+	const cacheReadInputTokens = usage?.prompt_tokens_details?.cached_tokens;
+	return {
+		inputTokens: usage?.prompt_tokens === void 0 ? void 0 : Math.max(0, usage.prompt_tokens - (cacheCreationInputTokens ?? 0) - (cacheReadInputTokens ?? 0)),
+		outputTokens: usage?.completion_tokens,
+		cacheCreationInputTokens,
+		cacheReadInputTokens
+	};
+};
+const normalizeAnthropicUsage = (usage) => ({
+	inputTokens: usage?.input_tokens,
+	outputTokens: usage?.output_tokens,
+	cacheCreationInputTokens: usage?.cache_creation_input_tokens,
+	cacheReadInputTokens: usage?.cache_read_input_tokens
+});
+const mergeAnthropicUsage = (current, next) => ({
+	inputTokens: next.inputTokens ?? current.inputTokens,
+	outputTokens: next.outputTokens ?? current.outputTokens,
+	cacheCreationInputTokens: next.cacheCreationInputTokens ?? current.cacheCreationInputTokens,
+	cacheReadInputTokens: next.cacheReadInputTokens ?? current.cacheReadInputTokens
+});
+const adjustInputTokens = (providerConfig, usage) => {
+	if (!providerConfig.adjustInputTokens || !usage) return;
+	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);
+};
 //#endregion
 //#region src/routes/messages/responses-stream-translation.ts
 const MAX_CONSECUTIVE_FUNCTION_CALL_WHITESPACE = 20;
@@ -4896,40 +6338,40 @@ const createResponsesStreamState = () => ({
 	blockHasDelta: /* @__PURE__ */ new Set(),
 	functionCallStateByOutputIndex: /* @__PURE__ */ new Map()
 });
-const translateResponsesStreamEvent = (rawEvent, state$1) => {
+const translateResponsesStreamEvent = (rawEvent, state) => {
 	switch (rawEvent.type) {
-		case "response.created": return handleResponseCreated(rawEvent, state$1);
-		case "response.output_item.added": return handleOutputItemAdded$1(rawEvent, state$1);
-		case "response.reasoning_summary_text.delta": return handleReasoningSummaryTextDelta(rawEvent, state$1);
-		case "response.output_text.delta": return handleOutputTextDelta(rawEvent, state$1);
-		case "response.reasoning_summary_text.done": return handleReasoningSummaryTextDone(rawEvent, state$1);
-		case "response.output_text.done": return handleOutputTextDone(rawEvent, state$1);
-		case "response.output_item.done": return handleOutputItemDone$1(rawEvent, state$1);
-		case "response.function_call_arguments.delta": return handleFunctionCallArgumentsDelta(rawEvent, state$1);
-		case "response.function_call_arguments.done": return handleFunctionCallArgumentsDone(rawEvent, state$1);
+		case "response.created": return handleResponseCreated(rawEvent, state);
+		case "response.output_item.added": return handleOutputItemAdded$1(rawEvent, state);
+		case "response.reasoning_summary_text.delta": return handleReasoningSummaryTextDelta(rawEvent, state);
+		case "response.output_text.delta": return handleOutputTextDelta(rawEvent, state);
+		case "response.reasoning_summary_text.done": return handleReasoningSummaryTextDone(rawEvent, state);
+		case "response.output_text.done": return handleOutputTextDone(rawEvent, state);
+		case "response.output_item.done": return handleOutputItemDone$1(rawEvent, state);
+		case "response.function_call_arguments.delta": return handleFunctionCallArgumentsDelta(rawEvent, state);
+		case "response.function_call_arguments.done": return handleFunctionCallArgumentsDone(rawEvent, state);
 		case "response.completed":
-		case "response.incomplete": return handleResponseCompleted(rawEvent, state$1);
-		case "response.failed": return handleResponseFailed(rawEvent, state$1);
-		case "error": return handleErrorEvent(rawEvent, state$1);
+		case "response.incomplete": return handleResponseCompleted(rawEvent, state);
+		case "response.failed": return handleResponseFailed(rawEvent, state);
+		case "error": return handleErrorEvent(rawEvent, state);
 		default: return [];
 	}
 };
-const handleResponseCreated = (rawEvent, state$1) => {
-	return messageStart(state$1, rawEvent.response);
+const handleResponseCreated = (rawEvent, state) => {
+	return messageStart(state, rawEvent.response);
 };
-const handleOutputItemAdded$1 = (rawEvent, state$1) => {
-	const events$1 = new Array();
+const handleOutputItemAdded$1 = (rawEvent, state) => {
+	const events = new Array();
 	const functionCallDetails = extractFunctionCallDetails(rawEvent);
-	if (!functionCallDetails) return events$1;
+	if (!functionCallDetails) return events;
 	const { outputIndex, toolCallId, name, initialArguments } = functionCallDetails;
-	const blockIndex = openFunctionCallBlock(state$1, {
+	const blockIndex = openFunctionCallBlock(state, {
 		outputIndex,
 		toolCallId,
 		name,
-		events: events$1
+		events
 	});
 	if (initialArguments !== void 0 && initialArguments.length > 0) {
-		events$1.push({
+		events.push({
 			type: "content_block_delta",
 			index: blockIndex,
 			delta: {
@@ -4937,29 +6379,29 @@ const handleOutputItemAdded$1 = (rawEvent, state$1) => {
 				partial_json: initialArguments
 			}
 		});
-		state$1.blockHasDelta.add(blockIndex);
+		state.blockHasDelta.add(blockIndex);
 	}
-	return events$1;
+	return events;
 };
-const handleOutputItemDone$1 = (rawEvent, state$1) => {
-	const events$1 = new Array();
+const handleOutputItemDone$1 = (rawEvent, state) => {
+	const events = new Array();
 	const item = rawEvent.item;
 	const itemType = item.type;
 	const outputIndex = rawEvent.output_index;
 	if (itemType === "compaction") {
-		if (!item.id || !item.encrypted_content) return events$1;
-		const blockIndex$1 = openThinkingBlockIfNeeded(state$1, outputIndex, events$1);
-		if (!state$1.blockHasDelta.has(blockIndex$1)) events$1.push({
+		if (!item.id || !item.encrypted_content) return events;
+		const blockIndex = openThinkingBlockIfNeeded(state, outputIndex, events);
+		if (!state.blockHasDelta.has(blockIndex)) events.push({
 			type: "content_block_delta",
-			index: blockIndex$1,
+			index: blockIndex,
 			delta: {
 				type: "thinking_delta",
-				thinking: THINKING_TEXT$1
+				thinking: THINKING_TEXT
 			}
 		});
-		events$1.push({
+		events.push({
 			type: "content_block_delta",
-			index: blockIndex$1,
+			index: blockIndex,
 			delta: {
 				type: "signature_delta",
 				signature: encodeCompactionCarrierSignature({
@@ -4968,22 +6410,22 @@ const handleOutputItemDone$1 = (rawEvent, state$1) => {
 				})
 			}
 		});
-		state$1.blockHasDelta.add(blockIndex$1);
-		return events$1;
+		state.blockHasDelta.add(blockIndex);
+		return events;
 	}
-	if (itemType !== "reasoning") return events$1;
-	const blockIndex = openThinkingBlockIfNeeded(state$1, outputIndex, events$1);
+	if (itemType !== "reasoning") return events;
+	const blockIndex = openThinkingBlockIfNeeded(state, outputIndex, events);
 	const signature = (item.encrypted_content ?? "") + "@" + item.id;
 	if (signature) {
-		if (!item.summary || item.summary.length === 0) events$1.push({
+		if (!item.summary || item.summary.length === 0) events.push({
 			type: "content_block_delta",
 			index: blockIndex,
 			delta: {
 				type: "thinking_delta",
-				thinking: THINKING_TEXT$1
+				thinking: THINKING_TEXT
 			}
 		});
-		events$1.push({
+		events.push({
 			type: "content_block_delta",
 			index: blockIndex,
 			delta: {
@@ -4991,25 +6433,25 @@ const handleOutputItemDone$1 = (rawEvent, state$1) => {
 				signature
 			}
 		});
-		state$1.blockHasDelta.add(blockIndex);
+		state.blockHasDelta.add(blockIndex);
 	}
-	return events$1;
+	return events;
 };
-const handleFunctionCallArgumentsDelta = (rawEvent, state$1) => {
-	const events$1 = new Array();
+const handleFunctionCallArgumentsDelta = (rawEvent, state) => {
+	const events = new Array();
 	const outputIndex = rawEvent.output_index;
 	const deltaText = rawEvent.delta;
-	if (!deltaText) return events$1;
-	const blockIndex = openFunctionCallBlock(state$1, {
+	if (!deltaText) return events;
+	const blockIndex = openFunctionCallBlock(state, {
 		outputIndex,
-		events: events$1
+		events
 	});
-	const functionCallState = state$1.functionCallStateByOutputIndex.get(outputIndex);
-	if (!functionCallState) return handleFunctionCallArgumentsValidationError(new FunctionCallArgumentsValidationError("Received function call arguments delta without an open tool call block."), state$1, events$1);
+	const functionCallState = state.functionCallStateByOutputIndex.get(outputIndex);
+	if (!functionCallState) return handleFunctionCallArgumentsValidationError(new FunctionCallArgumentsValidationError("Received function call arguments delta without an open tool call block."), state, events);
 	const { nextCount, exceeded } = updateWhitespaceRunState(functionCallState.consecutiveWhitespaceCount, deltaText);
-	if (exceeded) return handleFunctionCallArgumentsValidationError(new FunctionCallArgumentsValidationError("Received function call arguments delta containing more than 20 consecutive whitespace characters."), state$1, events$1);
+	if (exceeded) return handleFunctionCallArgumentsValidationError(new FunctionCallArgumentsValidationError("Received function call arguments delta containing more than 20 consecutive whitespace characters."), state, events);
 	functionCallState.consecutiveWhitespaceCount = nextCount;
-	events$1.push({
+	events.push({
 		type: "content_block_delta",
 		index: blockIndex,
 		delta: {
@@ -5017,19 +6459,19 @@ const handleFunctionCallArgumentsDelta = (rawEvent, state$1) => {
 			partial_json: deltaText
 		}
 	});
-	state$1.blockHasDelta.add(blockIndex);
-	return events$1;
+	state.blockHasDelta.add(blockIndex);
+	return events;
 };
-const handleFunctionCallArgumentsDone = (rawEvent, state$1) => {
-	const events$1 = new Array();
+const handleFunctionCallArgumentsDone = (rawEvent, state) => {
+	const events = new Array();
 	const outputIndex = rawEvent.output_index;
-	const blockIndex = openFunctionCallBlock(state$1, {
+	const blockIndex = openFunctionCallBlock(state, {
 		outputIndex,
-		events: events$1
+		events
 	});
 	const finalArguments = typeof rawEvent.arguments === "string" ? rawEvent.arguments : void 0;
-	if (!state$1.blockHasDelta.has(blockIndex) && finalArguments) {
-		events$1.push({
+	if (!state.blockHasDelta.has(blockIndex) && finalArguments) {
+		events.push({
 			type: "content_block_delta",
 			index: blockIndex,
 			delta: {
@@ -5037,23 +6479,23 @@ const handleFunctionCallArgumentsDone = (rawEvent, state$1) => {
 				partial_json: finalArguments
 			}
 		});
-		state$1.blockHasDelta.add(blockIndex);
+		state.blockHasDelta.add(blockIndex);
 	}
-	state$1.functionCallStateByOutputIndex.delete(outputIndex);
-	return events$1;
+	state.functionCallStateByOutputIndex.delete(outputIndex);
+	return events;
 };
-const handleOutputTextDelta = (rawEvent, state$1) => {
-	const events$1 = new Array();
+const handleOutputTextDelta = (rawEvent, state) => {
+	const events = new Array();
 	const outputIndex = rawEvent.output_index;
 	const contentIndex = rawEvent.content_index;
 	const deltaText = rawEvent.delta;
-	if (!deltaText) return events$1;
-	const blockIndex = openTextBlockIfNeeded(state$1, {
+	if (!deltaText) return events;
+	const blockIndex = openTextBlockIfNeeded(state, {
 		outputIndex,
 		contentIndex,
-		events: events$1
+		events
 	});
-	events$1.push({
+	events.push({
 		type: "content_block_delta",
 		index: blockIndex,
 		delta: {
@@ -5061,15 +6503,15 @@ const handleOutputTextDelta = (rawEvent, state$1) => {
 			text: deltaText
 		}
 	});
-	state$1.blockHasDelta.add(blockIndex);
-	return events$1;
+	state.blockHasDelta.add(blockIndex);
+	return events;
 };
-const handleReasoningSummaryTextDelta = (rawEvent, state$1) => {
+const handleReasoningSummaryTextDelta = (rawEvent, state) => {
 	const outputIndex = rawEvent.output_index;
 	const deltaText = rawEvent.delta;
-	const events$1 = new Array();
-	const blockIndex = openThinkingBlockIfNeeded(state$1, outputIndex, events$1);
-	events$1.push({
+	const events = new Array();
+	const blockIndex = openThinkingBlockIfNeeded(state, outputIndex, events);
+	events.push({
 		type: "content_block_delta",
 		index: blockIndex,
 		delta: {
@@ -5077,15 +6519,15 @@ const handleReasoningSummaryTextDelta = (rawEvent, state$1) => {
 			thinking: deltaText
 		}
 	});
-	state$1.blockHasDelta.add(blockIndex);
-	return events$1;
+	state.blockHasDelta.add(blockIndex);
+	return events;
 };
-const handleReasoningSummaryTextDone = (rawEvent, state$1) => {
+const handleReasoningSummaryTextDone = (rawEvent, state) => {
 	const outputIndex = rawEvent.output_index;
 	const text = rawEvent.text;
-	const events$1 = new Array();
-	const blockIndex = openThinkingBlockIfNeeded(state$1, outputIndex, events$1);
-	if (text && !state$1.blockHasDelta.has(blockIndex)) events$1.push({
+	const events = new Array();
+	const blockIndex = openThinkingBlockIfNeeded(state, outputIndex, events);
+	if (text && !state.blockHasDelta.has(blockIndex)) events.push({
 		type: "content_block_delta",
 		index: blockIndex,
 		delta: {
@@ -5093,19 +6535,19 @@ const handleReasoningSummaryTextDone = (rawEvent, state$1) => {
 			thinking: text
 		}
 	});
-	return events$1;
+	return events;
 };
-const handleOutputTextDone = (rawEvent, state$1) => {
-	const events$1 = new Array();
+const handleOutputTextDone = (rawEvent, state) => {
+	const events = new Array();
 	const outputIndex = rawEvent.output_index;
 	const contentIndex = rawEvent.content_index;
 	const text = rawEvent.text;
-	const blockIndex = openTextBlockIfNeeded(state$1, {
+	const blockIndex = openTextBlockIfNeeded(state, {
 		outputIndex,
 		contentIndex,
-		events: events$1
+		events
 	});
-	if (text && !state$1.blockHasDelta.has(blockIndex)) events$1.push({
+	if (text && !state.blockHasDelta.has(blockIndex)) events.push({
 		type: "content_block_delta",
 		index: blockIndex,
 		delta: {
@@ -5113,14 +6555,15 @@ const handleOutputTextDone = (rawEvent, state$1) => {
 			text
 		}
 	});
-	return events$1;
+	return events;
 };
-const handleResponseCompleted = (rawEvent, state$1) => {
+const handleResponseCompleted = (rawEvent, state) => {
 	const response = rawEvent.response;
-	const events$1 = new Array();
-	closeAllOpenBlocks(state$1, events$1);
+	const events = new Array();
+	closeAllOpenBlocks(state, events);
+	state.responseStatus = response.status;
 	const anthropic = translateResponsesResultToAnthropic(response);
-	events$1.push({
+	events.push({
 		type: "message_delta",
 		delta: {
 			stop_reason: anthropic.stop_reason,
@@ -5128,39 +6571,40 @@ const handleResponseCompleted = (rawEvent, state$1) => {
 		},
 		usage: anthropic.usage
 	}, { type: "message_stop" });
-	state$1.messageCompleted = true;
-	return events$1;
+	state.messageCompleted = true;
+	return events;
 };
-const handleResponseFailed = (rawEvent, state$1) => {
+const handleResponseFailed = (rawEvent, state) => {
 	const response = rawEvent.response;
-	const events$1 = new Array();
-	closeAllOpenBlocks(state$1, events$1);
+	const events = new Array();
+	closeAllOpenBlocks(state, events);
+	state.responseStatus = response.status;
 	const message = response.error?.message ?? "The response failed due to an unknown error.";
-	events$1.push(buildErrorEvent(message));
-	state$1.messageCompleted = true;
-	return events$1;
+	events.push(buildErrorEvent(message));
+	state.messageCompleted = true;
+	return events;
 };
-const handleErrorEvent = (rawEvent, state$1) => {
+const handleErrorEvent = (rawEvent, state) => {
 	const message = typeof rawEvent.message === "string" ? rawEvent.message : "An unexpected error occurred during streaming.";
-	state$1.messageCompleted = true;
+	state.messageCompleted = true;
 	return [buildErrorEvent(message)];
 };
-const handleFunctionCallArgumentsValidationError = (error, state$1, events$1 = []) => {
+const handleFunctionCallArgumentsValidationError = (error, state, events = []) => {
 	const reason = error.message;
-	closeAllOpenBlocks(state$1, events$1);
-	state$1.messageCompleted = true;
-	events$1.push(buildErrorEvent(reason));
-	return events$1;
+	closeAllOpenBlocks(state, events);
+	state.messageCompleted = true;
+	events.push(buildErrorEvent(reason));
+	return events;
 };
-const messageStart = (state$1, response) => {
-	state$1.messageStartSent = true;
+const messageStart = (state, response) => {
+	state.messageStartSent = true;
 	const inputCachedTokens = response.usage?.input_tokens_details?.cached_tokens;
 	const upstreamInputTokens = response.usage?.input_tokens;
-	const historicalInputTokens = state$1.historicalInputTokens;
-	const historicalOutputTokens = state$1.historicalOutputTokens ?? 0;
+	const historicalInputTokens = state.historicalInputTokens;
+	const historicalOutputTokens = state.historicalOutputTokens ?? 0;
 	const historicalTotalTokens = historicalInputTokens !== void 0 ? historicalInputTokens + historicalOutputTokens : void 0;
-	const inputTokens = upstreamInputTokens !== void 0 ? upstreamInputTokens - (inputCachedTokens ?? 0) : historicalTotalTokens ?? state$1.estimatedInputTokens ?? 0;
-	const cacheReadTokens = upstreamInputTokens !== void 0 ? inputCachedTokens ?? 0 : state$1.historicalCachedInputTokens ?? 0;
+	const inputTokens = upstreamInputTokens !== void 0 ? upstreamInputTokens - (inputCachedTokens ?? 0) : historicalTotalTokens ?? state.estimatedInputTokens ?? 0;
+	const cacheReadTokens = upstreamInputTokens !== void 0 ? inputCachedTokens ?? 0 : state.historicalCachedInputTokens ?? 0;
 	return [{
 		type: "message_start",
 		message: {
@@ -5179,18 +6623,18 @@ const messageStart = (state$1, response) => {
 		}
 	}];
 };
-const openTextBlockIfNeeded = (state$1, params) => {
-	const { outputIndex, contentIndex, events: events$1 } = params;
+const openTextBlockIfNeeded = (state, params) => {
+	const { outputIndex, contentIndex, events } = params;
 	const key = getBlockKey(outputIndex, contentIndex);
-	let blockIndex = state$1.blockIndexByKey.get(key);
+	let blockIndex = state.blockIndexByKey.get(key);
 	if (blockIndex === void 0) {
-		blockIndex = state$1.nextContentBlockIndex;
-		state$1.nextContentBlockIndex += 1;
-		state$1.blockIndexByKey.set(key, blockIndex);
+		blockIndex = state.nextContentBlockIndex;
+		state.nextContentBlockIndex += 1;
+		state.blockIndexByKey.set(key, blockIndex);
 	}
-	if (!state$1.openBlocks.has(blockIndex)) {
-		closeOpenBlocks(state$1, events$1);
-		events$1.push({
+	if (!state.openBlocks.has(blockIndex)) {
+		closeOpenBlocks(state, events);
+		events.push({
 			type: "content_block_start",
 			index: blockIndex,
 			content_block: {
@@ -5198,21 +6642,21 @@ const openTextBlockIfNeeded = (state$1, params) => {
 				text: ""
 			}
 		});
-		state$1.openBlocks.add(blockIndex);
+		state.openBlocks.add(blockIndex);
 	}
 	return blockIndex;
 };
-const openThinkingBlockIfNeeded = (state$1, outputIndex, events$1) => {
+const openThinkingBlockIfNeeded = (state, outputIndex, events) => {
 	const key = getBlockKey(outputIndex, 0);
-	let blockIndex = state$1.blockIndexByKey.get(key);
+	let blockIndex = state.blockIndexByKey.get(key);
 	if (blockIndex === void 0) {
-		blockIndex = state$1.nextContentBlockIndex;
-		state$1.nextContentBlockIndex += 1;
-		state$1.blockIndexByKey.set(key, blockIndex);
+		blockIndex = state.nextContentBlockIndex;
+		state.nextContentBlockIndex += 1;
+		state.blockIndexByKey.set(key, blockIndex);
 	}
-	if (!state$1.openBlocks.has(blockIndex)) {
-		closeOpenBlocks(state$1, events$1);
-		events$1.push({
+	if (!state.openBlocks.has(blockIndex)) {
+		closeOpenBlocks(state, events);
+		events.push({
 			type: "content_block_start",
 			index: blockIndex,
 			content_block: {
@@ -5220,25 +6664,25 @@ const openThinkingBlockIfNeeded = (state$1, outputIndex, events$1) => {
 				thinking: ""
 			}
 		});
-		state$1.openBlocks.add(blockIndex);
+		state.openBlocks.add(blockIndex);
 	}
 	return blockIndex;
 };
-const closeBlockIfOpen = (state$1, blockIndex, events$1) => {
-	if (!state$1.openBlocks.has(blockIndex)) return;
-	events$1.push({
+const closeBlockIfOpen = (state, blockIndex, events) => {
+	if (!state.openBlocks.has(blockIndex)) return;
+	events.push({
 		type: "content_block_stop",
 		index: blockIndex
 	});
-	state$1.openBlocks.delete(blockIndex);
-	state$1.blockHasDelta.delete(blockIndex);
+	state.openBlocks.delete(blockIndex);
+	state.blockHasDelta.delete(blockIndex);
 };
-const closeOpenBlocks = (state$1, events$1) => {
-	for (const blockIndex of state$1.openBlocks) closeBlockIfOpen(state$1, blockIndex, events$1);
+const closeOpenBlocks = (state, events) => {
+	for (const blockIndex of state.openBlocks) closeBlockIfOpen(state, blockIndex, events);
 };
-const closeAllOpenBlocks = (state$1, events$1) => {
-	closeOpenBlocks(state$1, events$1);
-	state$1.functionCallStateByOutputIndex.clear();
+const closeAllOpenBlocks = (state, events) => {
+	closeOpenBlocks(state, events);
+	state.functionCallStateByOutputIndex.clear();
 };
 const buildErrorEvent = (message) => ({
 	type: "error",
@@ -5248,24 +6692,24 @@ const buildErrorEvent = (message) => ({
 	}
 });
 const getBlockKey = (outputIndex, contentIndex) => `${outputIndex}:${contentIndex}`;
-const openFunctionCallBlock = (state$1, params) => {
-	const { outputIndex, toolCallId, name, events: events$1 } = params;
-	let functionCallState = state$1.functionCallStateByOutputIndex.get(outputIndex);
+const openFunctionCallBlock = (state, params) => {
+	const { outputIndex, toolCallId, name, events } = params;
+	let functionCallState = state.functionCallStateByOutputIndex.get(outputIndex);
 	if (!functionCallState) {
-		const blockIndex$1 = state$1.nextContentBlockIndex;
-		state$1.nextContentBlockIndex += 1;
+		const blockIndex = state.nextContentBlockIndex;
+		state.nextContentBlockIndex += 1;
 		functionCallState = {
-			blockIndex: blockIndex$1,
-			toolCallId: toolCallId ?? `tool_call_${blockIndex$1}`,
+			blockIndex,
+			toolCallId: toolCallId ?? `tool_call_${blockIndex}`,
 			name: name ?? "function",
 			consecutiveWhitespaceCount: 0
 		};
-		state$1.functionCallStateByOutputIndex.set(outputIndex, functionCallState);
+		state.functionCallStateByOutputIndex.set(outputIndex, functionCallState);
 	}
 	const { blockIndex } = functionCallState;
-	if (!state$1.openBlocks.has(blockIndex)) {
-		closeOpenBlocks(state$1, events$1);
-		events$1.push({
+	if (!state.openBlocks.has(blockIndex)) {
+		closeOpenBlocks(state, events);
+		events.push({
 			type: "content_block_start",
 			index: blockIndex,
 			content_block: {
@@ -5275,7 +6719,7 @@ const openFunctionCallBlock = (state$1, params) => {
 				input: {}
 			}
 		});
-		state$1.openBlocks.add(blockIndex);
+		state.openBlocks.add(blockIndex);
 	}
 	return blockIndex;
 };
@@ -5289,15 +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));
@@ -5322,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) => {
@@ -5380,7 +6832,7 @@ function getStreamChunkFields(chunk) {
 		data: c.data
 	};
 }
-const isAsyncIterable = (value) => Boolean(value) && typeof value[Symbol.asyncIterator] === "function";
+const isAsyncIterable$1 = (value) => Boolean(value) && typeof value[Symbol.asyncIterator] === "function";
 const containsVisionContent = (value) => {
 	if (!value) return false;
 	if (Array.isArray(value)) return value.some((entry) => containsVisionContent(entry));
@@ -5390,7 +6842,6 @@ const containsVisionContent = (value) => {
 	if (Array.isArray(record.content)) return record.content.some((entry) => containsVisionContent(entry));
 	return false;
 };
-
 //#endregion
 //#region src/services/copilot/create-messages.ts
 const isAgentMessage = (msg) => {
@@ -5453,297 +6904,36 @@ const buildMessagesHeaders = ({ ctx, enableVision, initiator, options, payload }
 	if (shouldUseMessageProxyHeaders(payload)) prepareMessageProxyHeaders(headers);
 	const anthropicBeta = buildAnthropicBetaHeader(options?.anthropicBetaHeader, payload.thinking, payload.model);
 	if (anthropicBeta) headers["anthropic-beta"] = anthropicBeta;
-	return headers;
-};
-const createMessages = async (payload, account, options) => {
-	const ctx = account ?? accountFromState();
-	if (!ctx.copilotToken) throw new Error("Copilot token not found");
-	const headers = buildMessagesHeaders({
-		ctx,
-		enableVision: hasVisionInput(payload),
-		initiator: options?.initiator ?? getMessagesInitiator(payload),
-		options,
-		payload
-	});
-	captureOutboundHeadersSnapshot(headers);
-	const response = await copilotFetch(`${copilotBaseUrl(ctx)}/v1/messages`, {
-		method: "POST",
-		headers,
-		body: JSON.stringify(payload)
-	}, {
-		requestId: options?.requestId,
-		callSite: "messages"
-	});
-	logCopilotRateLimits(response.headers);
-	if (!response.ok) {
-		consola.error("Failed to create messages", response);
-		throw new HTTPError("Failed to create messages", response);
-	}
-	if (payload.stream) return events(response);
-	return await response.json();
-};
-
-//#endregion
-//#region src/routes/messages/stream-translation.ts
-function isToolBlockOpen(state$1) {
-	if (!state$1.contentBlockOpen) return false;
-	return Object.values(state$1.toolCalls).some((tc) => tc.anthropicBlockIndex === state$1.contentBlockIndex);
-}
-function translateChunkToAnthropicEvents(chunk, state$1) {
-	const events$1 = [];
-	if (chunk.choices.length === 0) return events$1;
-	const choice = chunk.choices[0];
-	const { delta } = choice;
-	handleMessageStart(state$1, events$1, chunk);
-	handleThinkingText(delta, state$1, events$1);
-	handleContent(delta, state$1, events$1);
-	handleToolCalls(delta, state$1, events$1);
-	handleFinish(choice, state$1, {
-		events: events$1,
-		chunk
-	});
-	return events$1;
-}
-function handleFinish(choice, state$1, context) {
-	const { events: events$1, chunk } = context;
-	if (choice.finish_reason && choice.finish_reason.length > 0) {
-		if (state$1.contentBlockOpen) {
-			const toolBlockOpen = isToolBlockOpen(state$1);
-			context.events.push({
-				type: "content_block_stop",
-				index: state$1.contentBlockIndex
-			});
-			state$1.contentBlockOpen = false;
-			state$1.contentBlockIndex++;
-			if (!toolBlockOpen) handleReasoningOpaque(choice.delta, events$1, state$1);
-		}
-		events$1.push({
-			type: "message_delta",
-			delta: {
-				stop_reason: mapOpenAIStopReasonToAnthropic(choice.finish_reason),
-				stop_sequence: null
-			},
-			usage: {
-				input_tokens: (chunk.usage?.prompt_tokens ?? 0) - (chunk.usage?.prompt_tokens_details?.cached_tokens ?? 0),
-				output_tokens: chunk.usage?.completion_tokens ?? 0,
-				...chunk.usage?.prompt_tokens_details?.cached_tokens !== void 0 && { cache_read_input_tokens: chunk.usage.prompt_tokens_details.cached_tokens }
-			}
-		}, { type: "message_stop" });
-	}
-}
-function handleToolCalls(delta, state$1, events$1) {
-	if (delta.tool_calls && delta.tool_calls.length > 0) {
-		closeThinkingBlockIfOpen(state$1, events$1);
-		handleReasoningOpaqueInToolCalls(state$1, events$1, delta);
-		for (const toolCall of delta.tool_calls) {
-			if (toolCall.id && toolCall.function?.name) {
-				if (state$1.contentBlockOpen) {
-					events$1.push({
-						type: "content_block_stop",
-						index: state$1.contentBlockIndex
-					});
-					state$1.contentBlockIndex++;
-					state$1.contentBlockOpen = false;
-				}
-				const anthropicBlockIndex = state$1.contentBlockIndex;
-				state$1.toolCalls[toolCall.index] = {
-					id: toolCall.id,
-					name: toolCall.function.name,
-					anthropicBlockIndex
-				};
-				events$1.push({
-					type: "content_block_start",
-					index: anthropicBlockIndex,
-					content_block: {
-						type: "tool_use",
-						id: toolCall.id,
-						name: toolCall.function.name,
-						input: {}
-					}
-				});
-				state$1.contentBlockOpen = true;
-			}
-			if (toolCall.function?.arguments) {
-				const toolCallInfo = state$1.toolCalls[toolCall.index];
-				if (toolCallInfo) events$1.push({
-					type: "content_block_delta",
-					index: toolCallInfo.anthropicBlockIndex,
-					delta: {
-						type: "input_json_delta",
-						partial_json: toolCall.function.arguments
-					}
-				});
-			}
-		}
-	}
-}
-function handleReasoningOpaqueInToolCalls(state$1, events$1, delta) {
-	if (state$1.contentBlockOpen && !isToolBlockOpen(state$1)) {
-		events$1.push({
-			type: "content_block_stop",
-			index: state$1.contentBlockIndex
-		});
-		state$1.contentBlockIndex++;
-		state$1.contentBlockOpen = false;
-	}
-	handleReasoningOpaque(delta, events$1, state$1);
-}
-function handleContent(delta, state$1, events$1) {
-	if (delta.content && delta.content.length > 0) {
-		closeThinkingBlockIfOpen(state$1, events$1);
-		if (isToolBlockOpen(state$1)) {
-			events$1.push({
-				type: "content_block_stop",
-				index: state$1.contentBlockIndex
-			});
-			state$1.contentBlockIndex++;
-			state$1.contentBlockOpen = false;
-		}
-		if (!state$1.contentBlockOpen) {
-			events$1.push({
-				type: "content_block_start",
-				index: state$1.contentBlockIndex,
-				content_block: {
-					type: "text",
-					text: ""
-				}
-			});
-			state$1.contentBlockOpen = true;
-		}
-		events$1.push({
-			type: "content_block_delta",
-			index: state$1.contentBlockIndex,
-			delta: {
-				type: "text_delta",
-				text: delta.content
-			}
-		});
-	}
-	if (delta.content === "" && delta.reasoning_opaque && delta.reasoning_opaque.length > 0 && state$1.thinkingBlockOpen) {
-		events$1.push({
-			type: "content_block_delta",
-			index: state$1.contentBlockIndex,
-			delta: {
-				type: "signature_delta",
-				signature: delta.reasoning_opaque
-			}
-		}, {
-			type: "content_block_stop",
-			index: state$1.contentBlockIndex
-		});
-		state$1.contentBlockIndex++;
-		state$1.thinkingBlockOpen = false;
-	}
-}
-function handleMessageStart(state$1, events$1, chunk) {
-	if (!state$1.messageStartSent) {
-		const cachedTokens = chunk.usage?.prompt_tokens_details?.cached_tokens;
-		const upstreamPromptTokens = chunk.usage?.prompt_tokens;
-		const historicalInputTokens = state$1.historicalInputTokens;
-		const historicalOutputTokens = state$1.historicalOutputTokens ?? 0;
-		const historicalTotalTokens = historicalInputTokens !== void 0 ? historicalInputTokens + historicalOutputTokens : void 0;
-		const inputTokens = upstreamPromptTokens !== void 0 ? upstreamPromptTokens - (cachedTokens ?? 0) : historicalTotalTokens ?? state$1.estimatedInputTokens ?? 0;
-		const cacheReadTokens = upstreamPromptTokens !== void 0 ? cachedTokens : state$1.historicalCachedInputTokens;
-		events$1.push({
-			type: "message_start",
-			message: {
-				id: chunk.id,
-				type: "message",
-				role: "assistant",
-				content: [],
-				model: chunk.model,
-				stop_reason: null,
-				stop_sequence: null,
-				usage: {
-					input_tokens: inputTokens,
-					output_tokens: 0,
-					...cacheReadTokens !== void 0 && { cache_read_input_tokens: cacheReadTokens }
-				}
-			}
-		});
-		state$1.messageStartSent = true;
-	}
-}
-function handleReasoningOpaque(delta, events$1, state$1) {
-	if (delta.reasoning_opaque && delta.reasoning_opaque.length > 0) {
-		events$1.push({
-			type: "content_block_start",
-			index: state$1.contentBlockIndex,
-			content_block: {
-				type: "thinking",
-				thinking: ""
-			}
-		}, {
-			type: "content_block_delta",
-			index: state$1.contentBlockIndex,
-			delta: {
-				type: "thinking_delta",
-				thinking: THINKING_TEXT
-			}
-		}, {
-			type: "content_block_delta",
-			index: state$1.contentBlockIndex,
-			delta: {
-				type: "signature_delta",
-				signature: delta.reasoning_opaque
-			}
-		}, {
-			type: "content_block_stop",
-			index: state$1.contentBlockIndex
-		});
-		state$1.contentBlockIndex++;
-	}
-}
-function handleThinkingText(delta, state$1, events$1) {
-	if (delta.reasoning_text && delta.reasoning_text.length > 0) {
-		if (state$1.contentBlockOpen) {
-			delta.content = delta.reasoning_text;
-			delta.reasoning_text = void 0;
-			return;
-		}
-		if (!state$1.thinkingBlockOpen) {
-			events$1.push({
-				type: "content_block_start",
-				index: state$1.contentBlockIndex,
-				content_block: {
-					type: "thinking",
-					thinking: ""
-				}
-			});
-			state$1.thinkingBlockOpen = true;
-		}
-		events$1.push({
-			type: "content_block_delta",
-			index: state$1.contentBlockIndex,
-			delta: {
-				type: "thinking_delta",
-				thinking: delta.reasoning_text
-			}
-		});
-	}
-}
-function closeThinkingBlockIfOpen(state$1, events$1) {
-	if (state$1.thinkingBlockOpen) {
-		events$1.push({
-			type: "content_block_delta",
-			index: state$1.contentBlockIndex,
-			delta: {
-				type: "signature_delta",
-				signature: ""
-			}
-		}, {
-			type: "content_block_stop",
-			index: state$1.contentBlockIndex
-		});
-		state$1.contentBlockIndex++;
-		state$1.thinkingBlockOpen = false;
+	return headers;
+};
+const createMessages = async (payload, account, options) => {
+	const ctx = account ?? accountFromState();
+	if (!ctx.copilotToken) throw new Error("Copilot token not found");
+	const headers = buildMessagesHeaders({
+		ctx,
+		enableVision: hasVisionInput(payload),
+		initiator: options?.initiator ?? getMessagesInitiator(payload),
+		options,
+		payload
+	});
+	captureOutboundHeadersSnapshot(headers);
+	const response = await copilotFetch(`${copilotBaseUrl(ctx)}/v1/messages`, {
+		method: "POST",
+		headers,
+		body: JSON.stringify(payload)
+	}, {
+		requestId: options?.requestId,
+		callSite: "messages",
+		fetchImpl: options?.fetchImpl
+	});
+	logCopilotRateLimits(response.headers);
+	if (!response.ok) {
+		consola.error("Failed to create messages", response);
+		throw new HTTPError("Failed to create messages", response);
 	}
-}
-
-//#endregion
-//#region src/lib/subagent.ts
-const subagentMarkerPrefix = "__SUBAGENT_MARKER__";
-
+	if (payload.stream) return events(response);
+	return await response.json();
+};
 //#endregion
 //#region src/routes/messages/subagent-marker.ts
 const subagentStartContextPrefix = "SubagentStart hook additional context:";
@@ -5778,8 +6968,8 @@ const extractMarkerPayloadFromReminderLine = (line) => {
 	if (!trimmedLine) return null;
 	let markerLine = trimmedLine;
 	if (markerLine.startsWith(subagentStartContextPrefix)) markerLine = markerLine.slice(38).trimStart();
-	if (!markerLine.startsWith(subagentMarkerPrefix)) return null;
-	return markerLine.slice(subagentMarkerPrefix.length).trimStart();
+	if (!markerLine.startsWith("__SUBAGENT_MARKER__")) return null;
+	return markerLine.slice(19).trimStart();
 };
 const inspectSubagentMarkerFromSystemReminder = (text) => {
 	let sawInvalidMarker = false;
@@ -5848,32 +7038,136 @@ const extractBalancedJson = (text) => {
 	}
 	return null;
 };
-
 //#endregion
 //#region src/routes/messages/handler.ts
-const logger$5 = createHandlerLogger("messages-handler");
+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;
+	const tokensTotal = usage.inputTokens === void 0 && usage.outputTokens === void 0 ? void 0 : (tokensInput ?? 0) + (usage.outputTokens ?? 0) + (usage.cacheCreationInputTokens ?? 0) + (tokensCachedInput ?? 0);
+	return {
+		tokensCachedInput,
+		tokensInput,
+		tokensOutput: usage.outputTokens,
+		tokensTotal,
+		usageJson: JSON.stringify({
+			input_tokens: usage.inputTokens,
+			output_tokens: usage.outputTokens,
+			cache_creation_input_tokens: usage.cacheCreationInputTokens,
+			cache_read_input_tokens: usage.cacheReadInputTokens
+		})
+	};
+}
+async function handleProviderAliasCompletion(c, options) {
+	const { payload, provider, providerModel } = options;
+	const requestId = randomUUID();
+	const startedAtMs = Date.now();
+	const method = c.req.raw.method;
+	const path = new URL(c.req.url, "http://local").pathname;
+	const { ip: clientIp, source: clientIpSource } = getClientIpInfo(c);
+	const userAgent = c.req.header("user-agent") ?? void 0;
+	const streamRequested = Boolean(payload.stream);
+	const originalModel = payload.model;
+	const rawUserId = payload.metadata?.user_id;
+	const userId = typeof rawUserId === "string" ? rawUserId : void 0;
+	const { safetyIdentifier, sessionId: promptCacheKey } = parseUserIdMetadata(userId);
+	const isSubagent = inspectSubagentMarkerFromFirstUser(payload).kind === "valid";
+	let requestRecorded = false;
+	const insertProviderAliasLog = (record) => {
+		if (requestRecorded) {
+			logger$3.warn("provider alias request already recorded", { requestId });
+			return;
+		}
+		requestRecorded = true;
+		const finishedAtMs = Date.now();
+		getRequestHistoryStore().insert({
+			requestId,
+			startedAtMs,
+			finishedAtMs,
+			durationMs: finishedAtMs - startedAtMs,
+			method,
+			path,
+			clientIp,
+			clientIpSource,
+			userAgent,
+			userId,
+			safetyIdentifier: safetyIdentifier ?? void 0,
+			promptCacheKey: promptCacheKey ?? void 0,
+			isSubagent,
+			clientModel: originalModel,
+			upstreamEndpoint: `/providers/${provider}/messages`,
+			stream: streamRequested,
+			upstreamModel: providerModel,
+			...record
+		});
+	};
+	const instrumentation = {
+		onComplete: (usage) => {
+			insertProviderAliasLog({
+				...normalizeProviderAliasUsage(usage),
+				httpStatus: 200
+			});
+		},
+		onError: (error) => {
+			insertProviderAliasLog({
+				httpStatus: error.httpStatus,
+				errorName: error.errorName,
+				errorStatus: error.errorStatus,
+				errorMessage: error.errorMessage,
+				upstreamErrorMessageRaw: error.upstreamErrorMessageRaw
+			});
+		}
+	};
+	payload.model = providerModel;
+	try {
+		return await handleProviderMessagesForProvider(c, {
+			instrumentation,
+			payload,
+			provider
+		});
+	} catch (error) {
+		const observableError = await extractErrorObservability(error);
+		instrumentation.onError?.(observableError);
+		throw error;
+	}
+}
 async function handleCompletion(c) {
+	const anthropicPayload = await c.req.json();
+	const providerConfigResolver = getProviderConfigResolver(c);
+	const providerTargetModelAlias = resolveExistingProviderModelAlias(anthropicPayload.model, providerConfigResolver) ?? resolveProviderTargetModelAlias(anthropicPayload.model, providerConfigResolver);
+	if (providerTargetModelAlias) return await handleProviderAliasCompletion(c, {
+		payload: anthropicPayload,
+		provider: providerTargetModelAlias.provider,
+		providerModel: providerTargetModelAlias.model
+	});
 	await checkRateLimit(state);
 	const store = getRequestHistoryStore();
 	const requestId = randomUUID();
 	const startedAtMs = Date.now();
 	const method = c.req.raw.method;
-	const path$2 = new URL(c.req.url, "http://local").pathname;
+	const path = new URL(c.req.url, "http://local").pathname;
 	const { ip: clientIp, source: clientIpSource } = getClientIpInfo(c);
 	const userAgent = c.req.header("user-agent") ?? void 0;
-	const anthropicPayload = await c.req.json();
 	sanitizeIdeTools(anthropicPayload);
-	debugJson(logger$5, "Anthropic request payload:", anthropicPayload);
+	debugJson(logger$3, "Anthropic request payload:", anthropicPayload);
 	const markerInspection = inspectSubagentMarkerFromFirstUser(anthropicPayload);
 	const subagentMarker = markerInspection.kind === "valid" ? markerInspection.marker : null;
 	const isSubagentRequest = subagentMarker !== null;
 	const invalidSubagentMarkerSelectionReason = markerInspection.kind === "invalid" ? "subagent_marker_invalid_fallback" : void 0;
-	if (subagentMarker) debugJson(logger$5, "Detected Subagent marker:", subagentMarker);
+	if (subagentMarker) debugJson(logger$3, "Detected Subagent marker:", subagentMarker);
 	const sessionId = getRootSessionId(anthropicPayload, c);
-	logger$5.debug("Extracted session ID:", sessionId);
+	logger$3.debug("Extracted session ID:", sessionId);
 	const ownershipLookupSessionId = markerInspection.kind === "valid" ? normalizeStableSessionId(markerInspection.marker.session_id) : void 0;
 	const ownershipWriteSessionId = markerInspection.kind === "none" ? sessionId : void 0;
 	const anthropicBeta = c.req.header("anthropic-beta");
@@ -5881,14 +7175,14 @@ async function handleCompletion(c) {
 	const isCompact = compactType !== 0;
 	const originalRequestModel = anthropicPayload.model;
 	if (anthropicBeta && isWarmupProbeRequest(anthropicPayload)) anthropicPayload.model = getSmallModel();
-	if (compactType !== 0) logger$5.debug("Compact request type:", compactType);
-	if (compactType === COMPACT_REQUEST && shouldCompactUseSmallModel()) anthropicPayload.model = getSmallModel();
+	if (compactType !== 0) logger$3.debug("Compact request type:", compactType);
+	if (compactType === 1 && shouldCompactUseSmallModel()) anthropicPayload.model = getSmallModel();
 	if (compactType === 0) {
 		stripToolReferenceTurnBoundary(anthropicPayload);
 		mergeToolResultForClaude(anthropicPayload);
 	}
 	const upstreamRequestId = generateRequestIdFromPayload(anthropicPayload, sessionId);
-	logger$5.debug("Generated request ID:", upstreamRequestId);
+	logger$3.debug("Generated request ID:", upstreamRequestId);
 	const clientModel = anthropicPayload.model;
 	const streamRequested = Boolean(anthropicPayload.stream);
 	const rawUserId = anthropicPayload.metadata?.user_id;
@@ -5907,7 +7201,7 @@ async function handleCompletion(c) {
 		requestId,
 		startedAtMs,
 		method,
-		path: path$2,
+		path,
 		streamRequested,
 		clientModel,
 		clientIp,
@@ -5942,11 +7236,13 @@ async function handleCompletion(c) {
 		headerSessionId: c.req.header("x-session-id") ?? null,
 		upstreamRequestId
 	});
+	const responsesItemOwnershipKeys = extractAnthropicResponsesItemOwnerKeys(anthropicPayload);
 	const selection = await accountsManager.selectAccountForRequest(candidates, {
 		requestId: affinityKey.requestId,
 		affinityModelId,
 		ownershipLookupSessionId,
-		ownershipWriteSessionId
+		ownershipWriteSessionId,
+		responsesItemOwnershipKeys
 	});
 	const selectionReason = invalidSubagentMarkerSelectionReason ?? selection.selectionReason;
 	if (!selection.ok) return handleSelectionFailure({
@@ -5955,7 +7251,7 @@ async function handleCompletion(c) {
 		requestId,
 		startedAtMs,
 		method,
-		path: path$2,
+		path,
 		streamRequested,
 		clientModel,
 		clientIp,
@@ -5969,6 +7265,7 @@ async function handleCompletion(c) {
 		affinityKeyUsed: affinityKey.affinityKeyUsed,
 		affinityKeySource: affinityKey.affinityKeySource,
 		selectionReason,
+		responsesItemOwnerLookupKeys: responsesItemOwnershipKeys,
 		selection
 	});
 	const { account, reservation, selectedModel, endpoint, costUnits } = selection;
@@ -5982,7 +7279,7 @@ async function handleCompletion(c) {
 		requestId,
 		startedAtMs,
 		method,
-		path: path$2,
+		path,
 		clientIp,
 		clientIpSource,
 		userAgent,
@@ -6005,7 +7302,8 @@ async function handleCompletion(c) {
 		affinityCacheKey: selection.affinityCacheKey,
 		affinityKeyUsed: affinityKey.affinityKeyUsed,
 		affinityKeySource: affinityKey.affinityKeySource,
-		selectionReason
+		selectionReason,
+		responsesItemOwnerLookupKeys: responsesItemOwnershipKeys
 	};
 	if (endpoint === MESSAGES_ENDPOINT) return await handleWithMessagesApi({
 		c,
@@ -6039,7 +7337,7 @@ async function handleCompletion(c) {
 }
 const handleWithChatCompletions = async (params) => {
 	const { c, openAIPayload, subagentMarker, sessionId, selectedModel, instr, compactType } = params;
-	debugJson(logger$5, "Translated OpenAI request payload:", openAIPayload);
+	debugJson(logger$3, "Translated OpenAI request payload:", openAIPayload);
 	const ctx = toAccountContext(instr.account);
 	const effectiveInitiator = resolveEffectiveInitiator(getChatInitiator(openAIPayload.messages), {
 		isCompact: compactType !== 0,
@@ -6070,9 +7368,9 @@ const handleWithChatCompletions = async (params) => {
 		response,
 		instr
 	});
-	logger$5.debug("Streaming response from Copilot");
+	logger$3.debug("Streaming response from Copilot");
 	const fallbackEnabled = isMessageStartInputTokensFallbackEnabled();
-	const estimatedInputTokens = fallbackEnabled ? await estimateInputTokens(openAIPayload, selectedModel, logger$5) : void 0;
+	const estimatedInputTokens = fallbackEnabled ? await estimateInputTokens(openAIPayload, selectedModel, logger$3) : void 0;
 	const historicalUsage = fallbackEnabled && instr.promptCacheKey && instr.safetyIdentifier ? instr.store.getLastCompletedUsageBySession({
 		promptCacheKey: instr.promptCacheKey,
 		safetyIdentifier: instr.safetyIdentifier,
@@ -6088,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$5, "Translated Responses payload:", 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)
@@ -6108,7 +7410,8 @@ const handleWithResponsesApi = async (params) => {
 			subagentMarker,
 			sessionId,
 			compactType,
-			requestId: instr.requestId
+			requestId: instr.requestId,
+			transport
 		}, ctx);
 		instr.confirmAffinity?.();
 		instr.confirmOwnership?.();
@@ -6119,10 +7422,10 @@ const handleWithResponsesApi = async (params) => {
 			stream: Boolean(responsesPayload.stream)
 		});
 	}
-	if (responsesPayload.stream && isAsyncIterable$1(response)) {
-		logger$5.debug("Streaming response from Copilot (Responses API)");
+	if (responsesPayload.stream && isAsyncIterable(response)) {
+		logger$3.debug("Streaming response from Copilot (Responses API)");
 		const fallbackEnabled = isMessageStartInputTokensFallbackEnabled();
-		const estimatedInputTokens = fallbackEnabled ? await estimateInputTokens(openAIPayload, selectedModel, logger$5) : void 0;
+		const estimatedInputTokens = fallbackEnabled ? await estimateInputTokens(openAIPayload, selectedModel, logger$3) : void 0;
 		const historicalUsage = fallbackEnabled && instr.promptCacheKey && instr.safetyIdentifier ? instr.store.getLastCompletedUsageBySession({
 			promptCacheKey: instr.promptCacheKey,
 			safetyIdentifier: instr.safetyIdentifier,
@@ -6142,13 +7445,16 @@ const handleWithResponsesApi = async (params) => {
 		instr
 	});
 };
+function stringifyOwnerKeys(keys) {
+	return keys && keys.length > 0 ? JSON.stringify(keys) : void 0;
+}
 function insertRequestLog$1(instr, record) {
-	const { store, requestId, startedAtMs, method, path: path$2, clientIp, clientIpSource, userAgent, clientModel, account, upstreamEndpoint, upstreamModel, costUnits, premiumRemainingBefore, premiumUnlimitedBefore } = instr;
+	const { store, requestId, startedAtMs, method, path, clientIp, clientIpSource, userAgent, clientModel, account, upstreamEndpoint, upstreamModel, costUnits, premiumRemainingBefore, premiumUnlimitedBefore } = instr;
 	store.insert({
 		requestId,
 		startedAtMs,
 		method,
-		path: path$2,
+		path,
 		clientIp,
 		clientIpSource,
 		userAgent,
@@ -6171,7 +7477,9 @@ function insertRequestLog$1(instr, record) {
 		upstreamModel,
 		premiumRemainingBefore,
 		premiumUnlimitedBefore,
-		...record
+		...record,
+		responsesItemOwnerLookupKeysJson: stringifyOwnerKeys(instr.responsesItemOwnerLookupKeys),
+		responsesItemOwnerRecordedKeysJson: stringifyOwnerKeys(instr.responsesItemOwnerRecordedKeys)
 	});
 	flushPendingCapture(requestId);
 }
@@ -6215,9 +7523,9 @@ async function handleChatCompletionsNonStreaming(params) {
 	let upstreamErrorMessageRaw;
 	const finishedAtMs = Date.now();
 	try {
-		logger$5.debug("Non-streaming response from Copilot:", JSON.stringify(response));
+		logger$3.debug("Non-streaming response from Copilot:", JSON.stringify(response));
 		const anthropicResponse = translateToAnthropic(response);
-		debugJson(logger$5, "Translated Anthropic response:", anthropicResponse);
+		debugJson(logger$3, "Translated Anthropic response:", anthropicResponse);
 		return c.json(anthropicResponse);
 	} catch (error) {
 		const details = await extractErrorObservability(error);
@@ -6268,16 +7576,16 @@ async function streamChatCompletionsAndLog(params) {
 	try {
 		for await (const rawEvent of response) {
 			if (ttfbMs === void 0) ttfbMs = Date.now() - instr.startedAtMs;
-			logger$5.debug("Copilot raw stream event:", JSON.stringify(rawEvent));
+			logger$3.debug("Copilot raw stream event:", JSON.stringify(rawEvent));
 			const { data: rawData } = rawEvent;
 			const data = typeof rawData === "string" ? rawData : await rawData;
 			if (data === "[DONE]") break;
 			if (!data) continue;
 			const chunk = JSON.parse(data);
 			if (chunk.usage) lastUsage = normalizeChatCompletionsUsage(chunk.usage);
-			const events$1 = translateChunkToAnthropicEvents(chunk, streamState);
-			for (const event of events$1) {
-				logger$5.debug("Translated Anthropic event:", JSON.stringify(event));
+			const events = translateChunkToAnthropicEvents(chunk, streamState);
+			for (const event of events) {
+				logger$3.debug("Translated Anthropic event:", JSON.stringify(event));
 				await stream.writeSSE({
 					event: event.type,
 					data: JSON.stringify(event)
@@ -6290,7 +7598,7 @@ async function streamChatCompletionsAndLog(params) {
 		errorStatus = details.errorStatus;
 		errorMessage = details.errorMessage;
 		upstreamErrorMessageRaw = details.upstreamErrorMessageRaw;
-		logger$5.warn("Streaming error:", error);
+		logger$3.warn("Streaming error:", error);
 		if (shouldMarkAccountFailed(details)) accountsManager.markAccountFailed(instr.account.id, "Unauthorized (401)");
 		await writeAnthropicStreamError(stream, getUserVisibleErrorMessage(details));
 	} finally {
@@ -6349,10 +7657,14 @@ async function handleResponsesNonStreaming(params) {
 	const finishedAtMs = Date.now();
 	try {
 		usage = extractResponsesUsageFromResult(result);
-		logger$5.debug("Non-streaming Responses result:", JSON.stringify(result).slice(-400));
+		const responseOwnerKeys = extractResponsesResultOwnerKeys(result);
+		instr.responsesItemOwnerRecordedKeys = responseOwnerKeys;
+		logger$3.debug("Non-streaming Responses result:", JSON.stringify(result).slice(-400));
 		const anthropicResponse = translateResponsesResultToAnthropic(result);
-		debugJson(logger$5, "Translated Anthropic response:", anthropicResponse);
-		return c.json(anthropicResponse);
+		debugJson(logger$3, "Translated Anthropic response:", anthropicResponse);
+		const response = c.json(anthropicResponse);
+		if (result.status === "completed") accountsManager.recordResponsesItemOwnership(responseOwnerKeys, instr.account.id);
+		return response;
 	} catch (error) {
 		const details = await extractErrorObservability(error);
 		httpStatus = details.httpStatus;
@@ -6383,7 +7695,7 @@ async function handleResponsesNonStreaming(params) {
 async function ensureResponsesStreamCompleted(params) {
 	const { stream, streamState, setStreamError } = params;
 	if (streamState.messageCompleted) return;
-	logger$5.warn("Responses stream ended without completion; sending error event");
+	logger$3.warn("Responses stream ended without completion; sending error event");
 	const msg = "Responses stream ended without completion";
 	const errorEvent = buildErrorEvent(msg);
 	setStreamError("StreamIncomplete", msg);
@@ -6400,22 +7712,66 @@ async function writeAnthropicStreamError(stream, message) {
 			data: JSON.stringify(errorEvent)
 		});
 	} catch (streamError) {
-		logger$5.warn("Failed to write Anthropic stream error event:", streamError);
+		logger$3.warn("Failed to write Anthropic stream error event:", streamError);
+	}
+}
+function collectResponsesStreamOwnerKeys(event, responseOwnerKeys) {
+	for (const key of extractResponsesStreamEventOwnerKeys(event)) responseOwnerKeys.add(key);
+}
+function createResponsesStreamStateWithUsage(params) {
+	const streamState = createResponsesStreamState();
+	streamState.estimatedInputTokens = params.estimatedInputTokens;
+	streamState.historicalInputTokens = params.historicalUsage?.tokensInput;
+	streamState.historicalOutputTokens = params.historicalUsage?.tokensOutput;
+	streamState.historicalCachedInputTokens = params.historicalUsage?.tokensCachedInput;
+	return streamState;
+}
+function recordStreamOwnerKeys(streamState, responseOwnerKeys, instr) {
+	if (!streamState.messageCompleted) return;
+	const ownerKeys = [...responseOwnerKeys];
+	instr.responsesItemOwnerRecordedKeys = ownerKeys;
+	if (streamState.responseStatus === "completed") accountsManager.recordResponsesItemOwnership(ownerKeys, instr.account.id);
+}
+function getResponsesStreamEventError(event) {
+	if (event.type === "response.failed") {
+		const message = event.response.error?.message ?? "Responses stream failed upstream.";
+		return {
+			errorName: "ResponsesStreamFailed",
+			errorStatus: 502,
+			errorMessage: message,
+			upstreamErrorMessageRaw: message
+		};
+	}
+	if (event.type === "error") {
+		const message = event.message || "Responses stream returned an error.";
+		return {
+			errorName: "ResponsesStreamError",
+			errorStatus: 502,
+			errorMessage: message,
+			upstreamErrorMessageRaw: message
+		};
+	}
+}
+async function writeTranslatedAnthropicStreamEvents(stream, events) {
+	for (const event of events) {
+		const eventData = JSON.stringify(event);
+		logger$3.debug("Translated Anthropic event:", eventData);
+		await stream.writeSSE({
+			event: event.type,
+			data: eventData
+		});
 	}
 }
 async function streamResponsesAndLog$1(params) {
-	const { stream, response, instr, estimatedInputTokens, historicalUsage } = params;
+	const { stream, response, instr } = params;
 	let ttfbMs;
 	let lastUsage = {};
 	let errorName;
 	let errorStatus;
 	let errorMessage;
 	let upstreamErrorMessageRaw;
-	const streamState = createResponsesStreamState();
-	streamState.estimatedInputTokens = estimatedInputTokens;
-	streamState.historicalInputTokens = historicalUsage?.tokensInput;
-	streamState.historicalOutputTokens = historicalUsage?.tokensOutput;
-	streamState.historicalCachedInputTokens = historicalUsage?.tokensCachedInput;
+	const streamState = createResponsesStreamStateWithUsage(params);
+	const responseOwnerKeys = /* @__PURE__ */ new Set();
 	try {
 		for await (const chunk of response) {
 			if (ttfbMs === void 0) ttfbMs = Date.now() - instr.startedAtMs;
@@ -6428,21 +7784,21 @@ async function streamResponsesAndLog$1(params) {
 			}
 			const data = chunk.data;
 			if (!data) continue;
-			logger$5.debug("Responses raw stream event:", data);
+			logger$3.debug("Responses raw stream event:", data);
 			const parsed = JSON.parse(data);
+			const streamEventError = getResponsesStreamEventError(parsed);
+			if (streamEventError) {
+				errorName = streamEventError.errorName;
+				errorStatus = streamEventError.errorStatus;
+				errorMessage = streamEventError.errorMessage;
+				upstreamErrorMessageRaw = streamEventError.upstreamErrorMessageRaw;
+			}
+			collectResponsesStreamOwnerKeys(parsed, responseOwnerKeys);
 			const u = extractResponsesUsageFromStreamEvent(parsed);
 			if (u.usageJson) lastUsage = u;
-			const events$1 = translateResponsesStreamEvent(parsed, streamState);
-			for (const event of events$1) {
-				const eventData = JSON.stringify(event);
-				logger$5.debug("Translated Anthropic event:", eventData);
-				await stream.writeSSE({
-					event: event.type,
-					data: eventData
-				});
-			}
+			await writeTranslatedAnthropicStreamEvents(stream, translateResponsesStreamEvent(parsed, streamState));
 			if (streamState.messageCompleted) {
-				logger$5.debug("Message completed, ending stream");
+				logger$3.debug("Message completed, ending stream");
 				break;
 			}
 		}
@@ -6454,13 +7810,14 @@ async function streamResponsesAndLog$1(params) {
 				errorMessage = message;
 			}
 		});
+		recordStreamOwnerKeys(streamState, responseOwnerKeys, instr);
 	} catch (error) {
 		const details = await extractErrorObservability(error);
 		errorName = details.errorName;
 		errorStatus = details.errorStatus;
 		errorMessage = details.errorMessage;
 		upstreamErrorMessageRaw = details.upstreamErrorMessageRaw;
-		logger$5.warn("Streaming error:", error);
+		logger$3.warn("Streaming error:", error);
 		invalidateAffinityOnOwnershipMismatch(details.ownershipMismatch, instr);
 		if (shouldMarkAccountFailed(details)) accountsManager.markAccountFailed(instr.account.id, "Unauthorized (401)");
 		await writeAnthropicStreamError(stream, getUserVisibleErrorMessage(details));
@@ -6515,7 +7872,7 @@ async function handleMessagesNonStreaming(params) {
 	let upstreamErrorMessageRaw;
 	const finishedAtMs = Date.now();
 	try {
-		logger$5.debug("Non-streaming Messages result:", JSON.stringify(response).slice(-400));
+		logger$3.debug("Non-streaming Messages result:", JSON.stringify(response).slice(-400));
 		return c.json(response);
 	} catch (error) {
 		const details = await extractErrorObservability(error);
@@ -6545,14 +7902,15 @@ async function handleMessagesNonStreaming(params) {
 	}
 }
 const parseMessagesStreamUsage = (data) => {
-	if (!data) return null;
+	if (!data || data === "[DONE]") return null;
 	try {
 		const parsed = JSON.parse(data);
+		if (parsed.type === "error") throw new Error(parsed.error.message);
 		if (parsed.type !== "message_delta" || !parsed.usage) return null;
 		return normalizeMessagesUsage(parsed.usage);
 	} catch (error) {
-		logger$5.warn("Failed to parse messages stream event", error);
-		return null;
+		logger$3.warn("Failed to parse messages stream event", error);
+		throw new Error("Failed to parse messages stream event", { cause: error });
 	}
 };
 async function streamMessagesAndLog(params) {
@@ -6569,7 +7927,7 @@ async function streamMessagesAndLog(params) {
 			const eventNameRaw = rawEvent.event;
 			const eventName = typeof eventNameRaw === "string" && eventNameRaw.length > 0 ? eventNameRaw : "message";
 			const data = rawEvent.data ?? "";
-			logger$5.debug("Messages raw stream event:", data);
+			logger$3.debug("Messages raw stream event:", data);
 			const usage = parseMessagesStreamUsage(data);
 			if (usage) lastUsage = usage;
 			await stream.writeSSE({
@@ -6583,7 +7941,7 @@ async function streamMessagesAndLog(params) {
 		errorStatus = details.errorStatus;
 		errorMessage = details.errorMessage;
 		upstreamErrorMessageRaw = details.upstreamErrorMessageRaw;
-		logger$5.warn("Streaming error:", error);
+		logger$3.warn("Streaming error:", error);
 		if (shouldMarkAccountFailed(details)) accountsManager.markAccountFailed(instr.account.id, "Unauthorized (401)");
 		await writeAnthropicStreamError(stream, getUserVisibleErrorMessage(details));
 	} finally {
@@ -6609,7 +7967,7 @@ async function streamMessagesAndLog(params) {
 const handleWithMessagesApi = async (params) => {
 	const { c, anthropicPayload, anthropicBetaHeader, subagentMarker, sessionId, instr, selectedModel, compactType } = params;
 	prepareMessagesApiPayload(anthropicPayload, selectedModel);
-	debugJson(logger$5, "Translated Messages payload:", anthropicPayload);
+	debugJson(logger$3, "Translated Messages payload:", anthropicPayload);
 	const ctx = toAccountContext(instr.account);
 	const effectiveInitiator = resolveEffectiveInitiator(getMessagesInitiator(anthropicPayload), {
 		isCompact: compactType !== 0,
@@ -6636,8 +7994,8 @@ const handleWithMessagesApi = async (params) => {
 			stream: Boolean(anthropicPayload.stream)
 		});
 	}
-	if (isAsyncIterable$1(response)) {
-		logger$5.debug("Streaming response from Copilot (Messages API)");
+	if (isAsyncIterable(response)) {
+		logger$3.debug("Streaming response from Copilot (Messages API)");
 		return streamSSE(c, (stream) => streamMessagesAndLog({
 			stream,
 			response,
@@ -6651,8 +8009,7 @@ const handleWithMessagesApi = async (params) => {
 	});
 };
 const isNonStreaming = (response) => Object.hasOwn(response, "choices");
-const isAsyncIterable$1 = (value) => Boolean(value) && typeof value[Symbol.asyncIterator] === "function";
-
+const isAsyncIterable = (value) => Boolean(value) && typeof value[Symbol.asyncIterator] === "function";
 //#endregion
 //#region src/routes/messages/route.ts
 const messageRoutes = new Hono();
@@ -6670,22 +8027,23 @@ messageRoutes.post("/count_tokens", async (c) => {
 		return await forwardError(c, error);
 	}
 });
-
 //#endregion
 //#region src/routes/models/route.ts
 const modelRoutes = new Hono();
 modelRoutes.get("/", async (c) => {
 	try {
 		const blockedTargets = getAliasTargetSet();
-		const models = getAvailableModels().filter((model) => !blockedTargets.has(model.id.toLowerCase())).map((model) => ({
-			id: model.id,
-			object: "model",
-			type: "model",
-			created: 0,
-			created_at: (/* @__PURE__ */ new Date(0)).toISOString(),
-			owned_by: model.vendor,
-			display_name: model.name
-		}));
+		const models = getAvailableModels().filter((model) => !blockedTargets.has(model.id.toLowerCase())).map((model) => {
+			return {
+				id: model.capabilities.limits?.max_context_window_tokens === 1e6 ? `${model.id}[1m]` : model.id,
+				object: "model",
+				type: "model",
+				created: 0,
+				created_at: (/* @__PURE__ */ new Date(0)).toISOString(),
+				owned_by: model.vendor,
+				display_name: model.name
+			};
+		});
 		const aliasModels = Object.keys(getModelAliases()).map((alias) => ({
 			id: alias,
 			object: "model",
@@ -6707,195 +8065,6 @@ modelRoutes.get("/", async (c) => {
 		return await forwardError(c, error);
 	}
 });
-
-//#endregion
-//#region src/routes/provider/messages/count-tokens-handler.ts
-const logger$4 = createHandlerLogger("provider-count-tokens-handler");
-const createFallbackModel = (modelId) => ({
-	capabilities: {
-		family: "provider",
-		limits: {},
-		object: "model_capabilities",
-		supports: {},
-		tokenizer: "o200k_base",
-		type: "chat"
-	},
-	id: modelId,
-	model_picker_enabled: false,
-	name: modelId,
-	object: "model",
-	preview: false,
-	vendor: "provider",
-	version: "unknown"
-});
-async function handleProviderCountTokens(c) {
-	const provider = c.req.param("provider");
-	try {
-		const anthropicPayload = await c.req.json();
-		const openAIPayload = translateToOpenAI(anthropicPayload);
-		const modelId = anthropicPayload.model.trim();
-		let selectedModel = getAvailableModels().find((model) => model.id === modelId);
-		if (!selectedModel && modelId) selectedModel = createFallbackModel(modelId);
-		if (!selectedModel) {
-			logger$4.warn("provider.count_tokens.model_not_found", {
-				provider,
-				model: anthropicPayload.model
-			});
-			return c.json({ input_tokens: 1 });
-		}
-		const tokenCount = await getTokenCount(openAIPayload, selectedModel);
-		const finalTokenCount = tokenCount.input + tokenCount.output;
-		logger$4.debug("provider.count_tokens.success", {
-			provider,
-			model: anthropicPayload.model,
-			input_tokens: finalTokenCount
-		});
-		return c.json({ input_tokens: finalTokenCount });
-	} catch (error) {
-		logger$4.error("provider.count_tokens.error", {
-			provider,
-			error
-		});
-		return c.json({ input_tokens: 1 });
-	}
-}
-
-//#endregion
-//#region src/services/providers/anthropic-proxy.ts
-const FORWARDABLE_HEADERS = [
-	"anthropic-version",
-	"anthropic-beta",
-	"accept",
-	"user-agent"
-];
-const STRIPPED_RESPONSE_HEADERS = [
-	"connection",
-	"content-encoding",
-	"content-length",
-	"keep-alive",
-	"proxy-authenticate",
-	"proxy-authorization",
-	"te",
-	"trailer",
-	"transfer-encoding",
-	"upgrade"
-];
-function buildProviderUpstreamHeaders(providerConfig, requestHeaders) {
-	const authHeaders = {};
-	if (providerConfig.authType === "authorization") authHeaders.authorization = `Bearer ${providerConfig.apiKey}`;
-	else authHeaders["x-api-key"] = providerConfig.apiKey;
-	const headers = {
-		"content-type": "application/json",
-		accept: "application/json",
-		...authHeaders
-	};
-	for (const headerName of FORWARDABLE_HEADERS) {
-		const headerValue = requestHeaders.get(headerName);
-		if (headerValue) headers[headerName] = headerValue;
-	}
-	return headers;
-}
-function createProviderProxyResponse(upstreamResponse) {
-	const headers = new Headers(upstreamResponse.headers);
-	for (const headerName of STRIPPED_RESPONSE_HEADERS) headers.delete(headerName);
-	return new Response(upstreamResponse.body, {
-		headers,
-		status: upstreamResponse.status,
-		statusText: upstreamResponse.statusText
-	});
-}
-async function forwardProviderMessages(providerConfig, payload, requestHeaders) {
-	return await fetch(`${providerConfig.baseUrl}/v1/messages`, {
-		method: "POST",
-		headers: buildProviderUpstreamHeaders(providerConfig, requestHeaders),
-		body: JSON.stringify(payload)
-	});
-}
-async function forwardProviderModels(providerConfig, requestHeaders) {
-	return await fetch(`${providerConfig.baseUrl}/v1/models`, {
-		method: "GET",
-		headers: buildProviderUpstreamHeaders(providerConfig, requestHeaders)
-	});
-}
-
-//#endregion
-//#region src/routes/provider/messages/handler.ts
-const logger$3 = createHandlerLogger("provider-messages-handler");
-async function handleProviderMessages(c) {
-	const provider = c.req.param("provider") ?? "";
-	const providerConfig = getProviderConfig(provider);
-	if (!providerConfig) return c.json({ error: {
-		message: `Provider '${provider}' not found or disabled`,
-		type: "invalid_request_error"
-	} }, 404);
-	try {
-		const payload = await c.req.json();
-		const modelConfig = providerConfig.models?.[payload.model];
-		payload.temperature ??= modelConfig?.temperature;
-		payload.top_p ??= modelConfig?.topP;
-		payload.top_k ??= modelConfig?.topK;
-		debugJson(logger$3, "provider.messages.request", {
-			payload,
-			provider
-		});
-		const upstreamResponse = await forwardProviderMessages(providerConfig, payload, c.req.raw.headers);
-		if (!upstreamResponse.ok) {
-			logger$3.error("Failed to create responses", upstreamResponse);
-			throw new HTTPError("Failed to create responses", upstreamResponse);
-		}
-		const contentType = upstreamResponse.headers.get("content-type") ?? "";
-		if (Boolean(payload.stream) && contentType.includes("text/event-stream")) {
-			logger$3.debug("provider.messages.streaming");
-			return streamSSE(c, async (stream) => {
-				for await (const chunk of events(upstreamResponse)) {
-					logger$3.debug("provider.messages.raw_stream_event:", chunk.data);
-					const eventName = chunk.event;
-					if (eventName === "ping") {
-						await stream.writeSSE({
-							event: "ping",
-							data: "{\"type\":\"ping\"}"
-						});
-						continue;
-					}
-					let data = chunk.data;
-					if (!data) continue;
-					if (chunk.data === "[DONE]") break;
-					try {
-						const parsed = JSON.parse(data);
-						if (parsed.type === "message_start") adjustInputTokens(providerConfig, parsed.message.usage);
-						else if (parsed.type === "message_delta") adjustInputTokens(providerConfig, parsed.usage);
-						data = JSON.stringify(parsed);
-					} catch (error) {
-						logger$3.error("provider.messages.streaming.adjust_tokens_error", {
-							error,
-							originalData: data
-						});
-					}
-					await stream.writeSSE({
-						event: eventName,
-						data
-					});
-				}
-			});
-		}
-		const jsonBody = await upstreamResponse.json();
-		adjustInputTokens(providerConfig, jsonBody.usage);
-		debugJson(logger$3, "provider.messages.no_stream result:", jsonBody);
-		return c.json(jsonBody);
-	} catch (error) {
-		logger$3.error("provider.messages.error", {
-			provider,
-			error
-		});
-		throw error;
-	}
-}
-const adjustInputTokens = (providerConfig, usage) => {
-	if (!providerConfig.adjustInputTokens || !usage) return;
-	usage.input_tokens = Math.max(0, (usage.input_tokens ?? 0) - (usage.cache_read_input_tokens ?? 0) - (usage.cache_creation_input_tokens ?? 0));
-	debugJson(logger$3, "provider.messages.adjusted_usage:", usage);
-};
-
 //#endregion
 //#region src/routes/provider/messages/route.ts
 const providerMessageRoutes = new Hono();
@@ -6913,20 +8082,23 @@ providerMessageRoutes.post("/count_tokens", async (c) => {
 		return await forwardError(c, error);
 	}
 });
-
 //#endregion
 //#region src/routes/provider/models/route.ts
 const logger$2 = createHandlerLogger("provider-models-handler");
+const getProviderFetch = (c) => c.get("providerFetch") ?? fetch;
+const resolveProviderConfig = (c, provider) => {
+	return (c.get("providerConfigResolver") ?? getProviderConfig)(provider);
+};
 const providerModelRoutes = new Hono();
 providerModelRoutes.get("/", async (c) => {
 	const provider = c.req.param("provider") ?? "";
 	try {
-		const providerConfig = getProviderConfig(provider);
+		const providerConfig = resolveProviderConfig(c, provider);
 		if (!providerConfig) return c.json({ error: {
 			message: `Provider '${provider}' not found or disabled`,
 			type: "invalid_request_error"
 		} }, 404);
-		const upstreamResponse = await forwardProviderModels(providerConfig, c.req.raw.headers);
+		const upstreamResponse = await forwardProviderModels(providerConfig, c.req.raw.headers, getProviderFetch(c));
 		logger$2.debug("provider.models.response", {
 			provider,
 			statusCode: upstreamResponse.status
@@ -6940,7 +8112,6 @@ providerModelRoutes.get("/", async (c) => {
 		return await forwardError(c, error);
 	}
 });
-
 //#endregion
 //#region src/routes/responses/stream-id-sync.ts
 const createStreamIdTracker = () => ({ outputItems: /* @__PURE__ */ new Map() });
@@ -6977,7 +8148,6 @@ const handleItemId = (parsed, tracker) => {
 	}
 	return JSON.stringify(parsed);
 };
-
 //#endregion
 //#region src/routes/responses/handler.ts
 const logger$1 = createHandlerLogger("responses-handler");
@@ -7051,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();
@@ -7069,7 +8240,8 @@ const handleResponses = async (c) => {
 		vision,
 		initiator,
 		premiumRemainingBefore,
-		premiumUnlimitedBefore
+		premiumUnlimitedBefore,
+		transport
 	});
 	return handleNonStreamingResponses({
 		c,
@@ -7082,7 +8254,8 @@ const handleResponses = async (c) => {
 		vision,
 		initiator,
 		premiumRemainingBefore,
-		premiumUnlimitedBefore
+		premiumUnlimitedBefore,
+		transport
 	});
 };
 async function observeRequestError(accountId, error, affinity) {
@@ -7121,13 +8294,13 @@ function buildRequestContext(c) {
 	const requestId = randomUUID();
 	const startedAtMs = Date.now();
 	const method = c.req.raw.method;
-	const path$2 = new URL(c.req.url, "http://local").pathname;
+	const path = new URL(c.req.url, "http://local").pathname;
 	const { ip: clientIp, source: clientIpSource } = getClientIpInfo(c);
 	return {
 		requestId,
 		startedAtMs,
 		method,
-		path: path$2,
+		path,
 		clientIp,
 		clientIpSource,
 		userAgent: c.req.header("user-agent") ?? void 0
@@ -7190,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, {
@@ -7198,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) {
@@ -7212,7 +8386,7 @@ async function handleStreamingResponses(params) {
 			error
 		});
 	}
-	if (isAsyncIterable(response)) {
+	if (isAsyncIterable$1(response)) {
 		logger$1.debug("Forwarding native Responses stream");
 		return streamSSE(c, (stream) => streamResponsesAndLog({
 			stream,
@@ -7386,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 };
@@ -7397,9 +8571,10 @@ async function handleNonStreamingResponses(params) {
 			initiator,
 			upstreamRequestId: request.upstreamRequestId,
 			sessionId: request.upstreamSessionId,
-			requestId: request.requestId
+			requestId: request.requestId,
+			transport
 		}, accountCtx);
-		if (isAsyncIterable(response)) throw new Error("Upstream returned a stream unexpectedly");
+		if (isAsyncIterable$1(response)) throw new Error("Upstream returned a stream unexpectedly");
 		selection.confirmAffinity?.();
 		finishedAtMs = Date.now();
 		const result = response;
@@ -7459,7 +8634,6 @@ const removeUnsupportedTools = (payload) => {
 	});
 	if (dropped.length > 0) logger$1.debug("Removed unsupported tools:", dropped);
 };
-
 //#endregion
 //#region src/routes/responses/route.ts
 const responsesRoutes = new Hono();
@@ -7470,7 +8644,6 @@ responsesRoutes.post("/", async (c) => {
 		return await forwardError(c, error);
 	}
 });
-
 //#endregion
 //#region src/routes/token/route.ts
 const tokenRoute = new Hono();
@@ -7485,7 +8658,6 @@ tokenRoute.get("/", (c) => {
 		}, 500);
 	}
 });
-
 //#endregion
 //#region src/routes/usage/route.ts
 const usageRoute = new Hono();
@@ -7522,7 +8694,6 @@ usageRoute.get("/:accountIndex", async (c) => {
 		return c.json({ error: "Failed to fetch account usage" }, 500);
 	}
 });
-
 //#endregion
 //#region src/server.ts
 const server = new Hono();
@@ -7549,7 +8720,7 @@ server.route("/v1/responses", responsesRoutes);
 server.route("/v1/messages", messageRoutes);
 server.route("/:provider/v1/messages", providerMessageRoutes);
 server.route("/:provider/v1/models", providerModelRoutes);
-
 //#endregion
 export { server };
-//# sourceMappingURL=server-DR9ZR_MN.js.map
+
+//# sourceMappingURL=server-DxQsi1x2.js.map