@jeffreycao/copilot-api 1.10.9 → 1.10.10

package/dist/{server-FPXzFkg9.js → server-D5O9IzAY.js}

@@ -1,20 +1,18 @@
-import { t as PATHS } from "./paths-DC-mqCY3.js";
-import { D as generateTraceId, E as prepareMessageProxyHeaders, I as state, M as compactMessageSections, O as requestContext, P as compactSystemPromptStarts, T as prepareInteractionHeaders, _ as copilotWebSocketHeaders, c as getUUID, d as sleep, f as getCopilotUsage, g as copilotHeaders, h as copilotBaseUrl, j as compactAutoContinuePromptStarts, k as resolveTraceId$1, l as isNullish, m as forwardError, n as cacheModels, o as generateRequestIdFromPayload, p as HTTPError, s as getRootSessionId, u as parseUserIdMetadata, w as prepareForCompact } from "./utils-jHLgqAq2.js";
-import { a as isDeferredToolName, c as parseMcpToolSearchSentinel, d as shouldEnableResponsesToolSearch, i as isBridgeToolSearchName, l as resolveBridgeToolSearchName, o as listDeferredToolNames, r as formatToolSearchBridgeArguments, s as normalizeToolSearchBridgeArguments, t as BRIDGE_TOOL_SEARCH_NAME, u as selectDeferredToolsByNames } from "./tool-search-D3SN0jX-.js";
-import { _ as setModelMappings, a as getConfig, c as getProviderConfig, d as isMessagesApiEnabled, f as isResponsesApiContextManagementModel, g as resolveMappedModel, i as getClaudeTokenMultiplier, l as getReasoningEffortForModel, m as isResponsesApiWebSocketEnabled, o as getExtraPromptForModel, p as isResponsesApiWebSearchEnabled, r as getAnthropicApiKey, s as getModelMappings, t as getProxyEnvDispatcher, u as getSmallModel } from "./proxy-DvlF9a-7.js";
+import { A as compactSystemPromptStarts, B as createWebSocketUrl, C as prepareForCompact, D as compactAutoContinuePromptStarts, F as normalizeCodexResponsesEvent, H as state, I as generateTraceId, L as requestContext, N as createStandardizedCodexResponsesEventStream, O as compactMessageSections, P as forwardCodexResponses, R as resolveTraceId$1, S as copilotWebSocketHeaders, T as prepareMessageProxyHeaders, U as logCodexRateLimitsEvent, _ as getCopilotUsage, b as copilotBaseUrl, d as generateRequestIdFromPayload, f as getRootSessionId, g as sleep, h as parseUserIdMetadata, m as isNullish, p as getUUID, r as setupCodexToken, s as cacheModels, v as HTTPError, w as prepareInteractionHeaders, x as copilotHeaders, y as forwardError, z as createPooledWebSocketStream } from "./token-1SfgxCRm.js";
+import { _ as setModelMappings, a as getModelMappings, c as getReasoningEffortForModel, d as isResponsesApiContextManagementModel, f as isResponsesApiWebSearchEnabled, g as resolveMappedModel, i as getExtraPromptForModel, l as getSmallModel, n as getClaudeTokenMultiplier, o as getProviderConfig, p as isResponsesApiWebSocketEnabled, r as getConfig, s as getRawProviderConfig, t as getAnthropicApiKey, u as isMessagesApiEnabled, y as PATHS } from "./config-ztdkLu9o.js";
+import { a as isDeferredToolName, c as parseMcpToolSearchSentinel, d as shouldEnableResponsesToolSearch, i as isBridgeToolSearchName, l as resolveBridgeToolSearchName, o as listDeferredToolNames, r as formatToolSearchBridgeArguments, s as normalizeToolSearchBridgeArguments, t as BRIDGE_TOOL_SEARCH_NAME, u as selectDeferredToolsByNames } from "./tool-search-wA-fLduL.js";
 import consola from "consola";
-import fs from "node:fs/promises";
-import path from "node:path";
 import { createHash } from "node:crypto";
+import fs, { readFileSync } from "node:fs";
+import fs$1 from "node:fs/promises";
+import path from "node:path";
 import { z } from "zod";
 import { Hono } from "hono";
 import { cors } from "hono/cors";
 import { logger } from "hono/logger";
-import fs$1, { readFileSync } from "node:fs";
 import { streamSSE } from "hono/streaming";
 import util from "node:util";
 import { events } from "fetch-event-stream";
-import { WebSocket } from "undici";
 //#region src/lib/request-auth.ts
 function normalizeApiKeys(apiKeys) {
 	if (!Array.isArray(apiKeys)) {
@@ -78,7 +76,7 @@ const traceIdMiddleware = async (c, next) => {
 		traceId,
 		startTime: Date.now(),
 		userAgent: c.req.header("user-agent") || "",
-		sessionAffinity: c.req.header("x-session-affinity"),
+		sessionAffinity: c.req.header("x-session-affinity") ?? c.req.header("x-client-request-id"),
 		parentSessionId: c.req.header("x-parent-session-id")
 	};
 	await requestContext.run(context, async () => {
@@ -154,22 +152,22 @@ let runtimeInitialized = false;
 let flushInterval;
 let cleanupInterval;
 const ensureLogDirectory = () => {
-	if (!fs$1.existsSync(LOG_DIR)) fs$1.mkdirSync(LOG_DIR, { recursive: true });
+	if (!fs.existsSync(LOG_DIR)) fs.mkdirSync(LOG_DIR, { recursive: true });
 };
 const cleanupOldLogs = () => {
-	if (!fs$1.existsSync(LOG_DIR)) return;
+	if (!fs.existsSync(LOG_DIR)) return;
 	const now = Date.now();
-	for (const entry of fs$1.readdirSync(LOG_DIR)) {
+	for (const entry of fs.readdirSync(LOG_DIR)) {
 		const filePath = path.join(LOG_DIR, entry);
 		let stats;
 		try {
-			stats = fs$1.statSync(filePath);
+			stats = fs.statSync(filePath);
 		} catch {
 			continue;
 		}
 		if (!stats.isFile()) continue;
 		if (now - stats.mtimeMs > LOG_RETENTION_MS) try {
-			fs$1.rmSync(filePath);
+			fs.rmSync(filePath);
 		} catch {
 			continue;
 		}
@@ -228,7 +226,7 @@ const getLogStream = (filePath) => {
 	initializeLoggerRuntime();
 	let stream = logStreams.get(filePath);
 	if (!stream || stream.destroyed) {
-		stream = fs$1.createWriteStream(filePath, { flags: "a" });
+		stream = fs.createWriteStream(filePath, { flags: "a" });
 		logStreams.set(filePath, stream);
 		stream.on("error", (error) => {
 			console.warn("Log stream error", error);
@@ -373,7 +371,7 @@ async function openNodeDatabase(dbPath) {
 }
 async function openSqliteDatabase(dbPath) {
 	const dir = path.dirname(dbPath);
-	if (dbPath !== ":memory:" && dir !== ".") await fs.mkdir(dir, { recursive: true });
+	if (dbPath !== ":memory:" && dir !== ".") await fs$1.mkdir(dir, { recursive: true });
 	return isBunRuntime() ? openBunDatabase(dbPath) : openNodeDatabase(dbPath);
 }
 var SqliteDbStore = class {
@@ -1402,6 +1400,31 @@ const getTokenCount = async (payload, model) => {
 	};
 };
 //#endregion
+//#region src/lib/provider-resolver.ts
+function isMissingCodexCredentialsError(error) {
+	return error instanceof Error && error.message === "Codex credentials not found. Run `copilot-api auth login --provider codex` first.";
+}
+async function resolveProviderConfig(providerName) {
+	const normalizedProviderName = providerName.trim();
+	if (!normalizedProviderName) return null;
+	if (normalizedProviderName === "codex") {
+		if (getRawProviderConfig(normalizedProviderName)?.enabled === false) return null;
+		try {
+			await setupCodexToken();
+		} catch (error) {
+			if (isMissingCodexCredentialsError(error)) return null;
+			throw error;
+		}
+		const providerConfig = getProviderConfig(normalizedProviderName);
+		if (!providerConfig) return null;
+		return {
+			...providerConfig,
+			apiKey: state.codexAccessToken ?? providerConfig.apiKey
+		};
+	}
+	return getProviderConfig(normalizedProviderName);
+}
+//#endregion
 //#region src/routes/messages/utils.ts
 function mapOpenAIStopReasonToAnthropic(finishReason) {
 	if (finishReason === null) return null;
@@ -1738,13 +1761,13 @@ async function handleProviderCountTokens(c) {
 async function handleProviderCountTokensForProvider(c, options) {
 	const { payload: anthropicPayload, provider } = options;
 	const modelId = anthropicPayload.model.trim();
-	const providerConfig = getProviderConfig(provider);
+	const providerConfig = await resolveProviderConfig(provider);
 	if (!providerConfig) return c.json({ error: {
 		message: `Provider '${provider}' not found or disabled`,
 		type: "invalid_request_error"
 	} }, 404);
 	const modelConfig = providerConfig.models?.[modelId];
-	const tokenCount = await getTokenCount(translateToOpenAI(anthropicPayload, providerConfig.type === "openai-compatible" ? {
+	const tokenCount = await getTokenCount(translateToOpenAI(anthropicPayload, providerConfig.type === "openai-compatible" || providerConfig.type === "openai-responses" ? {
 		supportPdf: modelConfig?.supportPdf,
 		toolContentSupportType: modelConfig?.toolContentSupportType ?? []
 	} : void 0), createFallbackModel(modelId));
@@ -2205,1847 +2228,1820 @@ function closeThinkingBlockIfOpen(state, events) {
 	}
 }
 //#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;
+//#region src/services/copilot/create-responses.ts
+const createResponses = async (payload, { vision, initiator, subagentMarker, requestId, sessionId, compactType, transport = "http" }) => {
+	if (!state.copilotToken) throw new Error("Copilot token not found");
 	const headers = {
-		"content-type": "application/json",
-		accept: "application/json",
-		...authHeaders
+		...copilotHeaders(state, requestId, vision),
+		"x-initiator": initiator
 	};
-	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;
+	prepareInteractionHeaders(sessionId, Boolean(subagentMarker), headers);
+	prepareForCompact(headers, compactType);
+	payload.service_tier = void 0;
+	consola.log(`<-- model: ${payload.model}`);
+	if ((compactType === 1 ? "http" : transport) === "websocket") {
+		const stream = createPooledResponsesWebSocketStream(prepareResponsesWebSocketRequest(payload, headers, {
+			requestId,
+			subagentMarker
+		}));
+		if (payload.stream) return stream;
+		return await consumeResponsesWebSocketStream(stream);
 	}
-	return 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 forwardProviderChatCompletions(providerConfig, payload, requestHeaders) {
-	return await fetch(`${providerConfig.baseUrl}/v1/chat/completions`, {
+	return await createHttpResponses(payload, headers);
+};
+const createHttpResponses = async (payload, headers) => {
+	const response = await fetch(`${copilotBaseUrl(state)}/responses`, {
 		method: "POST",
-		headers: buildProviderUpstreamHeaders(providerConfig, requestHeaders),
+		headers,
 		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$4 = createHandlerLogger("provider-messages-handler");
-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"
-]);
-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 { payload, provider } = options;
-	const providerConfig = getProviderConfig(provider);
-	if (!providerConfig) return c.json({ error: {
-		message: `Provider '${provider}' not found or disabled`,
-		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, {
-			modelConfig,
-			payload,
-			provider,
-			providerConfig
-		});
-		applyMissingExtraBody(payload, { extraBody: modelConfig?.extraBody });
-		const upstreamResponse = await forwardProviderMessages(providerConfig, payload, c.req.raw.headers);
-		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,
-			payload,
-			provider,
-			providerConfig,
-			upstreamResponse
-		});
-		return respondProviderMessagesJson(c, {
-			body: await upstreamResponse.json(),
-			payload,
-			provider,
-			providerConfig
-		});
-	} catch (error) {
-		logger$4.error("provider.messages.error", {
-			provider,
-			error
-		});
-		throw error;
+	logCopilotRateLimits(response.headers);
+	if (!response.ok) {
+		consola.error("Failed to create responses", response);
+		throw new HTTPError("Failed to create responses", response);
 	}
-}
-const applyModelDefaults = (payload, modelConfig) => {
-	payload.temperature ??= modelConfig?.temperature;
-	payload.top_p ??= modelConfig?.topP;
-	payload.top_k ??= modelConfig?.topK;
+	if (payload.stream) return events(response);
+	return await response.json();
 };
-const applyMissingExtraBody = (payload, options) => {
-	for (const [key, value] of Object.entries(options.extraBody ?? {})) if (!Object.hasOwn(payload, key)) payload[key] = value;
+const prepareResponsesWebSocketRequest = (payload, preparedHeaders, options) => {
+	const initiator = getResponsesWebSocketInitiator(preparedHeaders);
+	return {
+		headers: copilotWebSocketHeaders(preparedHeaders),
+		poolKey: buildResponsesWebSocketPoolKey(payload, options),
+		payload: buildResponsesWebSocketPayload(payload, initiator),
+		url: buildResponsesWebSocketUrl(copilotBaseUrl(state))
+	};
 };
-const getRequestThinkingBudget = (payload) => {
-	const budget = payload.thinking?.budget_tokens;
-	if (typeof budget !== "number" || !Number.isFinite(budget)) return;
-	return budget;
+const buildResponsesWebSocketPoolKey = (payload, { requestId, subagentMarker }) => {
+	const tokenFingerprint = state.copilotToken ? createHash("sha256").update(state.copilotToken).digest("hex").slice(0, 16) : "missing-token";
+	const subagentKey = subagentMarker ? [
+		subagentMarker.session_id,
+		subagentMarker.agent_id,
+		subagentMarker.agent_type
+	].join(":") : "main";
+	return [
+		tokenFingerprint,
+		payload.model,
+		requestId,
+		subagentKey
+	].map(encodePoolKeyPart).join("|");
 };
-const applyOpenAICompatibleThinkingBudget = (payload, source) => {
-	const thinkingBudget = getRequestThinkingBudget(source);
-	if (thinkingBudget !== void 0) {
-		payload.thinking_budget = thinkingBudget;
-		return;
-	}
-	if (payload.thinking_budget === void 0) delete payload.thinking_budget;
+const getResponsesWebSocketInitiator = (preparedHeaders) => {
+	return getHeaderValue(preparedHeaders, "x-initiator")?.toLowerCase() === "agent" ? "agent" : "user";
 };
-const applyOpenAICompatibleExtraBodyThinkingBudget = (payload, options) => {
-	const { extraBody } = options;
-	if (!extraBody || !Object.hasOwn(extraBody, "thinking_budget")) return;
-	const rawPayload = payload;
-	rawPayload.thinking_budget = extraBody.thinking_budget;
+const createPooledResponsesWebSocketStream = (request) => createPooledWebSocketStream(request, {
+	createChunk: createResponsesWebSocketStreamChunk,
+	isTerminalChunk: isTerminalResponsesStreamChunk,
+	openErrorMessage: "Failed to create responses websocket",
+	streamErrorMessage: "Responses websocket stream error",
+	terminalChunkMissingMessage: "Responses websocket ended without a terminal response"
+});
+const buildResponsesWebSocketPayload = (payload, initiator) => {
+	const websocketPayload = {
+		...payload,
+		type: "response.create",
+		initiator
+	};
+	delete websocketPayload.stream;
+	delete websocketPayload["background"];
+	delete websocketPayload.service_tier;
+	return websocketPayload;
 };
-const handleOpenAICompatibleProviderMessages = async (c, options) => {
-	const { 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);
-	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,
-		payload,
-		provider,
-		upstreamResponse
-	});
-	return respondOpenAICompatibleProviderMessagesJson(c, {
-		body: await upstreamResponse.json(),
-		payload,
-		provider
-	});
+const buildResponsesWebSocketUrl = (baseUrl) => {
+	return createWebSocketUrl(`${baseUrl.replace(/\/+$/u, "")}/responses`);
 };
-const createOpenAICompatiblePayload = (payload, modelConfig) => {
-	const openAIPayload = translateToOpenAI(payload, {
-		supportPdf: modelConfig?.supportPdf,
-		toolContentSupportType: modelConfig?.toolContentSupportType ?? []
-	});
-	applyOpenAICompatibleThinkingBudget(openAIPayload, payload);
-	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 });
-	applyOpenAICompatibleExtraBodyThinkingBudget(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 getHeaderValue = (headers, headerName) => {
+	const normalizedHeaderName = headerName.toLowerCase();
+	return Object.entries(headers).find(([key]) => key.toLowerCase() === normalizedHeaderName)?.[1];
 };
-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 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 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 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 applyOpenAICompatibleContextCache = (payload) => {
-	const messageIndexes = selectContextCacheMessageIndexes(payload.messages);
-	for (const messageIndex of messageIndexes) applyContextCacheControl(payload.messages[messageIndex]);
+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 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$1([...systemIndexes, ...finalIndexes]).sort((a, b) => a - b);
+//#endregion
+//#region src/routes/messages/responses-translation.ts
+const MESSAGE_TYPE = "message";
+const COMPACTION_SIGNATURE_PREFIX = "cm1#";
+const COMPACTION_SIGNATURE_SEPARATOR = "@";
+const THINKING_TEXT = "Thinking...";
+const buildPromptCacheKey = (basePromptCacheKey, subagentAgentId) => {
+	if (!basePromptCacheKey) return null;
+	const normalizedSubagentAgentId = subagentAgentId?.trim() || null;
+	if (!normalizedSubagentAgentId) return basePromptCacheKey;
+	return `${basePromptCacheKey}:agent:${normalizedSubagentAgentId}`;
 };
-const uniqueIndexes$1 = (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 translateAnthropicMessagesToResponsesPayload = (payload, subagentAgentId) => {
+	const input = [];
+	const applyPhase = shouldApplyPhase(payload.model);
+	const toolSearchEnabled = shouldEnableResponsesToolSearch({
+		model: payload.model,
+		tools: payload.tools
+	});
+	const translationState = {
+		originalTools: payload.tools ?? [],
+		toolSearchEnabled,
+		toolUseNameById: /* @__PURE__ */ new Map()
+	};
+	for (const message of payload.messages) input.push(...translateMessage(message, payload.model, applyPhase, translationState));
+	const hasOriginalTools = Array.isArray(payload.tools) && payload.tools.length > 0;
+	const translatedTools = convertAnthropicTools(payload.tools, toolSearchEnabled);
+	const toolChoice = convertAnthropicToolChoice(payload.tool_choice, toolSearchEnabled);
+	const { sessionId: metadataPromptCacheKey } = parseUserIdMetadata(payload.metadata?.user_id);
+	const sessionAffinity = requestContext.getStore()?.sessionAffinity?.trim() || null;
+	const promptCacheKey = buildPromptCacheKey(metadataPromptCacheKey ?? sessionAffinity, subagentAgentId);
+	const responsesPayload = {
+		model: payload.model,
+		input,
+		instructions: translateSystemPrompt(payload.system, payload.model),
+		temperature: 1,
+		top_p: payload.top_p ?? null,
+		max_output_tokens: Math.max(payload.max_tokens, 12800),
+		tools: translatedTools,
+		tool_choice: toolChoice,
+		metadata: payload.metadata ? { ...payload.metadata } : null,
+		stream: payload.stream ?? null,
+		store: false,
+		parallel_tool_calls: true,
+		reasoning: {
+			effort: getReasoningEffortForModel(payload.model),
+			summary: "detailed"
+		},
+		include: ["reasoning.encrypted_content"]
+	};
+	if (hasOriginalTools) responsesPayload.prompt_cache_key = promptCacheKey;
+	return responsesPayload;
 };
-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;
+const encodeCompactionCarrierSignature = (compaction) => {
+	return `${COMPACTION_SIGNATURE_PREFIX}${compaction.encrypted_content}${COMPACTION_SIGNATURE_SEPARATOR}${compaction.id}`;
+};
+const decodeCompactionCarrierSignature = (signature) => {
+	if (signature.startsWith(COMPACTION_SIGNATURE_PREFIX)) {
+		const raw = signature.slice(4);
+		const separatorIndex = raw.indexOf(COMPACTION_SIGNATURE_SEPARATOR);
+		if (separatorIndex <= 0 || separatorIndex === raw.length - 1) return;
+		const encrypted_content = raw.slice(0, separatorIndex);
+		const id = raw.slice(separatorIndex + 1);
+		if (!encrypted_content) return;
+		return {
+			id,
+			encrypted_content
+		};
 	}
-	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 translateMessage = (message, model, applyPhase, state) => {
+	if (message.role === "user") return translateUserMessage(message, state);
+	return translateAssistantMessage(message, model, applyPhase, state);
 };
-const streamProviderMessages = ({ c, payload, provider, providerConfig, upstreamResponse }) => {
-	logger$4.debug("provider.messages.streaming");
-	const recordUsage = createProviderMessagesUsageRecorder(payload, provider);
-	return streamSSE(c, async (stream) => {
-		let usage = {};
-		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]") break;
-			const parsed = parseProviderStreamEvent(data, providerConfig);
-			if (parsed) {
-				usage = mergeAnthropicUsage(usage, parsed.usage);
-				data = parsed.data;
-			}
-			await stream.writeSSE({
-				event: eventName,
-				data
-			});
+const translateUserMessage = (message, state) => {
+	if (typeof message.content === "string") return [createMessage("user", message.content)];
+	if (!Array.isArray(message.content)) return [];
+	const items = [];
+	const pendingContent = [];
+	for (const block of message.content) {
+		if (block.type === "tool_result") {
+			flushPendingContent(pendingContent, items, { role: "user" });
+			items.push(createToolCallOutput(block, state));
+			continue;
 		}
-		recordUsage(usage);
-	});
+		const converted = translateUserContentBlock(block);
+		if (converted.length > 0) pendingContent.push(...converted);
+	}
+	flushPendingContent(pendingContent, items, { role: "user" });
+	return items;
 };
-const streamOpenAICompatibleProviderMessages = ({ c, payload, provider, upstreamResponse }) => {
-	logger$4.debug("provider.messages.openai_compatible.streaming");
-	const recordUsage = createProviderMessagesUsageRecorder(payload, provider);
-	return streamSSE(c, async (stream) => {
-		let usage = {};
-		const streamState = {
-			messageStartSent: false,
-			contentBlockIndex: 0,
-			contentBlockOpen: false,
-			toolCalls: {},
-			thinkingBlockOpen: 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\"}"
+const translateAssistantMessage = (message, model, applyPhase, state) => {
+	const assistantPhase = resolveAssistantPhase(model, message.content, applyPhase);
+	if (typeof message.content === "string") return [createMessage("assistant", message.content, assistantPhase)];
+	if (!Array.isArray(message.content)) return [];
+	const items = [];
+	const pendingContent = [];
+	for (const block of message.content) {
+		if (block.type === "tool_use") {
+			state.toolUseNameById.set(block.id, block.name);
+			flushPendingContent(pendingContent, items, {
+				role: "assistant",
+				phase: assistantPhase
+			});
+			items.push(createToolCall(block, state));
+			continue;
+		}
+		if (block.type === "thinking" && block.signature) {
+			const compactionContent = createCompactionContent(block);
+			if (compactionContent) {
+				flushPendingContent(pendingContent, items, {
+					role: "assistant",
+					phase: assistantPhase
 				});
+				items.push(compactionContent);
 				continue;
 			}
-			if (!chunk.data || chunk.data === "[DONE]") {
-				if (chunk.data === "[DONE]") break;
-				continue;
-			}
-			const parsed = parseOpenAICompatibleStreamChunk(chunk.data);
-			if (!parsed) continue;
-			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
+			if (block.signature.includes("@")) {
+				flushPendingContent(pendingContent, items, {
+					role: "assistant",
+					phase: assistantPhase
 				});
+				items.push(createReasoningContent(block));
+				continue;
 			}
 		}
-		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
-			});
-		}
-		recordUsage(usage);
+		const converted = translateAssistantContentBlock(block);
+		if (converted) pendingContent.push(converted);
+	}
+	flushPendingContent(pendingContent, items, {
+		role: "assistant",
+		phase: assistantPhase
 	});
+	return items;
 };
-const parseOpenAICompatibleStreamChunk = (data) => {
-	try {
-		return JSON.parse(data);
-	} catch (error) {
-		logger$4.error("provider.messages.openai_compatible.parse_chunk_error", {
-			data,
-			error
-		});
-		return null;
+const translateUserContentBlock = (block) => {
+	switch (block.type) {
+		case "text": return [createTextContent(block.text)];
+		case "image": return [createImageContent(block)];
+		case "document": return [createFileContent(block)];
+		default: return [];
 	}
 };
-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),
-				model: parsed.message.model,
-				usage: normalizeAnthropicUsage(parsed.message.usage)
-			};
-		}
-		if (parsed.type === "message_delta") {
-			adjustInputTokens(providerConfig, parsed.usage);
-			return {
-				data: JSON.stringify(parsed),
-				usage: normalizeAnthropicUsage(parsed.usage)
-			};
-		}
-		return {
-			data: JSON.stringify(parsed),
-			usage: {}
-		};
-	} catch (error) {
-		logger$4.error("provider.messages.streaming.adjust_tokens_error", {
-			error,
-			originalData: data
-		});
-		return null;
+const translateAssistantContentBlock = (block) => {
+	switch (block.type) {
+		case "text": return createOutPutTextContent(block.text);
+		default: return;
 	}
 };
-const respondProviderMessagesJson = (c, options) => {
-	const { body, payload, provider, providerConfig } = options;
-	const recordUsage = createProviderMessagesUsageRecorder(payload, provider);
-	adjustInputTokens(providerConfig, body.usage);
-	recordUsage(normalizeAnthropicUsage(body.usage));
-	debugJson(logger$4, "provider.messages.no_stream result:", body);
-	return c.json(body);
-};
-const respondOpenAICompatibleProviderMessagesJson = (c, options) => {
-	const { body, payload, provider } = options;
-	createProviderMessagesUsageRecorder(payload, provider)(normalizeOpenAIUsage(body.usage));
-	const anthropicResponse = translateToAnthropic(body);
-	debugJson(logger$4, "provider.messages.openai_compatible.no_stream result:", anthropicResponse);
-	return c.json(anthropicResponse);
+const flushPendingContent = (pendingContent, target, message) => {
+	if (pendingContent.length === 0) return;
+	const messageContent = [...pendingContent];
+	target.push(createMessage(message.role, messageContent, message.phase));
+	pendingContent.length = 0;
 };
-const createProviderMessagesUsageRecorder = (payload, provider) => createProviderTokenUsageRecorder({
-	endpoint: "provider_messages",
-	model: payload.model,
-	providerName: provider,
-	sessionId: parseUserIdMetadata(payload.metadata?.user_id).sessionId
+const createMessage = (role, content, phase) => ({
+	type: MESSAGE_TYPE,
+	role,
+	content,
+	...role === "assistant" && phase ? { phase } : {}
 });
-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);
+const resolveAssistantPhase = (_model, content, applyPhase) => {
+	if (!applyPhase) return;
+	if (typeof content === "string") return "final_answer";
+	if (!Array.isArray(content)) return;
+	if (!content.some((block) => block.type === "text")) return;
+	return content.some((block) => block.type === "tool_use") ? "commentary" : "final_answer";
 };
-const responsesUtilsDependencies = {
-	isResponsesApiContextManagementModel,
-	isResponsesApiWebSocketEnabled
+const shouldApplyPhase = (_model) => {
+	return true;
 };
-const getResponsesRequestOptions = (payload) => {
+const createTextContent = (text) => ({
+	type: "input_text",
+	text
+});
+const createOutPutTextContent = (text) => ({
+	type: "output_text",
+	text
+});
+const createImageContent = (block) => ({
+	type: "input_image",
+	image_url: `data:${block.source.media_type};base64,${block.source.data}`,
+	detail: "auto"
+});
+const createFileContent = (block) => ({
+	type: "input_file",
+	file_data: `data:${block.source.media_type};base64,${block.source.data}`,
+	filename: block.title ?? "document.pdf"
+});
+const createReasoningContent = (block) => {
+	const { encryptedContent, id } = parseReasoningSignature(block.signature);
+	const thinking = block.thinking === "Thinking..." ? "" : block.thinking;
 	return {
-		vision: hasVisionInput(payload),
-		initiator: hasAgentInitiator(payload) ? "agent" : "user"
+		id,
+		type: "reasoning",
+		summary: thinking ? [{
+			type: "summary_text",
+			text: thinking
+		}] : [],
+		encrypted_content: encryptedContent
 	};
 };
-const getResponsesTransportForModel = (selectedModel, options = {}) => {
-	const supportedEndpoints = selectedModel?.supported_endpoints ?? [];
-	const useWebSocket = responsesUtilsDependencies.isResponsesApiWebSocketEnabled();
-	if (options.compactType !== 1 && useWebSocket && supportedEndpoints.includes("ws:/responses")) return "websocket";
-	if (supportedEndpoints.includes("/responses")) return "http";
-	return null;
-};
-const hasAgentInitiator = (payload) => {
-	const lastItem = getPayloadItems(payload).at(-1);
-	if (!lastItem) return false;
-	if (!("role" in lastItem) || !lastItem.role) return true;
-	return (typeof lastItem.role === "string" ? lastItem.role.toLowerCase() : "") === "assistant";
+const createCompactionContent = (block) => {
+	const compaction = decodeCompactionCarrierSignature(block.signature);
+	if (!compaction) return;
+	return {
+		id: compaction.id,
+		type: "compaction",
+		encrypted_content: compaction.encrypted_content
+	};
 };
-const hasVisionInput = (payload) => {
-	return getPayloadItems(payload).some((item) => containsVisionContent(item));
+const parseReasoningSignature = (signature) => {
+	const splitIndex = signature.lastIndexOf("@");
+	if (splitIndex <= 0 || splitIndex === signature.length - 1) return {
+		encryptedContent: signature,
+		id: ""
+	};
+	return {
+		encryptedContent: signature.slice(0, splitIndex),
+		id: signature.slice(splitIndex + 1)
+	};
 };
-const resolveResponsesCompactThreshold = (maxPromptTokens) => {
-	if (typeof maxPromptTokens === "number" && maxPromptTokens > 0) return Math.floor(maxPromptTokens * .9);
-	return 5e4;
+const createFunctionToolCall = (block, state) => ({
+	type: "function_call",
+	call_id: block.id,
+	name: block.name,
+	arguments: JSON.stringify(block.input),
+	status: "completed",
+	...state.toolSearchEnabled && isDeferredToolName(block.name) ? { namespace: block.name } : {}
+});
+const createToolSearchCall = (block) => ({
+	type: "tool_search_call",
+	call_id: block.id,
+	arguments: normalizeToolSearchBridgeArguments(block.input),
+	execution: "client",
+	status: "completed"
+});
+const createToolCall = (block, state) => {
+	if (state.toolSearchEnabled && isBridgeToolSearchName(block.name)) return createToolSearchCall(block);
+	return createFunctionToolCall(block, state);
 };
-const createCompactionContextManagement = (compactThreshold) => [{
-	type: "compaction",
-	compact_threshold: compactThreshold
-}];
-const applyResponsesApiContextManagement = (payload, maxPromptTokens) => {
-	if (payload.context_management !== void 0) return;
-	if (!responsesUtilsDependencies.isResponsesApiContextManagementModel(payload.model)) return;
-	payload.context_management = createCompactionContextManagement(resolveResponsesCompactThreshold(maxPromptTokens));
+const createFunctionCallOutput = (block) => ({
+	type: "function_call_output",
+	call_id: block.tool_use_id,
+	output: convertToolResultContent(block.content),
+	status: block.is_error ? "incomplete" : "completed"
+});
+const createToolCallOutput = (block, state) => {
+	const toolUseName = state.toolUseNameById.get(block.tool_use_id);
+	if (state.toolSearchEnabled && isBridgeToolSearchName(toolUseName ?? "")) return createToolSearchOutput(block, state.originalTools);
+	return createFunctionCallOutput(block);
 };
-const compactInputByLatestCompaction = (payload) => {
-	if (!Array.isArray(payload.input) || payload.input.length === 0) return;
-	const latestCompactionMessageIndex = getLatestCompactionMessageIndex(payload.input);
-	if (latestCompactionMessageIndex === void 0) return;
-	payload.input = payload.input.slice(latestCompactionMessageIndex);
+const createToolSearchOutput = (block, originalTools) => {
+	const referencedToolNames = resolveToolSearchReferencedToolNames(block.content, originalTools);
+	return {
+		type: "tool_search_output",
+		call_id: block.tool_use_id,
+		tools: referencedToolNames.map((toolName) => convertDeferredToolToNamespace(resolveDeferredTool(toolName, originalTools))),
+		execution: "client",
+		status: block.is_error ? "incomplete" : "completed"
+	};
 };
-const getLatestCompactionMessageIndex = (input) => {
-	for (let index = input.length - 1; index >= 0; index -= 1) if (isCompactionInputItem(input[index])) return index;
+const resolveToolSearchReferencedToolNames = (content, originalTools) => {
+	const explicitReferences = extractToolReferenceNames(content);
+	if (explicitReferences.length > 0) return uniqueToolNames(explicitReferences);
+	const sentinel = extractMcpToolSearchSentinel(content);
+	if (sentinel) return selectDeferredToolsByNames(sentinel.names, originalTools).map((tool) => tool.name);
+	return [];
 };
-const isCompactionInputItem = (value) => {
-	return "type" in value && typeof value.type === "string" && value.type === "compaction";
+const extractToolReferenceNames = (content) => {
+	if (!Array.isArray(content)) return [];
+	return content.flatMap((block) => block.type === "tool_reference" ? [block.tool_name] : []);
 };
-const getPayloadItems = (payload) => {
-	const result = [];
-	const { input } = payload;
-	if (Array.isArray(input)) result.push(...input);
-	return result;
+const extractMcpToolSearchSentinel = (content) => {
+	if (typeof content === "string") return parseMcpToolSearchSentinel(content);
+	for (const block of content) {
+		if (block.type !== "text") continue;
+		const sentinel = parseMcpToolSearchSentinel(block.text);
+		if (sentinel) return sentinel;
+	}
+	return null;
 };
-const containsVisionContent = (value) => {
-	if (!value) return false;
-	if (Array.isArray(value)) return value.some((entry) => containsVisionContent(entry));
-	if (typeof value !== "object") return false;
-	const record = value;
-	if ((typeof record.type === "string" ? record.type.toLowerCase() : void 0) === "input_image") return true;
-	if (Array.isArray(record.content)) return record.content.some((entry) => containsVisionContent(entry));
-	return false;
+const resolveDeferredTool = (toolName, originalTools) => {
+	const tool = originalTools.find((candidate) => candidate.name === toolName);
+	if (tool && isDeferredToolName(tool.name)) return tool;
+	throw createInvalidRequestError(`Tool reference '${toolName}' has no corresponding deferred tool definition`);
 };
-//#endregion
-//#region src/services/copilot/create-responses.ts
-const RESPONSES_WEBSOCKET_IDLE_TIMEOUT_MS = 6e4;
-const createResponses = async (payload, { vision, initiator, subagentMarker, requestId, sessionId, compactType, transport = "http" }) => {
-	if (!state.copilotToken) throw new Error("Copilot token not found");
-	const headers = {
-		...copilotHeaders(state, requestId, vision),
-		"x-initiator": initiator
-	};
-	prepareInteractionHeaders(sessionId, Boolean(subagentMarker), headers);
-	prepareForCompact(headers, compactType);
-	payload.service_tier = void 0;
-	consola.log(`<-- model: ${payload.model}`);
-	if ((compactType === 1 ? "http" : transport) === "websocket") {
-		const stream = createPooledResponsesWebSocketStream(prepareResponsesWebSocketRequest(payload, headers, {
-			requestId,
-			subagentMarker
-		}));
-		if (payload.stream) return stream;
-		return await consumeResponsesWebSocketStream(stream);
+const uniqueToolNames = (toolNames) => [...new Set(toolNames)];
+const createInvalidRequestError = (message) => new HTTPError(message, new Response(JSON.stringify({ error: {
+	message,
+	type: "invalid_request_error"
+} }), {
+	status: 400,
+	headers: { "content-type": "application/json" }
+}));
+const translateSystemPrompt = (system, model) => {
+	if (!system) return null;
+	const extraPrompt = getExtraPromptForModel(model);
+	if (typeof system === "string") return system + extraPrompt;
+	const text = system.map((block, index) => {
+		if (index === 0) return block.text + "\n\n" + extraPrompt + "\n\n";
+		return block.text;
+	}).join(" ");
+	return text.length > 0 ? text : null;
+};
+const convertAnthropicTools = (tools, toolSearchEnabled) => {
+	if (!tools || tools.length === 0) return null;
+	const converted = [];
+	let addedToolSearch = false;
+	const searchableToolNames = toolSearchEnabled ? listDeferredToolNames(tools) : [];
+	for (const tool of tools) {
+		if (isBridgeToolSearchName(tool.name)) {
+			if (toolSearchEnabled && !addedToolSearch) {
+				converted.push(createResponsesToolSearchDefinition(searchableToolNames));
+				addedToolSearch = true;
+			}
+			continue;
+		}
+		if (toolSearchEnabled && isDeferredToolName(tool.name)) {
+			converted.push(convertDeferredToolToNamespace(tool));
+			continue;
+		}
+		converted.push(convertToolToFunction(tool));
 	}
-	return await createHttpResponses(payload, headers);
+	return converted;
 };
-const createHttpResponses = async (payload, headers) => {
-	const response = await fetch(`${copilotBaseUrl(state)}/responses`, {
-		method: "POST",
-		headers,
-		body: JSON.stringify(payload)
-	});
-	logCopilotRateLimits(response.headers);
-	if (!response.ok) {
-		consola.error("Failed to create responses", response);
-		throw new HTTPError("Failed to create responses", response);
+const createResponsesToolSearchDefinition = (searchableToolNames) => ({
+	type: "tool_search",
+	execution: "client",
+	description: "Load deferred tools by exact name before using them. Return only the searchable tool names you need for the next step.",
+	parameters: {
+		type: "object",
+		properties: { names: {
+			type: "array",
+			description: "Exact deferred tool names to load.",
+			items: {
+				type: "string",
+				enum: searchableToolNames
+			},
+			minItems: 1
+		} },
+		required: ["names"],
+		additionalProperties: false
+	}
+});
+const convertToolToFunction = (tool) => ({
+	type: "function",
+	name: tool.name,
+	parameters: normalizeToolSchema(tool.input_schema),
+	strict: false,
+	...tool.description ? { description: tool.description } : {}
+});
+const convertDeferredToolToNamespace = (tool) => ({
+	type: "namespace",
+	name: tool.name,
+	...tool.description ? { description: tool.description } : {},
+	tools: [{
+		type: "function",
+		name: tool.name,
+		parameters: normalizeToolSchema(tool.input_schema),
+		strict: false,
+		defer_loading: true,
+		...tool.description ? { description: tool.description } : {}
+	}]
+});
+const convertAnthropicToolChoice = (choice, toolSearchEnabled) => {
+	if (!choice) return "auto";
+	switch (choice.type) {
+		case "auto": return "auto";
+		case "any": return "required";
+		case "tool":
+			if (toolSearchEnabled && choice.name && isBridgeToolSearchName(choice.name)) return "auto";
+			return choice.name ? {
+				type: "function",
+				name: choice.name
+			} : "auto";
+		case "none": return "none";
+		default: return "auto";
 	}
-	if (payload.stream) return events(response);
-	return await response.json();
 };
-const prepareResponsesWebSocketRequest = (payload, preparedHeaders, options) => {
-	const initiator = getResponsesWebSocketInitiator(preparedHeaders);
+const translateResponsesResultToAnthropic = (response, options) => {
+	const contentBlocks = mapOutputToAnthropicContent(response.output, options);
+	const usage = mapResponsesUsage(response);
+	let anthropicContent = fallbackContentBlocks(response.output_text);
+	if (contentBlocks.length > 0) anthropicContent = contentBlocks;
+	const stopReason = mapResponsesStopReason(response, options);
 	return {
-		headers: copilotWebSocketHeaders(preparedHeaders),
-		poolKey: buildResponsesWebSocketPoolKey(payload, options),
-		payload: buildResponsesWebSocketPayload(payload, initiator)
+		id: response.id,
+		type: "message",
+		role: "assistant",
+		content: anthropicContent,
+		model: response.model,
+		stop_reason: stopReason,
+		stop_sequence: null,
+		usage
 	};
 };
-const buildResponsesWebSocketPoolKey = (payload, { requestId, subagentMarker }) => {
-	const tokenFingerprint = state.copilotToken ? createHash("sha256").update(state.copilotToken).digest("hex").slice(0, 16) : "missing-token";
-	const subagentKey = subagentMarker ? [
-		subagentMarker.session_id,
-		subagentMarker.agent_id,
-		subagentMarker.agent_type
-	].join(":") : "main";
-	return [
-		tokenFingerprint,
-		payload.model,
-		requestId,
-		subagentKey
-	].map(encodePoolKeyPart).join("|");
-};
-const getResponsesWebSocketInitiator = (preparedHeaders) => {
-	return getHeaderValue(preparedHeaders, "x-initiator")?.toLowerCase() === "agent" ? "agent" : "user";
-};
-const createPooledResponsesWebSocketStream = (request) => runResponsesWebSocketRequest(request);
-const buildResponsesWebSocketPayload = (payload, initiator) => {
-	const websocketPayload = {
-		...payload,
-		type: "response.create",
-		initiator
-	};
-	delete websocketPayload.stream;
-	delete websocketPayload["background"];
-	delete websocketPayload.service_tier;
-	return websocketPayload;
+const mapOutputToAnthropicContent = (output, options) => {
+	const contentBlocks = [];
+	for (const item of output) switch (item.type) {
+		case "reasoning": {
+			const thinkingText = extractReasoningText(item);
+			if (thinkingText.length > 0) contentBlocks.push({
+				type: "thinking",
+				thinking: thinkingText,
+				signature: (item.encrypted_content ?? "") + "@" + item.id
+			});
+			break;
+		}
+		case "function_call": {
+			const toolUseBlock = createToolUseContentBlock(item);
+			if (toolUseBlock) contentBlocks.push(toolUseBlock);
+			break;
+		}
+		case "tool_search_call": {
+			const toolUseBlock = createToolSearchUseContentBlock(item, options?.toolSearchName);
+			if (toolUseBlock) contentBlocks.push(toolUseBlock);
+			break;
+		}
+		case "tool_search_output": break;
+		case "message": {
+			const combinedText = combineMessageTextContent(item.content);
+			if (combinedText.length > 0) contentBlocks.push({
+				type: "text",
+				text: combinedText
+			});
+			break;
+		}
+		case "compaction": {
+			const compactionBlock = createCompactionThinkingBlock(item);
+			if (compactionBlock) contentBlocks.push(compactionBlock);
+			break;
+		}
+		default: {
+			const combinedText = combineMessageTextContent(item.content);
+			if (combinedText.length > 0) contentBlocks.push({
+				type: "text",
+				text: combinedText
+			});
+		}
+	}
+	return contentBlocks;
 };
-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) {
-	const { entry, pooled } = getResponsesWebSocketRequestTarget(request);
-	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;
+const combineMessageTextContent = (content) => {
+	if (!Array.isArray(content)) return "";
+	let aggregated = "";
+	for (const block of content) {
+		if (isResponseOutputText(block)) {
+			aggregated += block.text;
+			continue;
+		}
+		if (isResponseOutputRefusal(block)) {
+			aggregated += block.refusal;
+			continue;
+		}
+		if (typeof block.text === "string") {
+			aggregated += block.text;
+			continue;
+		}
+		if (typeof block.reasoning === "string") {
+			aggregated += block.reasoning;
+			continue;
 		}
-		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();
 	}
+	return aggregated;
 };
-const getResponsesWebSocketRequestTarget = (request) => {
-	if (getResponsesWebSocketActiveRequestCount(request.poolKey) > 0) return {
-		entry: createResponsesWebSocketEntry(request),
-		pooled: false
+const extractReasoningText = (item) => {
+	const segments = [];
+	const collectFromBlocks = (blocks) => {
+		if (!Array.isArray(blocks)) return;
+		for (const block of blocks) if (typeof block.text === "string") {
+			segments.push(block.text);
+			continue;
+		}
 	};
-	const existing = responsesWebSocketPool.get(request.poolKey);
-	if (existing && !existing.closed) {
-		clearResponsesWebSocketIdleTimer(existing);
-		return {
-			entry: existing,
-			pooled: true
-		};
-	}
-	const entry = createResponsesWebSocketEntry(request);
-	responsesWebSocketPool.set(request.poolKey, entry);
+	if (!item.summary || item.summary.length === 0) return THINKING_TEXT;
+	collectFromBlocks(item.summary);
+	return segments.join("").trim();
+};
+const createToolUseContentBlock = (call) => {
+	const toolId = call.call_id;
+	const toolName = resolveToolUseName(call);
+	if (!toolName || !toolId) return null;
 	return {
-		entry,
-		pooled: true
+		type: "tool_use",
+		id: toolId,
+		name: toolName,
+		input: parseFunctionCallArguments(call.arguments)
 	};
 };
-const createResponsesWebSocketEntry = (request) => {
-	const entry = {
-		closed: false,
-		idleTimer: null,
-		requestCount: 0,
-		websocketPromise: openResponsesWebSocket({
-			headers: request.headers,
-			url: buildResponsesWebSocketUrl(copilotBaseUrl(state))
-		})
+const createToolSearchUseContentBlock = (call, toolSearchName = BRIDGE_TOOL_SEARCH_NAME) => {
+	const toolId = call.call_id;
+	if (!toolId) return null;
+	return {
+		type: "tool_use",
+		id: toolId,
+		name: toolSearchName,
+		input: parseToolSearchArguments(call.arguments)
 	};
-	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 resolveToolUseName = (call) => {
+	if (typeof call.namespace === "string" && call.namespace.length > 0) return call.namespace;
+	return call.name;
 };
-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();
+const createCompactionThinkingBlock = (item) => {
+	if (!item.id || !item.encrypted_content) return null;
+	return {
+		type: "thinking",
+		thinking: THINKING_TEXT,
+		signature: encodeCompactionCarrierSignature({
+			id: item.id,
+			encrypted_content: item.encrypted_content
+		})
 	};
-	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));
+const parseFunctionCallArguments = (rawArguments) => {
+	if (typeof rawArguments !== "string" || rawArguments.trim().length === 0) return {};
+	try {
+		const parsed = JSON.parse(rawArguments);
+		if (Array.isArray(parsed)) return { arguments: parsed };
+		if (parsed && typeof parsed === "object") return parsed;
+	} catch (error) {
+		consola.warn("Failed to parse function call arguments", {
+			error,
+			rawArguments
+		});
 	}
-	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));
+	return { raw_arguments: rawArguments };
 };
-const getHeaderValue = (headers, headerName) => {
-	const normalizedHeaderName = headerName.toLowerCase();
-	return Object.entries(headers).find(([key]) => key.toLowerCase() === normalizedHeaderName)?.[1];
+const parseToolSearchArguments = (argumentsValue) => {
+	return formatToolSearchBridgeArguments(argumentsValue);
 };
-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 fallbackContentBlocks = (outputText) => {
+	if (!outputText) return [];
+	return [{
+		type: "text",
+		text: outputText
+	}];
 };
-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 mapResponsesStopReason = (response, options) => {
+	const { status, incomplete_details: incompleteDetails } = response;
+	if (status === "completed") {
+		if (response.output.length === 0) return options?.hasToolCall ? "tool_use" : "end_turn";
+		if (response.output.some((item) => item.type === "function_call" || item.type === "tool_search_call")) return "tool_use";
+		return "end_turn";
 	}
-};
-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;
+	if (status === "incomplete") {
+		if (incompleteDetails?.reason === "max_output_tokens") return "max_tokens";
+		if (incompleteDetails?.reason === "content_filter") return "end_turn";
 	}
-	throw new Error("Responses websocket ended without a terminal response");
-};
-const closeResponsesWebSocket = (websocket) => {
-	if (websocket.readyState === WebSocket.CONNECTING || websocket.readyState === WebSocket.OPEN) websocket.close();
-};
-//#endregion
-//#region src/routes/messages/responses-translation.ts
-const MESSAGE_TYPE = "message";
-const COMPACTION_SIGNATURE_PREFIX = "cm1#";
-const COMPACTION_SIGNATURE_SEPARATOR = "@";
-const THINKING_TEXT = "Thinking...";
-const buildPromptCacheKey = (basePromptCacheKey, subagentAgentId) => {
-	if (!basePromptCacheKey) return null;
-	const normalizedSubagentAgentId = subagentAgentId?.trim() || null;
-	if (!normalizedSubagentAgentId) return basePromptCacheKey;
-	return `${basePromptCacheKey}:agent:${normalizedSubagentAgentId}`;
+	return null;
 };
-const translateAnthropicMessagesToResponsesPayload = (payload, subagentAgentId) => {
-	const input = [];
-	const applyPhase = shouldApplyPhase(payload.model);
-	const toolSearchEnabled = shouldEnableResponsesToolSearch({
-		model: payload.model,
-		tools: payload.tools
-	});
-	const translationState = {
-		originalTools: payload.tools ?? [],
-		toolSearchEnabled,
-		toolUseNameById: /* @__PURE__ */ new Map()
-	};
-	for (const message of payload.messages) input.push(...translateMessage(message, payload.model, applyPhase, translationState));
-	const hasOriginalTools = Array.isArray(payload.tools) && payload.tools.length > 0;
-	const translatedTools = convertAnthropicTools(payload.tools, toolSearchEnabled);
-	const toolChoice = convertAnthropicToolChoice(payload.tool_choice, toolSearchEnabled);
-	const { sessionId: metadataPromptCacheKey } = parseUserIdMetadata(payload.metadata?.user_id);
-	const sessionAffinity = requestContext.getStore()?.sessionAffinity?.trim() || null;
-	const promptCacheKey = buildPromptCacheKey(metadataPromptCacheKey ?? sessionAffinity, subagentAgentId);
-	const responsesPayload = {
-		model: payload.model,
-		input,
-		instructions: translateSystemPrompt(payload.system, payload.model),
-		temperature: 1,
-		top_p: payload.top_p ?? null,
-		max_output_tokens: Math.max(payload.max_tokens, 12800),
-		tools: translatedTools,
-		tool_choice: toolChoice,
-		metadata: payload.metadata ? { ...payload.metadata } : null,
-		stream: payload.stream ?? null,
-		store: false,
-		parallel_tool_calls: true,
-		reasoning: {
-			effort: getReasoningEffortForModel(payload.model),
-			summary: "detailed"
-		},
-		include: ["reasoning.encrypted_content"]
+const mapResponsesUsage = (response) => {
+	const inputTokens = response.usage?.input_tokens ?? 0;
+	const outputTokens = response.usage?.output_tokens ?? 0;
+	return {
+		input_tokens: inputTokens - (response.usage?.input_tokens_details?.cached_tokens ?? 0),
+		output_tokens: outputTokens,
+		...response.usage?.input_tokens_details?.cached_tokens !== void 0 && { cache_read_input_tokens: response.usage.input_tokens_details.cached_tokens }
 	};
-	if (hasOriginalTools) responsesPayload.prompt_cache_key = promptCacheKey;
-	return responsesPayload;
-};
-const encodeCompactionCarrierSignature = (compaction) => {
-	return `${COMPACTION_SIGNATURE_PREFIX}${compaction.encrypted_content}${COMPACTION_SIGNATURE_SEPARATOR}${compaction.id}`;
 };
-const decodeCompactionCarrierSignature = (signature) => {
-	if (signature.startsWith(COMPACTION_SIGNATURE_PREFIX)) {
-		const raw = signature.slice(4);
-		const separatorIndex = raw.indexOf(COMPACTION_SIGNATURE_SEPARATOR);
-		if (separatorIndex <= 0 || separatorIndex === raw.length - 1) return;
-		const encrypted_content = raw.slice(0, separatorIndex);
-		const id = raw.slice(separatorIndex + 1);
-		if (!encrypted_content) return;
-		return {
-			id,
-			encrypted_content
-		};
+const isRecord = (value) => typeof value === "object" && value !== null;
+const isResponseOutputText = (block) => isRecord(block) && "type" in block && block.type === "output_text";
+const isResponseOutputRefusal = (block) => isRecord(block) && "type" in block && block.type === "refusal";
+const convertToolResultContent = (content) => {
+	if (typeof content === "string") return content;
+	if (Array.isArray(content)) {
+		const result = [];
+		for (const block of content) switch (block.type) {
+			case "text":
+				result.push(createTextContent(block.text));
+				break;
+			case "image":
+				result.push(createImageContent(block));
+				break;
+			case "document":
+				result.push(createFileContent(block));
+				break;
+			case "tool_reference":
+				result.push(createTextContent(`Tool ${block.tool_name} loaded`));
+				break;
+			default: break;
+		}
+		return result;
 	}
+	return "";
 };
-const translateMessage = (message, model, applyPhase, state) => {
-	if (message.role === "user") return translateUserMessage(message, state);
-	return translateAssistantMessage(message, model, applyPhase, state);
+//#endregion
+//#region src/routes/messages/responses-stream-translation.ts
+const MAX_CONSECUTIVE_FUNCTION_CALL_WHITESPACE = 20;
+var FunctionCallArgumentsValidationError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "FunctionCallArgumentsValidationError";
+	}
 };
-const translateUserMessage = (message, state) => {
-	if (typeof message.content === "string") return [createMessage("user", message.content)];
-	if (!Array.isArray(message.content)) return [];
-	const items = [];
-	const pendingContent = [];
-	for (const block of message.content) {
-		if (block.type === "tool_result") {
-			flushPendingContent(pendingContent, items, { role: "user" });
-			items.push(createToolCallOutput(block, state));
+const updateWhitespaceRunState = (previousCount, chunk) => {
+	let count = previousCount;
+	for (const char of chunk) {
+		if (char === "\r" || char === "\n" || char === "	") {
+			count += 1;
+			if (count > MAX_CONSECUTIVE_FUNCTION_CALL_WHITESPACE) return {
+				nextCount: count,
+				exceeded: true
+			};
 			continue;
 		}
-		const converted = translateUserContentBlock(block);
-		if (converted.length > 0) pendingContent.push(...converted);
+		if (char !== " ") count = 0;
 	}
-	flushPendingContent(pendingContent, items, { role: "user" });
-	return items;
+	return {
+		nextCount: count,
+		exceeded: false
+	};
 };
-const translateAssistantMessage = (message, model, applyPhase, state) => {
-	const assistantPhase = resolveAssistantPhase(model, message.content, applyPhase);
-	if (typeof message.content === "string") return [createMessage("assistant", message.content, assistantPhase)];
-	if (!Array.isArray(message.content)) return [];
-	const items = [];
-	const pendingContent = [];
-	for (const block of message.content) {
-		if (block.type === "tool_use") {
-			state.toolUseNameById.set(block.id, block.name);
-			flushPendingContent(pendingContent, items, {
-				role: "assistant",
-				phase: assistantPhase
-			});
-			items.push(createToolCall(block, state));
-			continue;
-		}
-		if (block.type === "thinking" && block.signature) {
-			const compactionContent = createCompactionContent(block);
-			if (compactionContent) {
-				flushPendingContent(pendingContent, items, {
-					role: "assistant",
-					phase: assistantPhase
-				});
-				items.push(compactionContent);
-				continue;
-			}
-			if (block.signature.includes("@")) {
-				flushPendingContent(pendingContent, items, {
-					role: "assistant",
-					phase: assistantPhase
-				});
-				items.push(createReasoningContent(block));
-				continue;
-			}
-		}
-		const converted = translateAssistantContentBlock(block);
-		if (converted) pendingContent.push(converted);
-	}
-	flushPendingContent(pendingContent, items, {
-		role: "assistant",
-		phase: assistantPhase
-	});
-	return items;
-};
-const translateUserContentBlock = (block) => {
-	switch (block.type) {
-		case "text": return [createTextContent(block.text)];
-		case "image": return [createImageContent(block)];
-		case "document": return [createFileContent(block)];
+const createResponsesStreamState = (options) => ({
+	messageStartSent: false,
+	messageCompleted: false,
+	nextContentBlockIndex: 0,
+	blockIndexByKey: /* @__PURE__ */ new Map(),
+	openBlocks: /* @__PURE__ */ new Set(),
+	blockHasDelta: /* @__PURE__ */ new Set(),
+	functionCallStateByOutputIndex: /* @__PURE__ */ new Map(),
+	toolSearchName: options?.toolSearchName ?? "mcp__tool_search__search",
+	hasToolCall: false
+});
+const translateResponsesStreamEvent = (rawEvent, state) => {
+	switch (rawEvent.type) {
+		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);
+		case "response.failed": return handleResponseFailed(rawEvent, state);
+		case "error": return handleErrorEvent(rawEvent, state);
 		default: return [];
 	}
 };
-const translateAssistantContentBlock = (block) => {
-	switch (block.type) {
-		case "text": return createOutPutTextContent(block.text);
-		default: return;
-	}
-};
-const flushPendingContent = (pendingContent, target, message) => {
-	if (pendingContent.length === 0) return;
-	const messageContent = [...pendingContent];
-	target.push(createMessage(message.role, messageContent, message.phase));
-	pendingContent.length = 0;
-};
-const createMessage = (role, content, phase) => ({
-	type: MESSAGE_TYPE,
-	role,
-	content,
-	...role === "assistant" && phase ? { phase } : {}
-});
-const resolveAssistantPhase = (_model, content, applyPhase) => {
-	if (!applyPhase) return;
-	if (typeof content === "string") return "final_answer";
-	if (!Array.isArray(content)) return;
-	if (!content.some((block) => block.type === "text")) return;
-	return content.some((block) => block.type === "tool_use") ? "commentary" : "final_answer";
-};
-const shouldApplyPhase = (_model) => {
-	return true;
-};
-const createTextContent = (text) => ({
-	type: "input_text",
-	text
-});
-const createOutPutTextContent = (text) => ({
-	type: "output_text",
-	text
-});
-const createImageContent = (block) => ({
-	type: "input_image",
-	image_url: `data:${block.source.media_type};base64,${block.source.data}`,
-	detail: "auto"
-});
-const createFileContent = (block) => ({
-	type: "input_file",
-	file_data: `data:${block.source.media_type};base64,${block.source.data}`,
-	filename: block.title ?? "document.pdf"
-});
-const createReasoningContent = (block) => {
-	const { encryptedContent, id } = parseReasoningSignature(block.signature);
-	const thinking = block.thinking === "Thinking..." ? "" : block.thinking;
-	return {
-		id,
-		type: "reasoning",
-		summary: thinking ? [{
-			type: "summary_text",
-			text: thinking
-		}] : [],
-		encrypted_content: encryptedContent
-	};
-};
-const createCompactionContent = (block) => {
-	const compaction = decodeCompactionCarrierSignature(block.signature);
-	if (!compaction) return;
-	return {
-		id: compaction.id,
-		type: "compaction",
-		encrypted_content: compaction.encrypted_content
-	};
-};
-const parseReasoningSignature = (signature) => {
-	const splitIndex = signature.lastIndexOf("@");
-	if (splitIndex <= 0 || splitIndex === signature.length - 1) return {
-		encryptedContent: signature,
-		id: ""
-	};
-	return {
-		encryptedContent: signature.slice(0, splitIndex),
-		id: signature.slice(splitIndex + 1)
-	};
-};
-const createFunctionToolCall = (block, state) => ({
-	type: "function_call",
-	call_id: block.id,
-	name: block.name,
-	arguments: JSON.stringify(block.input),
-	status: "completed",
-	...state.toolSearchEnabled && isDeferredToolName(block.name) ? { namespace: block.name } : {}
-});
-const createToolSearchCall = (block) => ({
-	type: "tool_search_call",
-	call_id: block.id,
-	arguments: normalizeToolSearchBridgeArguments(block.input),
-	execution: "client",
-	status: "completed"
-});
-const createToolCall = (block, state) => {
-	if (state.toolSearchEnabled && isBridgeToolSearchName(block.name)) return createToolSearchCall(block);
-	return createFunctionToolCall(block, state);
-};
-const createFunctionCallOutput = (block) => ({
-	type: "function_call_output",
-	call_id: block.tool_use_id,
-	output: convertToolResultContent(block.content),
-	status: block.is_error ? "incomplete" : "completed"
-});
-const createToolCallOutput = (block, state) => {
-	const toolUseName = state.toolUseNameById.get(block.tool_use_id);
-	if (state.toolSearchEnabled && isBridgeToolSearchName(toolUseName ?? "")) return createToolSearchOutput(block, state.originalTools);
-	return createFunctionCallOutput(block);
-};
-const createToolSearchOutput = (block, originalTools) => {
-	const referencedToolNames = resolveToolSearchReferencedToolNames(block.content, originalTools);
-	return {
-		type: "tool_search_output",
-		call_id: block.tool_use_id,
-		tools: referencedToolNames.map((toolName) => convertDeferredToolToNamespace(resolveDeferredTool(toolName, originalTools))),
-		execution: "client",
-		status: block.is_error ? "incomplete" : "completed"
-	};
-};
-const resolveToolSearchReferencedToolNames = (content, originalTools) => {
-	const explicitReferences = extractToolReferenceNames(content);
-	if (explicitReferences.length > 0) return uniqueToolNames(explicitReferences);
-	const sentinel = extractMcpToolSearchSentinel(content);
-	if (sentinel) return selectDeferredToolsByNames(sentinel.names, originalTools).map((tool) => tool.name);
-	return [];
-};
-const extractToolReferenceNames = (content) => {
-	if (!Array.isArray(content)) return [];
-	return content.flatMap((block) => block.type === "tool_reference" ? [block.tool_name] : []);
+const handleResponseCreated = (rawEvent, state) => {
+	return messageStart(state, rawEvent.response);
 };
-const extractMcpToolSearchSentinel = (content) => {
-	if (typeof content === "string") return parseMcpToolSearchSentinel(content);
-	for (const block of content) {
-		if (block.type !== "text") continue;
-		const sentinel = parseMcpToolSearchSentinel(block.text);
-		if (sentinel) return sentinel;
+const handleOutputItemAdded$1 = (rawEvent, state) => {
+	const events = new Array();
+	const functionCallDetails = extractFunctionCallDetails(rawEvent, state);
+	if (!functionCallDetails) return events;
+	const { outputIndex, toolCallId, name, initialArguments } = functionCallDetails;
+	const blockIndex = openFunctionCallBlock(state, {
+		outputIndex,
+		toolCallId,
+		name,
+		events
+	});
+	if (initialArguments !== void 0 && initialArguments.length > 0) {
+		events.push({
+			type: "content_block_delta",
+			index: blockIndex,
+			delta: {
+				type: "input_json_delta",
+				partial_json: initialArguments
+			}
+		});
+		state.blockHasDelta.add(blockIndex);
 	}
-	return null;
-};
-const resolveDeferredTool = (toolName, originalTools) => {
-	const tool = originalTools.find((candidate) => candidate.name === toolName);
-	if (tool && isDeferredToolName(tool.name)) return tool;
-	throw createInvalidRequestError(`Tool reference '${toolName}' has no corresponding deferred tool definition`);
-};
-const uniqueToolNames = (toolNames) => [...new Set(toolNames)];
-const createInvalidRequestError = (message) => new HTTPError(message, new Response(JSON.stringify({ error: {
-	message,
-	type: "invalid_request_error"
-} }), {
-	status: 400,
-	headers: { "content-type": "application/json" }
-}));
-const translateSystemPrompt = (system, model) => {
-	if (!system) return null;
-	const extraPrompt = getExtraPromptForModel(model);
-	if (typeof system === "string") return system + extraPrompt;
-	const text = system.map((block, index) => {
-		if (index === 0) return block.text + "\n\n" + extraPrompt + "\n\n";
-		return block.text;
-	}).join(" ");
-	return text.length > 0 ? text : null;
+	return events;
 };
-const convertAnthropicTools = (tools, toolSearchEnabled) => {
-	if (!tools || tools.length === 0) return null;
-	const converted = [];
-	let addedToolSearch = false;
-	const searchableToolNames = toolSearchEnabled ? listDeferredToolNames(tools) : [];
-	for (const tool of tools) {
-		if (isBridgeToolSearchName(tool.name)) {
-			if (toolSearchEnabled && !addedToolSearch) {
-				converted.push(createResponsesToolSearchDefinition(searchableToolNames));
-				addedToolSearch = true;
-			}
-			continue;
-		}
-		if (toolSearchEnabled && isDeferredToolName(tool.name)) {
-			converted.push(convertDeferredToolToNamespace(tool));
-			continue;
+const handleOutputItemDone$1 = (rawEvent, state) => {
+	const events = new Array();
+	const item = rawEvent.item;
+	const itemType = item.type;
+	const outputIndex = rawEvent.output_index;
+	if (itemType === "tool_search_call") {
+		const blockIndex = openFunctionCallBlock(state, {
+			outputIndex,
+			toolCallId: item.call_id,
+			name: state.toolSearchName,
+			events
+		});
+		const finalArguments = stringifyToolSearchArguments(item.arguments);
+		if (!state.blockHasDelta.has(blockIndex) && finalArguments) {
+			events.push({
+				type: "content_block_delta",
+				index: blockIndex,
+				delta: {
+					type: "input_json_delta",
+					partial_json: finalArguments
+				}
+			});
+			state.blockHasDelta.add(blockIndex);
 		}
-		converted.push(convertToolToFunction(tool));
+		state.functionCallStateByOutputIndex.delete(outputIndex);
+		return events;
 	}
-	return converted;
-};
-const createResponsesToolSearchDefinition = (searchableToolNames) => ({
-	type: "tool_search",
-	execution: "client",
-	description: "Load deferred tools by exact name before using them. Return only the searchable tool names you need for the next step.",
-	parameters: {
-		type: "object",
-		properties: { names: {
-			type: "array",
-			description: "Exact deferred tool names to load.",
-			items: {
-				type: "string",
-				enum: searchableToolNames
-			},
-			minItems: 1
-		} },
-		required: ["names"],
-		additionalProperties: false
+	if (itemType === "compaction") {
+		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,
+			delta: {
+				type: "thinking_delta",
+				thinking: THINKING_TEXT
+			}
+		});
+		events.push({
+			type: "content_block_delta",
+			index: blockIndex,
+			delta: {
+				type: "signature_delta",
+				signature: encodeCompactionCarrierSignature({
+					id: item.id,
+					encrypted_content: item.encrypted_content
+				})
+			}
+		});
+		state.blockHasDelta.add(blockIndex);
+		return events;
 	}
-});
-const convertToolToFunction = (tool) => ({
-	type: "function",
-	name: tool.name,
-	parameters: normalizeToolSchema(tool.input_schema),
-	strict: false,
-	...tool.description ? { description: tool.description } : {}
-});
-const convertDeferredToolToNamespace = (tool) => ({
-	type: "namespace",
-	name: tool.name,
-	...tool.description ? { description: tool.description } : {},
-	tools: [{
-		type: "function",
-		name: tool.name,
-		parameters: normalizeToolSchema(tool.input_schema),
-		strict: false,
-		defer_loading: true,
-		...tool.description ? { description: tool.description } : {}
-	}]
-});
-const convertAnthropicToolChoice = (choice, toolSearchEnabled) => {
-	if (!choice) return "auto";
-	switch (choice.type) {
-		case "auto": return "auto";
-		case "any": return "required";
-		case "tool":
-			if (toolSearchEnabled && choice.name && isBridgeToolSearchName(choice.name)) return "auto";
-			return choice.name ? {
-				type: "function",
-				name: choice.name
-			} : "auto";
-		case "none": return "none";
-		default: return "auto";
+	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.push({
+			type: "content_block_delta",
+			index: blockIndex,
+			delta: {
+				type: "thinking_delta",
+				thinking: THINKING_TEXT
+			}
+		});
+		events.push({
+			type: "content_block_delta",
+			index: blockIndex,
+			delta: {
+				type: "signature_delta",
+				signature
+			}
+		});
+		state.blockHasDelta.add(blockIndex);
 	}
+	return events;
 };
-const translateResponsesResultToAnthropic = (response, options) => {
-	const contentBlocks = mapOutputToAnthropicContent(response.output, options);
-	const usage = mapResponsesUsage(response);
-	let anthropicContent = fallbackContentBlocks(response.output_text);
-	if (contentBlocks.length > 0) anthropicContent = contentBlocks;
-	const stopReason = mapResponsesStopReason(response);
-	return {
-		id: response.id,
-		type: "message",
-		role: "assistant",
-		content: anthropicContent,
-		model: response.model,
-		stop_reason: stopReason,
-		stop_sequence: null,
-		usage
-	};
+const handleFunctionCallArgumentsDelta = (rawEvent, state) => {
+	const events = new Array();
+	const outputIndex = rawEvent.output_index;
+	const deltaText = rawEvent.delta;
+	if (!deltaText) return events;
+	const blockIndex = openFunctionCallBlock(state, {
+		outputIndex,
+		events
+	});
+	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, events);
+	functionCallState.consecutiveWhitespaceCount = nextCount;
+	events.push({
+		type: "content_block_delta",
+		index: blockIndex,
+		delta: {
+			type: "input_json_delta",
+			partial_json: deltaText
+		}
+	});
+	state.blockHasDelta.add(blockIndex);
+	return events;
 };
-const mapOutputToAnthropicContent = (output, options) => {
-	const contentBlocks = [];
-	for (const item of output) switch (item.type) {
-		case "reasoning": {
-			const thinkingText = extractReasoningText(item);
-			if (thinkingText.length > 0) contentBlocks.push({
-				type: "thinking",
-				thinking: thinkingText,
-				signature: (item.encrypted_content ?? "") + "@" + item.id
-			});
-			break;
+const handleFunctionCallArgumentsDone = (rawEvent, state) => {
+	const events = new Array();
+	const outputIndex = rawEvent.output_index;
+	const blockIndex = openFunctionCallBlock(state, {
+		outputIndex,
+		events
+	});
+	const finalArguments = typeof rawEvent.arguments === "string" ? rawEvent.arguments : void 0;
+	if (!state.blockHasDelta.has(blockIndex) && finalArguments) {
+		events.push({
+			type: "content_block_delta",
+			index: blockIndex,
+			delta: {
+				type: "input_json_delta",
+				partial_json: finalArguments
+			}
+		});
+		state.blockHasDelta.add(blockIndex);
+	}
+	state.functionCallStateByOutputIndex.delete(outputIndex);
+	return events;
+};
+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;
+	const blockIndex = openTextBlockIfNeeded(state, {
+		outputIndex,
+		contentIndex,
+		events
+	});
+	events.push({
+		type: "content_block_delta",
+		index: blockIndex,
+		delta: {
+			type: "text_delta",
+			text: deltaText
 		}
-		case "function_call": {
-			const toolUseBlock = createToolUseContentBlock(item);
-			if (toolUseBlock) contentBlocks.push(toolUseBlock);
-			break;
+	});
+	state.blockHasDelta.add(blockIndex);
+	return events;
+};
+const handleReasoningSummaryTextDelta = (rawEvent, state) => {
+	const outputIndex = rawEvent.output_index;
+	const deltaText = rawEvent.delta;
+	const events = new Array();
+	const blockIndex = openThinkingBlockIfNeeded(state, outputIndex, events);
+	events.push({
+		type: "content_block_delta",
+		index: blockIndex,
+		delta: {
+			type: "thinking_delta",
+			thinking: deltaText
 		}
-		case "tool_search_call": {
-			const toolUseBlock = createToolSearchUseContentBlock(item, options?.toolSearchName);
-			if (toolUseBlock) contentBlocks.push(toolUseBlock);
-			break;
+	});
+	state.blockHasDelta.add(blockIndex);
+	return events;
+};
+const handleReasoningSummaryTextDone = (rawEvent, state) => {
+	const outputIndex = rawEvent.output_index;
+	const text = rawEvent.text;
+	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: {
+			type: "thinking_delta",
+			thinking: text
 		}
-		case "tool_search_output": break;
-		case "message": {
-			const combinedText = combineMessageTextContent(item.content);
-			if (combinedText.length > 0) contentBlocks.push({
-				type: "text",
-				text: combinedText
-			});
-			break;
+	});
+	return events;
+};
+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, {
+		outputIndex,
+		contentIndex,
+		events
+	});
+	if (text && !state.blockHasDelta.has(blockIndex)) events.push({
+		type: "content_block_delta",
+		index: blockIndex,
+		delta: {
+			type: "text_delta",
+			text
 		}
-		case "compaction": {
-			const compactionBlock = createCompactionThinkingBlock(item);
-			if (compactionBlock) contentBlocks.push(compactionBlock);
-			break;
+	});
+	return events;
+};
+const handleResponseCompleted = (rawEvent, state) => {
+	const response = rawEvent.response;
+	const events = new Array();
+	closeAllOpenBlocks(state, events);
+	const anthropic = translateResponsesResultToAnthropic(response, {
+		hasToolCall: state.hasToolCall,
+		toolSearchName: state.toolSearchName
+	});
+	events.push({
+		type: "message_delta",
+		delta: {
+			stop_reason: anthropic.stop_reason,
+			stop_sequence: anthropic.stop_sequence
+		},
+		usage: anthropic.usage
+	}, { type: "message_stop" });
+	state.messageCompleted = true;
+	return events;
+};
+const handleResponseFailed = (rawEvent, state) => {
+	const response = rawEvent.response;
+	const events = new Array();
+	closeAllOpenBlocks(state, events);
+	const message = response.error?.message ?? "The response failed due to an unknown error.";
+	events.push(buildErrorEvent(message));
+	state.messageCompleted = true;
+	return events;
+};
+const handleErrorEvent = (rawEvent, state) => {
+	const message = typeof rawEvent.message === "string" ? rawEvent.message : "An unexpected error occurred during streaming.";
+	state.messageCompleted = true;
+	return [buildErrorEvent(message)];
+};
+const handleFunctionCallArgumentsValidationError = (error, state, events = []) => {
+	const reason = error.message;
+	closeAllOpenBlocks(state, events);
+	state.messageCompleted = true;
+	events.push(buildErrorEvent(reason));
+	return events;
+};
+const messageStart = (state, response) => {
+	state.messageStartSent = true;
+	const inputCachedTokens = response.usage?.input_tokens_details?.cached_tokens;
+	const inputTokens = (response.usage?.input_tokens ?? 0) - (inputCachedTokens ?? 0);
+	return [{
+		type: "message_start",
+		message: {
+			id: response.id,
+			type: "message",
+			role: "assistant",
+			content: [],
+			model: response.model,
+			stop_reason: null,
+			stop_sequence: null,
+			usage: {
+				input_tokens: inputTokens,
+				output_tokens: 0,
+				cache_read_input_tokens: inputCachedTokens ?? 0
+			}
 		}
-		default: {
-			const combinedText = combineMessageTextContent(item.content);
-			if (combinedText.length > 0) contentBlocks.push({
+	}];
+};
+const openTextBlockIfNeeded = (state, params) => {
+	const { outputIndex, contentIndex, events } = params;
+	const key = getBlockKey(outputIndex, contentIndex);
+	let blockIndex = state.blockIndexByKey.get(key);
+	if (blockIndex === void 0) {
+		blockIndex = state.nextContentBlockIndex;
+		state.nextContentBlockIndex += 1;
+		state.blockIndexByKey.set(key, blockIndex);
+	}
+	if (!state.openBlocks.has(blockIndex)) {
+		closeOpenBlocks(state, events);
+		events.push({
+			type: "content_block_start",
+			index: blockIndex,
+			content_block: {
 				type: "text",
-				text: combinedText
-			});
-		}
+				text: ""
+			}
+		});
+		state.openBlocks.add(blockIndex);
 	}
-	return contentBlocks;
+	return blockIndex;
 };
-const combineMessageTextContent = (content) => {
-	if (!Array.isArray(content)) return "";
-	let aggregated = "";
-	for (const block of content) {
-		if (isResponseOutputText(block)) {
-			aggregated += block.text;
-			continue;
-		}
-		if (isResponseOutputRefusal(block)) {
-			aggregated += block.refusal;
-			continue;
-		}
-		if (typeof block.text === "string") {
-			aggregated += block.text;
-			continue;
-		}
-		if (typeof block.reasoning === "string") {
-			aggregated += block.reasoning;
-			continue;
-		}
+const openThinkingBlockIfNeeded = (state, outputIndex, events) => {
+	const key = getBlockKey(outputIndex, 0);
+	let blockIndex = state.blockIndexByKey.get(key);
+	if (blockIndex === void 0) {
+		blockIndex = state.nextContentBlockIndex;
+		state.nextContentBlockIndex += 1;
+		state.blockIndexByKey.set(key, blockIndex);
 	}
-	return aggregated;
+	if (!state.openBlocks.has(blockIndex)) {
+		closeOpenBlocks(state, events);
+		events.push({
+			type: "content_block_start",
+			index: blockIndex,
+			content_block: {
+				type: "thinking",
+				thinking: ""
+			}
+		});
+		state.openBlocks.add(blockIndex);
+	}
+	return blockIndex;
 };
-const extractReasoningText = (item) => {
-	const segments = [];
-	const collectFromBlocks = (blocks) => {
-		if (!Array.isArray(blocks)) return;
-		for (const block of blocks) if (typeof block.text === "string") {
-			segments.push(block.text);
-			continue;
-		}
-	};
-	if (!item.summary || item.summary.length === 0) return THINKING_TEXT;
-	collectFromBlocks(item.summary);
-	return segments.join("").trim();
+const closeBlockIfOpen = (state, blockIndex, events) => {
+	if (!state.openBlocks.has(blockIndex)) return;
+	events.push({
+		type: "content_block_stop",
+		index: blockIndex
+	});
+	state.openBlocks.delete(blockIndex);
+	state.blockHasDelta.delete(blockIndex);
 };
-const createToolUseContentBlock = (call) => {
-	const toolId = call.call_id;
-	const toolName = resolveToolUseName(call);
-	if (!toolName || !toolId) return null;
-	return {
-		type: "tool_use",
-		id: toolId,
-		name: toolName,
-		input: parseFunctionCallArguments(call.arguments)
-	};
+const closeOpenBlocks = (state, events) => {
+	for (const blockIndex of state.openBlocks) closeBlockIfOpen(state, blockIndex, events);
 };
-const createToolSearchUseContentBlock = (call, toolSearchName = BRIDGE_TOOL_SEARCH_NAME) => {
-	const toolId = call.call_id;
-	if (!toolId) return null;
-	return {
-		type: "tool_use",
-		id: toolId,
-		name: toolSearchName,
-		input: parseToolSearchArguments(call.arguments)
+const closeAllOpenBlocks = (state, events) => {
+	closeOpenBlocks(state, events);
+	state.functionCallStateByOutputIndex.clear();
+};
+const buildErrorEvent = (message) => ({
+	type: "error",
+	error: {
+		type: "api_error",
+		message
+	}
+});
+const getBlockKey = (outputIndex, contentIndex) => `${outputIndex}:${contentIndex}`;
+const openFunctionCallBlock = (state, params) => {
+	const { outputIndex, toolCallId, name, events } = params;
+	state.hasToolCall = true;
+	let functionCallState = state.functionCallStateByOutputIndex.get(outputIndex);
+	if (!functionCallState) {
+		const blockIndex = state.nextContentBlockIndex;
+		state.nextContentBlockIndex += 1;
+		functionCallState = {
+			blockIndex,
+			toolCallId: toolCallId ?? `tool_call_${blockIndex}`,
+			name: name ?? "function",
+			consecutiveWhitespaceCount: 0
+		};
+		state.functionCallStateByOutputIndex.set(outputIndex, functionCallState);
+	}
+	const { blockIndex } = functionCallState;
+	if (!state.openBlocks.has(blockIndex)) {
+		closeOpenBlocks(state, events);
+		events.push({
+			type: "content_block_start",
+			index: blockIndex,
+			content_block: {
+				type: "tool_use",
+				id: functionCallState.toolCallId,
+				name: functionCallState.name,
+				input: {}
+			}
+		});
+		state.openBlocks.add(blockIndex);
+	}
+	return blockIndex;
+};
+const extractFunctionCallDetails = (rawEvent, state) => {
+	const item = rawEvent.item;
+	const itemType = item.type;
+	if (itemType === "tool_search_call") return {
+		outputIndex: rawEvent.output_index,
+		toolCallId: item.call_id,
+		name: state.toolSearchName,
+		initialArguments: ""
 	};
-};
-const resolveToolUseName = (call) => {
-	if (typeof call.namespace === "string" && call.namespace.length > 0) return call.namespace;
-	return call.name;
-};
-const createCompactionThinkingBlock = (item) => {
-	if (!item.id || !item.encrypted_content) return null;
+	if (itemType !== "function_call") return;
 	return {
-		type: "thinking",
-		thinking: THINKING_TEXT,
-		signature: encodeCompactionCarrierSignature({
-			id: item.id,
-			encrypted_content: item.encrypted_content
-		})
+		outputIndex: rawEvent.output_index,
+		toolCallId: item.call_id,
+		name: resolveToolUseName(item),
+		initialArguments: item.arguments
 	};
 };
-const parseFunctionCallArguments = (rawArguments) => {
-	if (typeof rawArguments !== "string" || rawArguments.trim().length === 0) return {};
+const stringifyToolSearchArguments = (argumentsValue) => {
 	try {
-		const parsed = JSON.parse(rawArguments);
-		if (Array.isArray(parsed)) return { arguments: parsed };
-		if (parsed && typeof parsed === "object") return parsed;
-	} catch (error) {
-		consola.warn("Failed to parse function call arguments", {
-			error,
-			rawArguments
-		});
+		return JSON.stringify(formatToolSearchBridgeArguments(argumentsValue));
+	} catch {
+		return;
 	}
-	return { raw_arguments: rawArguments };
 };
-const parseToolSearchArguments = (argumentsValue) => {
-	return formatToolSearchBridgeArguments(argumentsValue);
+const responsesUtilsDependencies = {
+	isResponsesApiContextManagementModel,
+	isResponsesApiWebSocketEnabled
 };
-const fallbackContentBlocks = (outputText) => {
-	if (!outputText) return [];
-	return [{
-		type: "text",
-		text: outputText
-	}];
+const getResponsesRequestOptions = (payload) => {
+	return {
+		vision: hasVisionInput(payload),
+		initiator: hasAgentInitiator(payload) ? "agent" : "user"
+	};
 };
-const mapResponsesStopReason = (response) => {
-	const { status, incomplete_details: incompleteDetails } = response;
-	if (status === "completed") {
-		if (response.output.some((item) => item.type === "function_call" || item.type === "tool_search_call")) return "tool_use";
-		return "end_turn";
-	}
-	if (status === "incomplete") {
-		if (incompleteDetails?.reason === "max_output_tokens") return "max_tokens";
-		if (incompleteDetails?.reason === "content_filter") return "end_turn";
-	}
+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 mapResponsesUsage = (response) => {
-	const inputTokens = response.usage?.input_tokens ?? 0;
-	const outputTokens = response.usage?.output_tokens ?? 0;
-	return {
-		input_tokens: inputTokens - (response.usage?.input_tokens_details?.cached_tokens ?? 0),
-		output_tokens: outputTokens,
-		...response.usage?.input_tokens_details?.cached_tokens !== void 0 && { cache_read_input_tokens: response.usage.input_tokens_details.cached_tokens }
-	};
+const hasAgentInitiator = (payload) => {
+	const lastItem = getPayloadItems(payload).at(-1);
+	if (!lastItem) return false;
+	if (!("role" in lastItem) || !lastItem.role) return true;
+	return (typeof lastItem.role === "string" ? lastItem.role.toLowerCase() : "") === "assistant";
 };
-const isRecord = (value) => typeof value === "object" && value !== null;
-const isResponseOutputText = (block) => isRecord(block) && "type" in block && block.type === "output_text";
-const isResponseOutputRefusal = (block) => isRecord(block) && "type" in block && block.type === "refusal";
-const convertToolResultContent = (content) => {
-	if (typeof content === "string") return content;
-	if (Array.isArray(content)) {
-		const result = [];
-		for (const block of content) switch (block.type) {
-			case "text":
-				result.push(createTextContent(block.text));
-				break;
-			case "image":
-				result.push(createImageContent(block));
-				break;
-			case "document":
-				result.push(createFileContent(block));
-				break;
-			case "tool_reference":
-				result.push(createTextContent(`Tool ${block.tool_name} loaded`));
-				break;
-			default: break;
-		}
-		return result;
-	}
-	return "";
+const hasVisionInput = (payload) => {
+	return getPayloadItems(payload).some((item) => containsVisionContent(item));
 };
-//#endregion
-//#region src/routes/messages/responses-stream-translation.ts
-const MAX_CONSECUTIVE_FUNCTION_CALL_WHITESPACE = 20;
-var FunctionCallArgumentsValidationError = class extends Error {
-	constructor(message) {
-		super(message);
-		this.name = "FunctionCallArgumentsValidationError";
-	}
+const resolveResponsesCompactThreshold = (maxPromptTokens) => {
+	if (typeof maxPromptTokens === "number" && maxPromptTokens > 0) return Math.floor(maxPromptTokens * .9);
+	return 5e4;
 };
-const updateWhitespaceRunState = (previousCount, chunk) => {
-	let count = previousCount;
-	for (const char of chunk) {
-		if (char === "\r" || char === "\n" || char === "	") {
-			count += 1;
-			if (count > MAX_CONSECUTIVE_FUNCTION_CALL_WHITESPACE) return {
-				nextCount: count,
-				exceeded: true
-			};
-			continue;
-		}
-		if (char !== " ") count = 0;
+const createCompactionContextManagement = (compactThreshold) => [{
+	type: "compaction",
+	compact_threshold: compactThreshold
+}];
+const applyResponsesApiContextManagement = (payload, maxPromptTokens) => {
+	if (payload.context_management !== void 0) return;
+	if (!responsesUtilsDependencies.isResponsesApiContextManagementModel(payload.model)) return;
+	payload.context_management = createCompactionContextManagement(resolveResponsesCompactThreshold(maxPromptTokens));
+};
+const compactInputByLatestCompaction = (payload) => {
+	if (!Array.isArray(payload.input) || payload.input.length === 0) return;
+	const latestCompactionMessageIndex = getLatestCompactionMessageIndex(payload.input);
+	if (latestCompactionMessageIndex === void 0) return;
+	payload.input = payload.input.slice(latestCompactionMessageIndex);
+};
+const getLatestCompactionMessageIndex = (input) => {
+	for (let index = input.length - 1; index >= 0; index -= 1) if (isCompactionInputItem(input[index])) return index;
+};
+const isCompactionInputItem = (value) => {
+	return "type" in value && typeof value.type === "string" && value.type === "compaction";
+};
+const getPayloadItems = (payload) => {
+	const result = [];
+	const { input } = payload;
+	if (Array.isArray(input)) result.push(...input);
+	return result;
+};
+const containsVisionContent = (value) => {
+	if (!value) return false;
+	if (Array.isArray(value)) return value.some((entry) => containsVisionContent(entry));
+	if (typeof value !== "object") return false;
+	const record = value;
+	if ((typeof record.type === "string" ? record.type.toLowerCase() : void 0) === "input_image") return true;
+	if (Array.isArray(record.content)) return record.content.some((entry) => containsVisionContent(entry));
+	return false;
+};
+//#endregion
+//#region src/services/codex/get-models.ts
+const CODEX_MODELS = [
+	{
+		contextWindow: 272e3,
+		id: "gpt-5.3-codex-spark",
+		input: ["text"],
+		maxTokens: 128e3,
+		name: "GPT-5.3 Codex Spark"
+	},
+	{
+		contextWindow: 1e6,
+		id: "gpt-5.4",
+		input: ["text", "image"],
+		maxTokens: 128e3,
+		name: "GPT-5.4"
+	},
+	{
+		contextWindow: 1e6,
+		id: "gpt-5.4-mini",
+		input: ["text", "image"],
+		maxTokens: 128e3,
+		name: "GPT-5.4 mini"
+	},
+	{
+		contextWindow: 272e3,
+		id: "gpt-5.5",
+		input: ["text", "image"],
+		maxTokens: 128e3,
+		name: "GPT-5.5"
 	}
+];
+function normalizeCodexModel(model) {
+	const supportsVision = model.input.includes("image");
 	return {
-		nextCount: count,
-		exceeded: false
+		capabilities: {
+			family: "gpt",
+			limits: {
+				max_context_window_tokens: model.contextWindow,
+				max_output_tokens: model.maxTokens,
+				max_prompt_tokens: model.contextWindow
+			},
+			object: "model_capabilities",
+			supports: {
+				adaptive_thinking: true,
+				parallel_tool_calls: true,
+				reasoning_effort: [
+					"minimal",
+					"low",
+					"medium",
+					"high",
+					"xhigh"
+				],
+				streaming: true,
+				tool_calls: true,
+				vision: supportsVision
+			},
+			tokenizer: "o200k_base",
+			type: "chat"
+		},
+		id: model.id,
+		model_picker_enabled: true,
+		name: model.name,
+		object: "model",
+		preview: false,
+		supported_endpoints: ["/v1/messages", "/v1/responses"],
+		vendor: "openai",
+		version: "chatgpt-codex"
 	};
-};
-const createResponsesStreamState = (options) => ({
-	messageStartSent: false,
-	messageCompleted: false,
-	nextContentBlockIndex: 0,
-	blockIndexByKey: /* @__PURE__ */ new Map(),
-	openBlocks: /* @__PURE__ */ new Set(),
-	blockHasDelta: /* @__PURE__ */ new Set(),
-	functionCallStateByOutputIndex: /* @__PURE__ */ new Map(),
-	toolSearchName: options?.toolSearchName ?? "mcp__tool_search__search"
-});
-const translateResponsesStreamEvent = (rawEvent, state) => {
-	switch (rawEvent.type) {
-		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);
-		case "response.failed": return handleResponseFailed(rawEvent, state);
-		case "error": return handleErrorEvent(rawEvent, state);
-		default: return [];
+}
+function getModels() {
+	return {
+		object: "list",
+		data: CODEX_MODELS.map((model) => normalizeCodexModel(model))
+	};
+}
+//#endregion
+//#region src/services/providers/provider-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 === "x-api-key") authHeaders["x-api-key"] = providerConfig.apiKey;
+	else authHeaders.authorization = `Bearer ${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;
 	}
-};
-const handleResponseCreated = (rawEvent, state) => {
-	return messageStart(state, rawEvent.response);
-};
-const handleOutputItemAdded$1 = (rawEvent, state) => {
-	const events = new Array();
-	const functionCallDetails = extractFunctionCallDetails(rawEvent, state);
-	if (!functionCallDetails) return events;
-	const { outputIndex, toolCallId, name, initialArguments } = functionCallDetails;
-	const blockIndex = openFunctionCallBlock(state, {
-		outputIndex,
-		toolCallId,
-		name,
-		events
+	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, body) {
+	const headers = new Headers(upstreamResponse.headers);
+	for (const headerName of STRIPPED_RESPONSE_HEADERS) headers.delete(headerName);
+	return new Response(body ?? 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)
 	});
-	if (initialArguments !== void 0 && initialArguments.length > 0) {
-		events.push({
-			type: "content_block_delta",
-			index: blockIndex,
-			delta: {
-				type: "input_json_delta",
-				partial_json: initialArguments
-			}
+}
+async function forwardProviderChatCompletions(providerConfig, payload, requestHeaders) {
+	return await fetch(`${providerConfig.baseUrl}/v1/chat/completions`, {
+		method: "POST",
+		headers: buildProviderUpstreamHeaders(providerConfig, requestHeaders),
+		body: JSON.stringify(payload)
+	});
+}
+async function forwardProviderResponses(providerConfig, payload, requestHeaders) {
+	return await fetch(`${providerConfig.baseUrl}/v1/responses`, {
+		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$4 = createHandlerLogger("provider-messages-handler");
+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"
+]);
+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 { payload, provider } = options;
+	const providerConfig = await resolveProviderConfig(provider);
+	if (!providerConfig) return c.json({ error: {
+		message: `Provider '${provider}' not found or disabled`,
+		type: "invalid_request_error"
+	} }, 404);
+	try {
+		const modelConfig = providerConfig.models?.[payload.model];
+		applyModelDefaults(payload, modelConfig);
+		debugJson(logger$4, "provider.messages.request", {
+			payload,
+			provider
 		});
-		state.blockHasDelta.add(blockIndex);
-	}
-	return events;
-};
-const handleOutputItemDone$1 = (rawEvent, state) => {
-	const events = new Array();
-	const item = rawEvent.item;
-	const itemType = item.type;
-	const outputIndex = rawEvent.output_index;
-	if (itemType === "tool_search_call") {
-		const blockIndex = openFunctionCallBlock(state, {
-			outputIndex,
-			toolCallId: item.call_id,
-			name: state.toolSearchName,
-			events
+		if (providerConfig.type === "openai-responses") return await handleOpenAIResponsesProviderMessages(c, {
+			modelConfig,
+			payload,
+			provider,
+			providerConfig
 		});
-		const finalArguments = stringifyToolSearchArguments(item.arguments);
-		if (!state.blockHasDelta.has(blockIndex) && finalArguments) {
-			events.push({
-				type: "content_block_delta",
-				index: blockIndex,
-				delta: {
-					type: "input_json_delta",
-					partial_json: finalArguments
-				}
-			});
-			state.blockHasDelta.add(blockIndex);
-		}
-		state.functionCallStateByOutputIndex.delete(outputIndex);
-		return events;
-	}
-	if (itemType === "compaction") {
-		if (!item.id || !item.encrypted_content) return events;
-		const blockIndex = openThinkingBlockIfNeeded(state, outputIndex, events);
-		if (!state.blockHasDelta.has(blockIndex)) events.push({
-			type: "content_block_delta",
-			index: blockIndex,
-			delta: {
-				type: "thinking_delta",
-				thinking: THINKING_TEXT
-			}
+		if (providerConfig.type === "openai-compatible") return await handleOpenAICompatibleProviderMessages(c, {
+			modelConfig,
+			payload,
+			provider,
+			providerConfig
 		});
-		events.push({
-			type: "content_block_delta",
-			index: blockIndex,
-			delta: {
-				type: "signature_delta",
-				signature: encodeCompactionCarrierSignature({
-					id: item.id,
-					encrypted_content: item.encrypted_content
-				})
-			}
+		applyMissingExtraBody(payload, { extraBody: modelConfig?.extraBody });
+		const upstreamResponse = await forwardProviderMessages(providerConfig, payload, c.req.raw.headers);
+		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,
+			payload,
+			provider,
+			providerConfig,
+			upstreamResponse
 		});
-		state.blockHasDelta.add(blockIndex);
-		return events;
-	}
-	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.push({
-			type: "content_block_delta",
-			index: blockIndex,
-			delta: {
-				type: "thinking_delta",
-				thinking: THINKING_TEXT
-			}
+		return respondProviderMessagesJson(c, {
+			body: await upstreamResponse.json(),
+			payload,
+			provider,
+			providerConfig
 		});
-		events.push({
-			type: "content_block_delta",
-			index: blockIndex,
-			delta: {
-				type: "signature_delta",
-				signature
-			}
+	} catch (error) {
+		logger$4.error("provider.messages.error", {
+			provider,
+			error
 		});
-		state.blockHasDelta.add(blockIndex);
+		throw error;
 	}
-	return events;
-};
-const handleFunctionCallArgumentsDelta = (rawEvent, state) => {
-	const events = new Array();
-	const outputIndex = rawEvent.output_index;
-	const deltaText = rawEvent.delta;
-	if (!deltaText) return events;
-	const blockIndex = openFunctionCallBlock(state, {
-		outputIndex,
-		events
+}
+const handleOpenAIResponsesProviderMessages = async (c, options) => {
+	const { payload, provider, providerConfig } = options;
+	const selectedModel = providerConfig.name === "codex" ? getModels().data.find((model) => model.id === payload.model) : void 0;
+	const responsesPayload = translateAnthropicMessagesToResponsesPayload(payload);
+	applyResponsesApiContextManagement(responsesPayload, selectedModel?.capabilities.limits.max_prompt_tokens);
+	compactInputByLatestCompaction(responsesPayload);
+	debugJson(logger$4, "provider.messages.responses.request", {
+		payload: responsesPayload,
+		provider
 	});
-	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, events);
-	functionCallState.consecutiveWhitespaceCount = nextCount;
-	events.push({
-		type: "content_block_delta",
-		index: blockIndex,
-		delta: {
-			type: "input_json_delta",
-			partial_json: deltaText
-		}
+	const upstreamResponse = providerConfig.name === "codex" ? await forwardCodexResponses(responsesPayload, c.req.raw.headers, providerConfig.baseUrl) : await forwardProviderResponses(providerConfig, responsesPayload, c.req.raw.headers);
+	if (!upstreamResponse.ok) {
+		logger$4.error("Failed to create provider responses", upstreamResponse);
+		throw new HTTPError("Failed to create provider responses", upstreamResponse);
+	}
+	if (responsesPayload.stream) return streamResponsesProviderMessages({
+		c,
+		payload,
+		provider,
+		providerConfig,
+		upstreamResponse
+	});
+	return respondResponsesProviderMessagesJson(c, {
+		body: await upstreamResponse.json(),
+		payload,
+		provider,
+		providerConfig
 	});
-	state.blockHasDelta.add(blockIndex);
-	return events;
 };
-const handleFunctionCallArgumentsDone = (rawEvent, state) => {
-	const events = new Array();
-	const outputIndex = rawEvent.output_index;
-	const blockIndex = openFunctionCallBlock(state, {
-		outputIndex,
-		events
+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 getRequestThinkingBudget = (payload) => {
+	const budget = payload.thinking?.budget_tokens;
+	if (typeof budget !== "number" || !Number.isFinite(budget)) return;
+	return budget;
+};
+const applyOpenAICompatibleThinkingBudget = (payload, source) => {
+	const thinkingBudget = getRequestThinkingBudget(source);
+	if (thinkingBudget !== void 0) {
+		payload.thinking_budget = thinkingBudget;
+		return;
+	}
+	if (payload.thinking_budget === void 0) delete payload.thinking_budget;
+};
+const applyOpenAICompatibleExtraBodyThinkingBudget = (payload, options) => {
+	const { extraBody } = options;
+	if (!extraBody || !Object.hasOwn(extraBody, "thinking_budget")) return;
+	const rawPayload = payload;
+	rawPayload.thinking_budget = extraBody.thinking_budget;
+};
+const handleOpenAICompatibleProviderMessages = async (c, options) => {
+	const { modelConfig, payload, provider, providerConfig } = options;
+	const openAIPayload = createOpenAICompatiblePayload(payload, modelConfig);
+	debugJson(logger$4, "provider.messages.openai_compatible.request", {
+		payload: openAIPayload,
+		provider
 	});
-	const finalArguments = typeof rawEvent.arguments === "string" ? rawEvent.arguments : void 0;
-	if (!state.blockHasDelta.has(blockIndex) && finalArguments) {
-		events.push({
-			type: "content_block_delta",
-			index: blockIndex,
-			delta: {
-				type: "input_json_delta",
-				partial_json: finalArguments
-			}
-		});
-		state.blockHasDelta.add(blockIndex);
+	const upstreamResponse = await forwardProviderChatCompletions(providerConfig, openAIPayload, c.req.raw.headers);
+	if (!upstreamResponse.ok) {
+		logger$4.error("Failed to create openai-compatible responses", upstreamResponse);
+		throw new HTTPError("Failed to create openai-compatible responses", upstreamResponse);
 	}
-	state.functionCallStateByOutputIndex.delete(outputIndex);
-	return events;
-};
-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;
-	const blockIndex = openTextBlockIfNeeded(state, {
-		outputIndex,
-		contentIndex,
-		events
+	const contentType = upstreamResponse.headers.get("content-type") ?? "";
+	if (Boolean(openAIPayload.stream) && contentType.includes("text/event-stream")) return streamOpenAICompatibleProviderMessages({
+		c,
+		payload,
+		provider,
+		upstreamResponse
 	});
-	events.push({
-		type: "content_block_delta",
-		index: blockIndex,
-		delta: {
-			type: "text_delta",
-			text: deltaText
-		}
+	return respondOpenAICompatibleProviderMessagesJson(c, {
+		body: await upstreamResponse.json(),
+		payload,
+		provider
 	});
-	state.blockHasDelta.add(blockIndex);
-	return events;
 };
-const handleReasoningSummaryTextDelta = (rawEvent, state) => {
-	const outputIndex = rawEvent.output_index;
-	const deltaText = rawEvent.delta;
-	const events = new Array();
-	const blockIndex = openThinkingBlockIfNeeded(state, outputIndex, events);
-	events.push({
-		type: "content_block_delta",
-		index: blockIndex,
-		delta: {
-			type: "thinking_delta",
-			thinking: deltaText
-		}
+const createOpenAICompatiblePayload = (payload, modelConfig) => {
+	const openAIPayload = translateToOpenAI(payload, {
+		supportPdf: modelConfig?.supportPdf,
+		toolContentSupportType: modelConfig?.toolContentSupportType ?? []
 	});
-	state.blockHasDelta.add(blockIndex);
-	return events;
-};
-const handleReasoningSummaryTextDone = (rawEvent, state) => {
-	const outputIndex = rawEvent.output_index;
-	const text = rawEvent.text;
-	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: {
-			type: "thinking_delta",
-			thinking: text
-		}
+	applyOpenAICompatibleThinkingBudget(openAIPayload, payload);
+	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
 	});
-	return events;
+	applyMissingExtraBody(openAIPayload, { extraBody: modelConfig?.extraBody });
+	applyOpenAICompatibleExtraBodyThinkingBudget(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 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, {
-		outputIndex,
-		contentIndex,
-		events
-	});
-	if (text && !state.blockHasDelta.has(blockIndex)) events.push({
-		type: "content_block_delta",
-		index: blockIndex,
-		delta: {
-			type: "text_delta",
-			text
-		}
-	});
-	return events;
+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 handleResponseCompleted = (rawEvent, state) => {
-	const response = rawEvent.response;
-	const events = new Array();
-	closeAllOpenBlocks(state, events);
-	const anthropic = translateResponsesResultToAnthropic(response);
-	events.push({
-		type: "message_delta",
-		delta: {
-			stop_reason: anthropic.stop_reason,
-			stop_sequence: anthropic.stop_sequence
-		},
-		usage: anthropic.usage
-	}, { type: "message_stop" });
-	state.messageCompleted = true;
-	return events;
+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 handleResponseFailed = (rawEvent, state) => {
-	const response = rawEvent.response;
-	const events = new Array();
-	closeAllOpenBlocks(state, events);
-	const message = response.error?.message ?? "The response failed due to an unknown error.";
-	events.push(buildErrorEvent(message));
-	state.messageCompleted = true;
-	return events;
+const applyOpenAICompatibleContextCache = (payload) => {
+	const messageIndexes = selectContextCacheMessageIndexes(payload.messages);
+	for (const messageIndex of messageIndexes) applyContextCacheControl(payload.messages[messageIndex]);
 };
-const handleErrorEvent = (rawEvent, state) => {
-	const message = typeof rawEvent.message === "string" ? rawEvent.message : "An unexpected error occurred during streaming.";
-	state.messageCompleted = true;
-	return [buildErrorEvent(message)];
+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$1([...systemIndexes, ...finalIndexes]).sort((a, b) => a - b);
 };
-const handleFunctionCallArgumentsValidationError = (error, state, events = []) => {
-	const reason = error.message;
-	closeAllOpenBlocks(state, events);
-	state.messageCompleted = true;
-	events.push(buildErrorEvent(reason));
-	return events;
+const uniqueIndexes$1 = (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 messageStart = (state, response) => {
-	state.messageStartSent = true;
-	const inputCachedTokens = response.usage?.input_tokens_details?.cached_tokens;
-	const inputTokens = (response.usage?.input_tokens ?? 0) - (inputCachedTokens ?? 0);
-	return [{
-		type: "message_start",
-		message: {
-			id: response.id,
-			type: "message",
-			role: "assistant",
-			content: [],
-			model: response.model,
-			stop_reason: null,
-			stop_sequence: null,
-			usage: {
-				input_tokens: inputTokens,
-				output_tokens: 0,
-				cache_read_input_tokens: inputCachedTokens ?? 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, payload, provider, providerConfig, upstreamResponse }) => {
+	logger$4.debug("provider.messages.streaming");
+	const recordUsage = createProviderMessagesUsageRecorder(payload, provider);
+	return streamSSE(c, async (stream) => {
+		let usage = {};
+		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]") break;
+			const parsed = parseProviderStreamEvent(data, providerConfig);
+			if (parsed) {
+				usage = mergeAnthropicUsage(usage, parsed.usage);
+				data = parsed.data;
+			}
+			await stream.writeSSE({
+				event: eventName,
+				data
+			});
+		}
+		recordUsage(usage);
+	});
+};
+const streamOpenAICompatibleProviderMessages = ({ c, payload, provider, upstreamResponse }) => {
+	logger$4.debug("provider.messages.openai_compatible.streaming");
+	const recordUsage = createProviderMessagesUsageRecorder(payload, provider);
+	return streamSSE(c, async (stream) => {
+		let usage = {};
+		const streamState = {
+			messageStartSent: false,
+			contentBlockIndex: 0,
+			contentBlockOpen: false,
+			toolCalls: {},
+			thinkingBlockOpen: 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 || chunk.data === "[DONE]") {
+				if (chunk.data === "[DONE]") break;
+				continue;
+			}
+			const parsed = parseOpenAICompatibleStreamChunk(chunk.data);
+			if (!parsed) continue;
+			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
+				});
 			}
 		}
-	}];
+		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
+			});
+		}
+		recordUsage(usage);
+	});
 };
-const openTextBlockIfNeeded = (state, params) => {
-	const { outputIndex, contentIndex, events } = params;
-	const key = getBlockKey(outputIndex, contentIndex);
-	let blockIndex = state.blockIndexByKey.get(key);
-	if (blockIndex === void 0) {
-		blockIndex = state.nextContentBlockIndex;
-		state.nextContentBlockIndex += 1;
-		state.blockIndexByKey.set(key, blockIndex);
-	}
-	if (!state.openBlocks.has(blockIndex)) {
-		closeOpenBlocks(state, events);
-		events.push({
-			type: "content_block_start",
-			index: blockIndex,
-			content_block: {
-				type: "text",
-				text: ""
+const streamResponsesProviderMessages = ({ c, payload, provider, providerConfig, upstreamResponse }) => {
+	logger$4.debug("provider.messages.responses.streaming", { provider });
+	const recordUsage = createProviderMessagesUsageRecorder(payload, provider);
+	return streamSSE(c, async (stream) => {
+		let usage = {};
+		const streamState = createResponsesStreamState({ toolSearchName: resolveBridgeToolSearchName(payload.tools) });
+		for await (const chunk of events(upstreamResponse)) {
+			logger$4.debug("provider.messages.responses.raw_stream_event:", chunk.data);
+			if (chunk.event === "ping") {
+				await stream.writeSSE({
+					event: "ping",
+					data: "{\"type\":\"ping\"}"
+				});
+				continue;
+			}
+			if (!chunk.data || chunk.data === "[DONE]") {
+				if (chunk.data === "[DONE]") break;
+				continue;
+			}
+			const parsed = parseResponsesProviderStreamChunk(chunk.data, providerConfig);
+			if (!parsed) continue;
+			if (parsed.type === "response.completed" || parsed.type === "response.failed" || parsed.type === "response.incomplete") usage = normalizeResponsesUsage(parsed.response.usage);
+			const events = translateResponsesStreamEvent(parsed, streamState);
+			for (const event of events) {
+				const eventData = JSON.stringify(event);
+				debugLazy(logger$4, () => ["provider.messages.responses.translated_event:", eventData]);
+				await stream.writeSSE({
+					event: event.type,
+					data: eventData
+				});
 			}
+		}
+		if (!streamState.messageCompleted) {
+			const errorEvent = buildErrorEvent(`${provider} stream ended without a completion event`);
+			await stream.writeSSE({
+				event: errorEvent.type,
+				data: JSON.stringify(errorEvent)
+			});
+		}
+		recordUsage(usage);
+	});
+};
+const parseOpenAICompatibleStreamChunk = (data) => {
+	try {
+		return JSON.parse(data);
+	} catch (error) {
+		logger$4.error("provider.messages.openai_compatible.parse_chunk_error", {
+			data,
+			error
 		});
-		state.openBlocks.add(blockIndex);
+		return null;
 	}
-	return blockIndex;
 };
-const openThinkingBlockIfNeeded = (state, outputIndex, events) => {
-	const key = getBlockKey(outputIndex, 0);
-	let blockIndex = state.blockIndexByKey.get(key);
-	if (blockIndex === void 0) {
-		blockIndex = state.nextContentBlockIndex;
-		state.nextContentBlockIndex += 1;
-		state.blockIndexByKey.set(key, blockIndex);
-	}
-	if (!state.openBlocks.has(blockIndex)) {
-		closeOpenBlocks(state, events);
-		events.push({
-			type: "content_block_start",
-			index: blockIndex,
-			content_block: {
-				type: "thinking",
-				thinking: ""
-			}
+const parseResponsesProviderStreamChunk = (data, providerConfig) => {
+	try {
+		const parsed = JSON.parse(data);
+		if (providerConfig.name === "codex") logCodexRateLimitsEvent(parsed);
+		return providerConfig.name === "codex" ? normalizeCodexResponsesEvent(parsed) : parsed;
+	} catch (error) {
+		logger$4.error("provider.messages.responses.parse_chunk_error", {
+			provider: providerConfig.name,
+			data,
+			error
 		});
-		state.openBlocks.add(blockIndex);
+		return null;
 	}
-	return blockIndex;
-};
-const closeBlockIfOpen = (state, blockIndex, events) => {
-	if (!state.openBlocks.has(blockIndex)) return;
-	events.push({
-		type: "content_block_stop",
-		index: blockIndex
-	});
-	state.openBlocks.delete(blockIndex);
-	state.blockHasDelta.delete(blockIndex);
-};
-const closeOpenBlocks = (state, events) => {
-	for (const blockIndex of state.openBlocks) closeBlockIfOpen(state, blockIndex, events);
-};
-const closeAllOpenBlocks = (state, events) => {
-	closeOpenBlocks(state, events);
-	state.functionCallStateByOutputIndex.clear();
 };
-const buildErrorEvent = (message) => ({
-	type: "error",
-	error: {
-		type: "api_error",
-		message
-	}
-});
-const getBlockKey = (outputIndex, contentIndex) => `${outputIndex}:${contentIndex}`;
-const openFunctionCallBlock = (state, params) => {
-	const { outputIndex, toolCallId, name, events } = params;
-	let functionCallState = state.functionCallStateByOutputIndex.get(outputIndex);
-	if (!functionCallState) {
-		const blockIndex = state.nextContentBlockIndex;
-		state.nextContentBlockIndex += 1;
-		functionCallState = {
-			blockIndex,
-			toolCallId: toolCallId ?? `tool_call_${blockIndex}`,
-			name: name ?? "function",
-			consecutiveWhitespaceCount: 0
+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),
+				model: parsed.message.model,
+				usage: normalizeAnthropicUsage(parsed.message.usage)
+			};
+		}
+		if (parsed.type === "message_delta") {
+			adjustInputTokens(providerConfig, parsed.usage);
+			return {
+				data: JSON.stringify(parsed),
+				usage: normalizeAnthropicUsage(parsed.usage)
+			};
+		}
+		return {
+			data: JSON.stringify(parsed),
+			usage: {}
 		};
-		state.functionCallStateByOutputIndex.set(outputIndex, functionCallState);
-	}
-	const { blockIndex } = functionCallState;
-	if (!state.openBlocks.has(blockIndex)) {
-		closeOpenBlocks(state, events);
-		events.push({
-			type: "content_block_start",
-			index: blockIndex,
-			content_block: {
-				type: "tool_use",
-				id: functionCallState.toolCallId,
-				name: functionCallState.name,
-				input: {}
-			}
+	} catch (error) {
+		logger$4.error("provider.messages.streaming.adjust_tokens_error", {
+			error,
+			originalData: data
 		});
-		state.openBlocks.add(blockIndex);
+		return null;
 	}
-	return blockIndex;
 };
-const extractFunctionCallDetails = (rawEvent, state) => {
-	const item = rawEvent.item;
-	const itemType = item.type;
-	if (itemType === "tool_search_call") return {
-		outputIndex: rawEvent.output_index,
-		toolCallId: item.call_id,
-		name: state.toolSearchName,
-		initialArguments: ""
-	};
-	if (itemType !== "function_call") return;
-	return {
-		outputIndex: rawEvent.output_index,
-		toolCallId: item.call_id,
-		name: resolveToolUseName(item),
-		initialArguments: item.arguments
-	};
+const respondProviderMessagesJson = (c, options) => {
+	const { body, payload, provider, providerConfig } = options;
+	const recordUsage = createProviderMessagesUsageRecorder(payload, provider);
+	adjustInputTokens(providerConfig, body.usage);
+	recordUsage(normalizeAnthropicUsage(body.usage));
+	debugJson(logger$4, "provider.messages.no_stream result:", body);
+	return c.json(body);
 };
-const stringifyToolSearchArguments = (argumentsValue) => {
-	try {
-		return JSON.stringify(formatToolSearchBridgeArguments(argumentsValue));
-	} catch {
-		return;
-	}
+const respondOpenAICompatibleProviderMessagesJson = (c, options) => {
+	const { body, payload, provider } = options;
+	createProviderMessagesUsageRecorder(payload, provider)(normalizeOpenAIUsage(body.usage));
+	const anthropicResponse = translateToAnthropic(body);
+	debugJson(logger$4, "provider.messages.openai_compatible.no_stream result:", anthropicResponse);
+	return c.json(anthropicResponse);
+};
+const respondResponsesProviderMessagesJson = (c, options) => {
+	const { body, payload, provider, providerConfig } = options;
+	createProviderMessagesUsageRecorder(payload, provider)(normalizeResponsesUsage(body.usage));
+	const anthropicResponse = translateResponsesResultToAnthropic(body, { toolSearchName: resolveBridgeToolSearchName(payload.tools) });
+	debugJson(logger$4, "provider.messages.responses.no_stream result:", anthropicResponse);
+	if (providerConfig.name === "codex") logger$4.debug("provider.messages.codex.no_stream.result");
+	return c.json(anthropicResponse);
+};
+const createProviderMessagesUsageRecorder = (payload, provider) => createProviderTokenUsageRecorder({
+	endpoint: "provider_messages",
+	model: payload.model,
+	providerName: provider,
+	sessionId: parseUserIdMetadata(payload.metadata?.user_id).sessionId
+});
+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/services/copilot/create-messages.ts
@@ -4775,11 +4771,19 @@ const providerModelRoutes = new Hono();
 providerModelRoutes.get("/", async (c) => {
 	const provider = c.req.param("provider") ?? "";
 	try {
-		const providerConfig = getProviderConfig(provider);
+		const providerConfig = await resolveProviderConfig(provider);
 		if (!providerConfig) return c.json({ error: {
 			message: `Provider '${provider}' not found or disabled`,
 			type: "invalid_request_error"
 		} }, 404);
+		if (providerConfig.name === "codex") {
+			const models = getModels();
+			return c.json({
+				object: "list",
+				data: models.data,
+				has_more: false
+			});
+		}
 		const upstreamResponse = await forwardProviderModels(providerConfig, c.req.raw.headers);
 		logger$2.debug("provider.models.response", {
 			provider,
@@ -4839,9 +4843,17 @@ const responsesHandlerDependencies = {
 	isResponsesApiWebSearchEnabled
 };
 const handleResponses = async (c) => {
-	await responsesHandlerDependencies.checkRateLimit(state);
 	const payload = await c.req.json();
 	debugJson(logger$1, "Responses request payload:", payload);
+	const providerModelAlias = parseProviderModelAlias(payload.model);
+	if (providerModelAlias) {
+		payload.model = providerModelAlias.model;
+		return await handleProviderResponsesForProvider(c, {
+			payload,
+			provider: providerModelAlias.provider
+		});
+	}
+	await responsesHandlerDependencies.checkRateLimit(state);
 	const requestId = generateRequestIdFromPayload({ messages: payload.input });
 	logger$1.debug("Generated request ID:", requestId);
 	const sessionId = getUUID(requestId);
@@ -4897,6 +4909,30 @@ const handleResponses = async (c) => {
 	recordUsage(normalizeResponsesUsage(response.usage));
 	return c.json(response);
 };
+const handleProviderResponsesForProvider = async (c, options) => {
+	const { payload, provider } = options;
+	const providerConfig = await resolveProviderConfig(provider);
+	if (providerConfig?.type !== "openai-responses") return c.json({ error: {
+		message: `Provider '${provider}' does not support the /v1/responses endpoint`,
+		type: "invalid_request_error"
+	} }, 400);
+	const upstreamResponse = providerConfig.name === "codex" ? await forwardCodexResponses(payload, c.req.raw.headers, providerConfig.baseUrl) : await forwardProviderResponses(providerConfig, payload, c.req.raw.headers);
+	if (!upstreamResponse.ok) throw new HTTPError(`Failed to create ${provider} responses`, upstreamResponse);
+	const recordUsage = createProviderResponsesUsageRecorder(payload, provider);
+	if (payload.stream) recordProviderResponsesStreamUsage(upstreamResponse.clone(), {
+		normalizeCodex: providerConfig.name === "codex",
+		provider,
+		recordUsage
+	}).catch((error) => {
+		logger$1.warn("provider.responses.usage_stream_error", {
+			provider,
+			error: getErrorMessage(error)
+		});
+	});
+	else recordUsage(normalizeResponsesUsage((await upstreamResponse.clone().json()).usage));
+	if (providerConfig.name === "codex" && payload.stream) return createProviderProxyResponse(upstreamResponse, createStandardizedCodexResponsesEventStream(getResponsesEvents(upstreamResponse)));
+	return createProviderProxyResponse(upstreamResponse);
+};
 const isAsyncIterable = (value) => Boolean(value) && typeof value[Symbol.asyncIterator] === "function";
 const isStreamingRequested = (payload) => Boolean(payload.stream);
 const parseResponsesStreamEvent = (chunk) => {
@@ -4908,6 +4944,51 @@ const parseResponsesStreamEvent = (chunk) => {
 		return null;
 	}
 };
+const getErrorMessage = (error) => {
+	if (error instanceof Error && error.message) return error.message;
+	return String(error);
+};
+const createProviderResponsesUsageRecorder = (payload, provider) => {
+	const sessionAffinity = requestContext.getStore()?.sessionAffinity?.trim() || null;
+	return createProviderTokenUsageRecorder({
+		endpoint: "responses",
+		model: payload.model,
+		providerName: provider,
+		sessionId: sessionAffinity ?? ""
+	});
+};
+const recordProviderResponsesStreamUsage = async (upstreamResponse, options) => {
+	let usage = {};
+	try {
+		for await (const chunk of getResponsesEvents(upstreamResponse)) {
+			debugJson(logger$1, "Responses stream chunk:", chunk);
+			if (!chunk.data || chunk.data === "[DONE]") continue;
+			const parsed = parseProviderResponsesStreamEvent(chunk.data, {
+				normalizeCodex: options.normalizeCodex,
+				provider: options.provider
+			});
+			if (parsed?.type === "response.completed" || parsed?.type === "response.failed" || parsed?.type === "response.incomplete") usage = normalizeResponsesUsage(parsed.response.usage);
+		}
+	} finally {
+		options.recordUsage(usage);
+	}
+};
+const parseProviderResponsesStreamEvent = (data, options) => {
+	try {
+		const parsed = JSON.parse(data);
+		return options.normalizeCodex ? normalizeCodexResponsesEvent(parsed) : parsed;
+	} catch (error) {
+		logger$1.error("provider.responses.parse_chunk_error", {
+			provider: options.provider,
+			data,
+			error
+		});
+		return null;
+	}
+};
+const getResponsesEvents = (response) => {
+	return events(response);
+};
 const removeWebSearchTool = (payload) => {
 	if (!Array.isArray(payload.tools) || payload.tools.length === 0) return;
 	payload.tools = payload.tools.filter((t) => {
@@ -5040,4 +5121,4 @@ server.route("/:provider/v1/models", providerModelRoutes);
 //#endregion
 export { server };
 
-//# sourceMappingURL=server-FPXzFkg9.js.map
+//# sourceMappingURL=server-D5O9IzAY.js.map