@jeffreycao/copilot-api 1.14.23 → 1.15.0

package/dist/{server-D8An7dpg.js → server-DZtBoW6V.js}

@@ -1,7 +1,7 @@
-import { D as setModelMappings, E as resolveProviderAuthType, T as resolveMappedModel, _ as isMessagesApiEnabled, a as getConfig, c as getModelMappings, d as getRawProviderConfig, f as getReasoningEffortForModel, g as isGpt56OrAbove, h as isContextManagementEnabledForResponses, i as getClaudeTokenMultiplier, k as PATHS, l as getModelResponsesApiCompactThreshold$1, m as isContextManagementEnabledForMessages, n as getAnthropicApiKey, o as getExtraPromptForModel, p as getSmallModel, r as getClaudeAutoModel, s as getMessageApiWebSearchModel, u as getProviderConfig, v as isResponsesApiWebSearchEnabled, w as resolveEffectiveProviderType, x as listEnabledProviders, y as isResponsesApiWebSocketEnabled } from "./config-NTX23mAe.js";
-import { B as HTTPError, C as prepareMessageProxyHeaders, E as compactMessageSections, F as requestContext, I as resolveTraceId$1, L as createPooledWebSocketStream, M as buildCodexRequestHeaders, N as forwardCodexResponses, O as compactSystemPromptStarts, P as generateTraceId, R as createWebSocketUrl, S as prepareInteractionHeaders, T as compactAutoContinuePromptStarts, V as forwardError, b as copilotWebSocketHeaders, d as generateRequestIdFromPayload, f as getRootSessionId, g as getCopilotUsage, h as parseUserIdMetadata, j as CODEX_API_BASE_URL, m as isNullish, p as getUUID, r as setupCodexToken, v as copilotBaseUrl, x as prepareForCompact, y as copilotHeaders, z as state } from "./token-BjW645tq.js";
+import { A as PATHS, D as resolveProviderAuthType, E as resolveMappedModel, O as setModelMappings, S as listEnabledProviders, T as resolveEffectiveProviderType, _ as isGpt56OrAbove, a as getConfig, b as isResponsesApiWebSocketEnabled, c as getModelMappings, d as getRawProviderConfig, f as getReasoningEffortForModel, g as isContextManagementEnabledForResponses, h as isContextManagementEnabledForMessages, i as getClaudeTokenMultiplier, l as getModelResponsesApiCompactThreshold$1, m as isAlphaSearchCodexPriorityEnabled, n as getAnthropicApiKey, o as getExtraPromptForModel, p as getSmallModel, r as getClaudeAutoModel, s as getMessageApiWebSearchModel, u as getProviderConfig, v as isMessagesApiEnabled, y as isResponsesApiWebSearchEnabled } from "./config-B3hsNlmB.js";
+import { B as HTTPError, C as prepareMessageProxyHeaders, E as compactMessageSections, F as requestContext, I as resolveTraceId$1, L as createPooledWebSocketStream, M as buildCodexRequestHeaders, N as forwardCodexResponses, O as compactSystemPromptStarts, P as generateTraceId, R as createWebSocketUrl, S as prepareInteractionHeaders, T as compactAutoContinuePromptStarts, V as forwardError, b as copilotWebSocketHeaders, d as generateRequestIdFromPayload, f as getRootSessionId, g as getCopilotUsage, h as parseUserIdMetadata, j as CODEX_API_BASE_URL, m as isNullish, p as getUUID, r as setupCodexToken, v as copilotBaseUrl, x as prepareForCompact, y as copilotHeaders, z as state } from "./token-DArgO8vi.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-Ds1vbmGG.js";
-import { i as toClientModelId, r as normalizeSdkModelId, t as findEndpointModel } from "./models-D-Rwtv0H.js";
+import { i as toClientModelId, r as normalizeSdkModelId, t as findEndpointModel } from "./models-_FSj4UOe.js";
 import consola from "consola";
 import { createHash } from "node:crypto";
 import fs, { readFileSync } from "node:fs";
@@ -327,203 +327,6 @@ const createHandlerLogger = (name) => {
 	return instance;
 };
 //#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/services/codex/alpha-search.ts
-const CODEX_ALPHA_SEARCH_URL = `${CODEX_API_BASE_URL}/codex/alpha/search`;
-function resolveCodexAlphaSearchUrl(requestUrl) {
-	const upstreamUrl = new URL(CODEX_ALPHA_SEARCH_URL);
-	upstreamUrl.search = new URL(requestUrl, "http://localhost").search;
-	return upstreamUrl.toString();
-}
-async function forwardCodexAlphaSearch(request) {
-	const headers = buildCodexRequestHeaders(request.headers);
-	if (!headers.has("accept")) headers.set("accept", "application/json");
-	const body = await request.arrayBuffer();
-	if (!headers.has("content-type")) headers.set("content-type", "application/json");
-	return await fetch(resolveCodexAlphaSearchUrl(request.url), {
-		method: "POST",
-		headers,
-		body
-	});
-}
-//#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;
-	}
-	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) {
-	consola.log(`<-- model: ${payload.model}`);
-	return await fetch(`${providerConfig.baseUrl}/v1/messages`, {
-		method: "POST",
-		headers: buildProviderUpstreamHeaders(providerConfig, requestHeaders),
-		body: JSON.stringify(payload)
-	});
-}
-async function forwardProviderChatCompletions(providerConfig, payload, requestHeaders) {
-	consola.log(`<-- model: ${payload.model}`);
-	return await fetch(`${providerConfig.baseUrl}/v1/chat/completions`, {
-		method: "POST",
-		headers: buildProviderUpstreamHeaders(providerConfig, requestHeaders),
-		body: JSON.stringify(payload)
-	});
-}
-async function forwardProviderResponses(providerConfig, payload, requestHeaders) {
-	consola.log(`<-- model: ${payload.model}`);
-	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)
-	});
-}
-/** Align with Codex images: long-running generation/edits need a generous cap. */
-const PROVIDER_IMAGES_TIMEOUT_MS = 900 * 1e3;
-const providerImagesDispatcher = { dispatch(options, handler) {
-	return getGlobalDispatcher().dispatch({
-		...options,
-		bodyTimeout: PROVIDER_IMAGES_TIMEOUT_MS,
-		headersTimeout: PROVIDER_IMAGES_TIMEOUT_MS
-	}, handler);
-} };
-function resolveProviderRequestUrl(providerConfig, requestUrl, path) {
-	const upstreamUrl = new URL(`${providerConfig.baseUrl}${path}`);
-	upstreamUrl.search = new URL(requestUrl, "http://localhost").search;
-	return upstreamUrl.toString();
-}
-async function forwardProviderAlphaSearch(providerConfig, request) {
-	const headers = buildProviderUpstreamHeaders(providerConfig, request.headers);
-	const body = await request.arrayBuffer();
-	return await fetch(resolveProviderRequestUrl(providerConfig, request.url, "/v1/alpha/search"), {
-		method: "POST",
-		headers,
-		body
-	});
-}
-async function forwardProviderImages(providerConfig, request, operation) {
-	const headers = buildProviderUpstreamHeaders(providerConfig, request.headers);
-	const contentType = request.headers.get("content-type");
-	if (contentType) headers["content-type"] = contentType;
-	else if (operation === "edits") delete headers["content-type"];
-	const init = {
-		method: "POST",
-		headers,
-		body: request.body,
-		duplex: "half",
-		signal: AbortSignal.timeout(PROVIDER_IMAGES_TIMEOUT_MS)
-	};
-	const upstreamUrl = resolveProviderRequestUrl(providerConfig, request.url, `/v1/images/${operation}`);
-	if (typeof Bun !== "undefined") return await fetch(upstreamUrl, init);
-	return await fetch$1(upstreamUrl, {
-		...init,
-		dispatcher: providerImagesDispatcher
-	});
-}
-//#endregion
-//#region src/routes/alpha-search/route.ts
-const logger$14 = createHandlerLogger("alpha-search-handler");
-const alphaSearchRoutes = new Hono();
-function parseDebugBody(body) {
-	try {
-		return JSON.parse(body);
-	} catch {
-		return body;
-	}
-}
-/**
-* Handles Codex alpha-search proxying. Pass `resolvedProviderConfig` when the
-* caller already resolved the codex provider to avoid a second resolve.
-*/
-async function handleCodexAlphaSearch(c, resolvedProviderConfig) {
-	if (!(resolvedProviderConfig ?? await resolveProviderConfig("codex"))) return c.json({ error: {
-		message: "Provider 'codex' not found or disabled",
-		type: "invalid_request_error"
-	} }, 404);
-	await debugJsonAsync(logger$14, "alpha_search.codex.request", async () => ({ body: parseDebugBody(await c.req.raw.clone().text()) }));
-	const upstreamResponse = await forwardCodexAlphaSearch(c.req.raw);
-	await debugJsonAsync(logger$14, "alpha_search.codex.response", async () => ({
-		body: parseDebugBody(await upstreamResponse.clone().text()),
-		statusCode: upstreamResponse.status
-	}));
-	return createProviderProxyResponse(upstreamResponse);
-}
-alphaSearchRoutes.post("/", async (c) => {
-	try {
-		return await handleCodexAlphaSearch(c);
-	} catch (error) {
-		logger$14.error("alpha_search.codex.error", { error });
-		return await forwardError(c, error);
-	}
-});
-//#endregion
 //#region src/lib/provider-model.ts
 const parseProviderModelAlias = (model) => {
 	const separatorIndex = model.indexOf("/");
@@ -554,6 +357,31 @@ const createFallbackModel = (modelId) => ({
 	version: "unknown"
 });
 //#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/lib/event-bus.ts
 var EventBus = class {
 	handlers = /* @__PURE__ */ new Map();
@@ -1671,34 +1499,1161 @@ function normalizeOptionalCost(value) {
 	return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : void 0;
 }
 //#endregion
-//#region src/lib/dashscope.ts
-const OPENAI_COMPATIBLE_CONTEXT_CACHE_MARKER_LIMIT = 4;
-const OPENAI_COMPATIBLE_CONTEXT_CACHE_CONTROL = { type: "ephemeral" };
-const OPENAI_COMPATIBLE_CONTEXT_CACHE_ROLES = new Set([
-	"system",
-	"user",
-	"assistant",
-	"tool"
-]);
-const isDashScopeAliyunProvider = (providerConfig) => providerConfig.name === "dashscope" || providerConfig.baseUrl.includes("aliyuncs.com");
-const applyDashScopePreserveThinkingDefault = (payload, providerConfig) => {
-	if (!isDashScopeAliyunProvider(providerConfig)) return;
-	if (!Object.hasOwn(payload, "preserve_thinking")) payload.preserve_thinking = true;
-};
-const applyOpenAICompatibleContextCache = (payload) => {
-	const messageIndexes = selectContextCacheMessageIndexes(payload.messages);
-	for (const messageIndex of messageIndexes) applyContextCacheControl(payload.messages[messageIndex]);
+//#region src/routes/alpha-search/alpha-search-types.ts
+const unsignedInteger = z.number().int().nonnegative();
+const passthroughRecord = z.record(z.string(), z.unknown());
+const searchQuerySchema = z.object({
+	q: z.string(),
+	recency: unsignedInteger.optional(),
+	domains: z.array(z.string()).optional()
+}).loose();
+const openOperationSchema = z.object({
+	ref_id: z.string(),
+	lineno: unsignedInteger.optional()
+}).loose();
+const clickOperationSchema = z.object({
+	ref_id: z.string(),
+	id: unsignedInteger
+}).loose();
+const findOperationSchema = z.object({
+	ref_id: z.string(),
+	pattern: z.string()
+}).loose();
+const screenshotOperationSchema = z.object({
+	ref_id: z.string(),
+	pageno: unsignedInteger
+}).loose();
+const financeOperationSchema = z.object({
+	ticker: z.string(),
+	type: z.enum([
+		"equity",
+		"fund",
+		"crypto",
+		"index"
+	]),
+	market: z.string().optional()
+}).loose();
+const weatherOperationSchema = z.object({
+	location: z.string(),
+	start: z.string().optional(),
+	duration: unsignedInteger.optional()
+}).loose();
+const sportsOperationSchema = z.object({
+	tool: z.literal("sports").optional(),
+	fn: z.enum(["schedule", "standings"]),
+	league: z.enum([
+		"nba",
+		"wnba",
+		"nfl",
+		"nhl",
+		"mlb",
+		"epl",
+		"ncaamb",
+		"ncaawb",
+		"ipl"
+	]),
+	team: z.string().optional(),
+	opponent: z.string().optional(),
+	date_from: z.string().optional(),
+	date_to: z.string().optional(),
+	num_games: unsignedInteger.optional(),
+	locale: z.string().optional()
+}).loose();
+const timeOperationSchema = z.object({ utc_offset: z.string().regex(/^[+-](?:[01]\d|2[0-3]):[0-5]\d$/u) }).loose();
+const alphaSearchCommandsSchema = z.object({
+	search_query: z.array(searchQuerySchema).optional(),
+	image_query: z.array(searchQuerySchema).optional(),
+	open: z.array(openOperationSchema).optional(),
+	click: z.array(clickOperationSchema).optional(),
+	find: z.array(findOperationSchema).optional(),
+	screenshot: z.array(screenshotOperationSchema).optional(),
+	finance: z.array(financeOperationSchema).optional(),
+	weather: z.array(weatherOperationSchema).optional(),
+	sports: z.array(sportsOperationSchema).optional(),
+	time: z.array(timeOperationSchema).optional(),
+	response_length: z.enum([
+		"short",
+		"medium",
+		"long"
+	]).optional()
+}).loose();
+const reasoningSchema = z.object({
+	effort: z.string().min(1).nullable().optional(),
+	summary: z.enum([
+		"auto",
+		"concise",
+		"detailed",
+		"none"
+	]).nullable().optional(),
+	context: z.enum([
+		"auto",
+		"current_turn",
+		"all_turns"
+	]).nullable().optional()
+}).loose();
+const settingsSchema = z.object({
+	user_location: z.object({
+		type: z.literal("approximate"),
+		country: z.string().optional(),
+		region: z.string().optional(),
+		city: z.string().optional(),
+		timezone: z.string().optional()
+	}).loose().optional(),
+	search_context_size: z.enum([
+		"low",
+		"medium",
+		"high"
+	]).optional(),
+	filters: z.object({
+		allowed_domains: z.array(z.string()).optional(),
+		blocked_domains: z.array(z.string()).optional()
+	}).loose().optional(),
+	image_settings: z.object({
+		max_results: unsignedInteger.optional(),
+		caption: z.boolean().optional()
+	}).loose().optional(),
+	allowed_callers: z.array(z.enum([
+		"direct",
+		"shell",
+		"code_interpreter"
+	])).optional(),
+	external_web_access: z.union([z.boolean(), z.enum([
+		"cached",
+		"indexed",
+		"live"
+	])]).optional()
+}).loose();
+const alphaSearchRequestSchema = z.object({
+	id: z.string(),
+	model: z.string(),
+	reasoning: reasoningSchema.optional(),
+	input: z.union([z.string(), z.array(passthroughRecord)]).optional(),
+	commands: alphaSearchCommandsSchema.optional(),
+	settings: settingsSchema.optional(),
+	max_output_tokens: unsignedInteger.optional()
+}).loose();
+//#endregion
+//#region src/routes/messages/web-search/backend.ts
+/** Builds the Responses API web_search tool object from normalized config. */
+const buildResponsesWebSearchTool = (config) => {
+	const tool = { type: "web_search" };
+	const filters = {};
+	if (config.allowedDomains?.length) filters.allowed_domains = config.allowedDomains;
+	if (config.blockedDomains?.length) filters.blocked_domains = config.blockedDomains;
+	if (Object.keys(filters).length > 0) tool.filters = filters;
+	if (config.userLocation) tool.user_location = config.userLocation;
+	if (config.searchContextSize) tool.search_context_size = config.searchContextSize;
+	return tool;
 };
-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(-1);
-	return uniqueIndexes$1([...systemIndexes, ...finalIndexes]).sort((a, b) => a - b);
+const isMessageItem = (item) => item.type === "message";
+const isValidUrlCitation = (annotation, seenUrls) => {
+	const ann = annotation;
+	return ann.type === "url_citation" && Boolean(ann.url) && !seenUrls.has(ann.url);
 };
-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;
+const collectTextParts = (blocks, seenUrls) => {
+	const textParts = [];
+	const sources = [];
+	for (const block of blocks ?? []) {
+		if (block.type !== "output_text") continue;
+		if (block.text) textParts.push(block.text);
+		for (const annotation of block.annotations ?? []) {
+			if (!isValidUrlCitation(annotation, seenUrls)) continue;
+			const ann = annotation;
+			seenUrls.add(ann.url);
+			const start = Math.max(0, (ann.start_index ?? 0) - 120);
+			const end = Math.min(block.text?.length ?? 0, (ann.end_index ?? block.text?.length ?? 0) + 120);
+			sources.push({
+				url: ann.url,
+				title: ann.title ?? ann.url,
+				snippet: block.text?.slice(start, end).trim()
+			});
+		}
+	}
+	return {
+		textParts,
+		sources
+	};
+};
+const collectQuery = (item, queries) => {
+	if (item.action?.queries?.length) queries.push(...item.action.queries);
+	else if (item.action?.query) queries.push(item.action.query);
+};
+/**
+* Extracts the answer text, deduped sources, and run queries from a GPT
+* /responses web_search result.
+*/
+const extractWebSearchResult = (result) => {
+	const textParts = [];
+	const sources = [];
+	const seenUrls = /* @__PURE__ */ new Set();
+	const queries = [];
+	for (const item of result.output) if (isMessageItem(item)) {
+		const collected = collectTextParts(item.content, seenUrls);
+		textParts.push(...collected.textParts);
+		sources.push(...collected.sources);
+	}
+	for (const item of result.output) if (item.type === "web_search_call") {
+		const action = item.action;
+		collectQuery({ action }, queries);
+		for (const source of action?.sources ?? []) {
+			if (!source.url || seenUrls.has(source.url)) continue;
+			seenUrls.add(source.url);
+			sources.push({
+				url: source.url,
+				title: source.url
+			});
+		}
+	}
+	return {
+		answerText: textParts.join("\n\n").trim() || (result.output_text ?? "").trim(),
+		sources,
+		queries
+	};
+};
+//#endregion
+//#region src/lib/copilot-rate-limit.ts
+const copilotRateLimitTypes = ["session", "weekly"];
+const copilotRateLimitHeaders = {
+	session: "x-usage-ratelimit-session",
+	weekly: "x-usage-ratelimit-weekly"
+};
+const copilotQuotaSnapshotKeys = {
+	session: "5Hour-Session-RateLimits",
+	weekly: "Weekly-Session-RateLimits"
+};
+const hasGetMethod = (headers) => {
+	return "get" in headers && typeof headers.get === "function";
+};
+const getHeaderValue$1 = (headers, headerName) => {
+	if (hasGetMethod(headers)) return headers.get(headerName);
+	const normalizedHeaderName = headerName.toLowerCase();
+	return Object.entries(headers).find(([key]) => key.toLowerCase() === normalizedHeaderName)?.[1] ?? null;
+};
+const parseCopilotRateLimitHeader = (headerValue) => {
+	const params = new URLSearchParams(headerValue);
+	const remaining = params.get("rem");
+	const resetAt = params.get("rst");
+	if (!remaining || !resetAt) return null;
+	return {
+		remaining,
+		resetAt
+	};
+};
+const getCopilotRateLimitUsage = (headers, type) => {
+	const headerName = copilotRateLimitHeaders[type];
+	const headerValue = getHeaderValue$1(headers, headerName);
+	if (!headerValue) return null;
+	const parsed = parseCopilotRateLimitHeader(headerValue);
+	if (!parsed) return null;
+	return {
+		type,
+		...parsed
+	};
+};
+const getCopilotRateLimitUsageFromSnapshots = (snapshots, type) => {
+	const snapshot = snapshots?.[copilotQuotaSnapshotKeys[type]];
+	if (!isCopilotQuotaSnapshot(snapshot)) return null;
+	return {
+		remaining: String(snapshot.percent_remaining),
+		resetAt: snapshot.reset_date,
+		type
+	};
+};
+const logCopilotRateLimits = (headers) => {
+	for (const type of copilotRateLimitTypes) {
+		const usage = getCopilotRateLimitUsage(headers, type);
+		if (!usage) continue;
+		logCopilotRateLimitUsage(usage);
+	}
+};
+const logCopilotQuotaSnapshots = (snapshots) => {
+	for (const type of copilotRateLimitTypes) {
+		const usage = getCopilotRateLimitUsageFromSnapshots(snapshots, type);
+		if (!usage) continue;
+		logCopilotRateLimitUsage(usage);
+	}
+};
+const logCopilotRateLimitUsage = (usage) => {
+	const d = new Date(usage.resetAt);
+	const dateStr = Number.isNaN(d.getTime()) ? usage.resetAt : d.toLocaleString();
+	consola.log(`Copilot ${usage.type} quota remaining: ${usage.remaining}, resets at: ${dateStr}`);
+};
+const isCopilotQuotaSnapshot = (value) => {
+	if (!value || typeof value !== "object") return false;
+	const record = value;
+	return typeof record.entitlement === "string" && typeof record.percent_remaining === "number" && typeof record.overage_permitted === "boolean" && typeof record.overage_count === "number" && typeof record.reset_date === "string";
+};
+//#endregion
+//#region src/services/copilot/create-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 = {
+		...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}`);
+	const effectiveTransport = compactType === 1 ? "http" : transport;
+	if (payload.stream === true && effectiveTransport === "websocket") return createPooledResponsesWebSocketStream(prepareResponsesWebSocketRequest(payload, headers, {
+		requestId,
+		subagentMarker
+	}));
+	return await createHttpResponses(payload, headers);
+};
+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);
+	}
+	if (payload.stream) return events(response);
+	return await response.json();
+};
+const prepareResponsesWebSocketRequest = (payload, preparedHeaders, options) => {
+	const initiator = getResponsesWebSocketInitiator(preparedHeaders);
+	return {
+		headers: copilotWebSocketHeaders(preparedHeaders),
+		poolKey: buildResponsesWebSocketPoolKey(payload, options),
+		payload: buildResponsesWebSocketPayload(payload, initiator),
+		url: buildResponsesWebSocketUrl(copilotBaseUrl(state))
+	};
+};
+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) => createResponsesSafeStream(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 createResponsesSafeStream = async function* (source) {
+	try {
+		yield* source;
+	} catch (error) {
+		yield createResponsesErrorServerSentEventChunk(getErrorMessage(error));
+	}
+};
+const buildResponsesWebSocketPayload = (payload, initiator) => {
+	const websocketPayload = {
+		...payload,
+		type: "response.create",
+		initiator
+	};
+	delete websocketPayload.stream;
+	delete websocketPayload["background"];
+	delete websocketPayload.service_tier;
+	return websocketPayload;
+};
+const buildResponsesWebSocketUrl = (baseUrl) => {
+	return createWebSocketUrl(`${baseUrl.replace(/\/+$/u, "")}/responses`);
+};
+const getHeaderValue = (headers, headerName) => {
+	const normalizedHeaderName = headerName.toLowerCase();
+	return Object.entries(headers).find(([key]) => key.toLowerCase() === normalizedHeaderName)?.[1];
+};
+const encodePoolKeyPart = (value) => encodeURIComponent(value);
+const createResponsesWebSocketStreamChunk = (data) => {
+	if (data === "[DONE]") return { data };
+	try {
+		const parsed = JSON.parse(data);
+		if (parsed.type === "response.completed") logCopilotQuotaSnapshots(parsed.copilot_quota_snapshots);
+		if (parsed.type === "error" && parsed.error) {
+			consola.warn("Copilot responses websocket stream error:", parsed.error);
+			parsed.code = parsed.error.code;
+			parsed.message = parsed.error.message;
+		}
+		return {
+			event: typeof parsed.type === "string" ? parsed.type : void 0,
+			data: JSON.stringify(parsed),
+			id: typeof parsed.id === "string" ? parsed.id : void 0
+		};
+	} catch {
+		return { data };
+	}
+};
+const isTerminalResponsesStreamChunk = (chunk) => {
+	if (!chunk.data || chunk.data === "[DONE]") return false;
+	try {
+		const parsed = JSON.parse(chunk.data);
+		return parsed.type === "response.completed" || parsed.type === "response.failed" || parsed.type === "response.incomplete" || parsed.type === "error";
+	} catch {
+		return false;
+	}
+};
+const createResponsesErrorServerSentEventChunk = (message) => {
+	const errorEvent = {
+		code: null,
+		message,
+		param: null,
+		sequence_number: 0,
+		type: "error"
+	};
+	return {
+		event: errorEvent.type,
+		data: JSON.stringify(errorEvent)
+	};
+};
+const getErrorMessage = (error) => {
+	if (error instanceof Error && error.message) return error.message;
+	return String(error);
+};
+//#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;
+	}
+	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) {
+	consola.log(`<-- model: ${payload.model}`);
+	return await fetch(`${providerConfig.baseUrl}/v1/messages`, {
+		method: "POST",
+		headers: buildProviderUpstreamHeaders(providerConfig, requestHeaders),
+		body: JSON.stringify(payload)
+	});
+}
+async function forwardProviderChatCompletions(providerConfig, payload, requestHeaders) {
+	consola.log(`<-- model: ${payload.model}`);
+	return await fetch(`${providerConfig.baseUrl}/v1/chat/completions`, {
+		method: "POST",
+		headers: buildProviderUpstreamHeaders(providerConfig, requestHeaders),
+		body: JSON.stringify(payload)
+	});
+}
+async function forwardProviderResponses(providerConfig, payload, requestHeaders) {
+	consola.log(`<-- model: ${payload.model}`);
+	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)
+	});
+}
+/** Align with Codex images: long-running generation/edits need a generous cap. */
+const PROVIDER_IMAGES_TIMEOUT_MS = 900 * 1e3;
+const providerImagesDispatcher = { dispatch(options, handler) {
+	return getGlobalDispatcher().dispatch({
+		...options,
+		bodyTimeout: PROVIDER_IMAGES_TIMEOUT_MS,
+		headersTimeout: PROVIDER_IMAGES_TIMEOUT_MS
+	}, handler);
+} };
+function resolveProviderRequestUrl(providerConfig, requestUrl, path) {
+	const upstreamUrl = new URL(`${providerConfig.baseUrl}${path}`);
+	upstreamUrl.search = new URL(requestUrl, "http://localhost").search;
+	return upstreamUrl.toString();
+}
+async function forwardProviderAlphaSearch(providerConfig, request) {
+	const headers = buildProviderUpstreamHeaders(providerConfig, request.headers);
+	const body = await request.arrayBuffer();
+	return await fetch(resolveProviderRequestUrl(providerConfig, request.url, "/v1/alpha/search"), {
+		method: "POST",
+		headers,
+		body
+	});
+}
+async function forwardProviderImages(providerConfig, request, operation) {
+	const headers = buildProviderUpstreamHeaders(providerConfig, request.headers);
+	const contentType = request.headers.get("content-type");
+	if (contentType) headers["content-type"] = contentType;
+	else if (operation === "edits") delete headers["content-type"];
+	const init = {
+		method: "POST",
+		headers,
+		body: request.body,
+		duplex: "half",
+		signal: AbortSignal.timeout(PROVIDER_IMAGES_TIMEOUT_MS)
+	};
+	const upstreamUrl = resolveProviderRequestUrl(providerConfig, request.url, `/v1/images/${operation}`);
+	if (typeof Bun !== "undefined") return await fetch(upstreamUrl, init);
+	return await fetch$1(upstreamUrl, {
+		...init,
+		dispatcher: providerImagesDispatcher
+	});
+}
+//#endregion
+//#region src/routes/alpha-search/alpha-search-responses.ts
+const logger$15 = createHandlerLogger("alpha-search-responses-handler");
+const SESSION_TTL_MS = 3600 * 1e3;
+const MAX_SESSIONS = 128;
+const MAX_URL_REFERENCES = 256;
+const MAX_SNAPSHOTS = 16;
+const MAX_SNAPSHOT_CHARACTERS = 2e4;
+const IMAGE_UNSUPPORTED = "Unsupported by GitHub Copilot web search: image_query. Do not retry this operation; use search_query for image-source pages.";
+const SCREENSHOT_UNSUPPORTED = "Unsupported by GitHub Copilot web search: screenshot. Do not retry this operation; open the PDF for text content.";
+const KNOWN_COMMANDS = new Set([
+	"search_query",
+	"image_query",
+	"open",
+	"click",
+	"find",
+	"screenshot",
+	"finance",
+	"weather",
+	"sports",
+	"time",
+	"response_length"
+]);
+const sessions = /* @__PURE__ */ new Map();
+const alphaSearchResponsesDependencies = {
+	createResponses,
+	findEndpointModel,
+	now: () => Date.now(),
+	resolveMappedModel,
+	createUsageRecorder: (model, sessionId) => createCopilotTokenUsageRecorder({
+		endpoint: "responses",
+		fallbackSessionId: sessionId,
+		model
+	})
+};
+function reserveSession(id, now) {
+	for (const [sessionId, session] of sessions) if (now - session.touchedAt >= SESSION_TTL_MS) sessions.delete(sessionId);
+	let session = sessions.get(id);
+	if (!session) {
+		if (sessions.size >= MAX_SESSIONS) {
+			const oldestSession = sessions.keys().next();
+			if (!oldestSession.done) sessions.delete(oldestSession.value);
+		}
+		session = {
+			nextTurn: 0,
+			touchedAt: now,
+			referencesById: /* @__PURE__ */ new Map(),
+			referencesByUrl: /* @__PURE__ */ new Map(),
+			snapshots: /* @__PURE__ */ new Map()
+		};
+	} else {
+		sessions.delete(id);
+		session.touchedAt = now;
+	}
+	sessions.set(id, session);
+	const turn = session.nextTurn;
+	session.nextTurn += 1;
+	return {
+		session,
+		turn
+	};
+}
+function parseHttpUrl(value) {
+	try {
+		const url = new URL(value);
+		return url.protocol === "http:" || url.protocol === "https:" ? url.toString() : null;
+	} catch {
+		return null;
+	}
+}
+function extractMarkdownSources(text) {
+	return Array.from(text.matchAll(/(?<!!)\[([^\]\n]+)\]\((https?:\/\/(?:[^\s<>()]|\([^\s<>()]*\))+)\)/gu), ([, title, url]) => ({
+		title,
+		url
+	}));
+}
+function addUrlReference(session, source, turn) {
+	const url = parseHttpUrl(source.url);
+	if (!url) return null;
+	const existing = session.referencesByUrl.get(url);
+	if (existing) {
+		if (existing.result.title === existing.result.url && source.title) existing.result.title = source.title;
+		if (source.snippet) existing.result.snippet = source.snippet;
+		return existing;
+	}
+	if (session.referencesById.size >= MAX_URL_REFERENCES) {
+		const oldest = session.referencesById.entries().next().value;
+		if (oldest) {
+			const [refId, reference] = oldest;
+			session.referencesById.delete(refId);
+			session.referencesByUrl.delete(reference.result.url);
+		}
+	}
+	const refId = `turn${turn.number}search${turn.nextReferenceIndex}`;
+	turn.nextReferenceIndex += 1;
+	const reference = { result: {
+		type: "text_result",
+		domain: new URL(url).hostname,
+		ref_id: refId,
+		snippet: source.snippet?.trim() || source.title || url,
+		title: source.title || url,
+		url
+	} };
+	session.referencesById.set(refId, reference);
+	session.referencesByUrl.set(url, reference);
+	return reference;
+}
+function resolveUrlReference(session, refId, turn) {
+	const stored = session.referencesById.get(refId);
+	if (stored) return stored;
+	const url = parseHttpUrl(refId);
+	return url ? addUrlReference(session, {
+		title: url,
+		url
+	}, turn) : null;
+}
+function getSnapshot(session, refId) {
+	const snapshot = session.snapshots.get(refId);
+	if (!snapshot) return null;
+	session.snapshots.delete(refId);
+	session.snapshots.set(refId, snapshot);
+	return snapshot;
+}
+function findSnapshotByUrl(session, url) {
+	for (const snapshot of session.snapshots.values()) if (snapshot.source.result.url === url) return getSnapshot(session, snapshot.refId);
+	return null;
+}
+function addSnapshot(session, source, turn, index, text, links) {
+	const existing = findSnapshotByUrl(session, source.result.url);
+	if (existing) {
+		existing.text = text.slice(0, MAX_SNAPSHOT_CHARACTERS);
+		existing.links = links;
+		return existing;
+	}
+	if (session.snapshots.size >= MAX_SNAPSHOTS) {
+		const oldestRefId = session.snapshots.keys().next().value;
+		if (oldestRefId) session.snapshots.delete(oldestRefId);
+	}
+	const snapshot = {
+		refId: `turn${turn}view${index}`,
+		source,
+		text: text.slice(0, MAX_SNAPSHOT_CHARACTERS),
+		links
+	};
+	session.snapshots.set(snapshot.refId, snapshot);
+	return snapshot;
+}
+function renderSnapshot(snapshot, lineno) {
+	const lines = snapshot.text.split("\n");
+	const start = lineno === void 0 ? 0 : Math.max(0, Math.min(lineno, lines.length - 1) - 10);
+	const end = lineno === void 0 ? lines.length : Math.min(lines.length, start + 21);
+	const numbered = lines.slice(start, end).map((line, index) => `L${start + index}: ${line}`).join("\n");
+	const links = snapshot.links.map((link, index) => `[${index}] ${link.result.title} — ${link.result.url} (${link.result.ref_id})`).join("\n");
+	return [
+		`Open ${snapshot.refId} (${snapshot.source.result.url})`,
+		numbered,
+		links ? `Links:\n${links}` : ""
+	].filter(Boolean).join("\n");
+}
+function findInSnapshot(snapshot, pattern) {
+	const normalizedPattern = pattern.toLowerCase();
+	const matches = snapshot.text.split("\n").map((line, index) => ({
+		line,
+		index
+	})).filter(({ line }) => line.toLowerCase().includes(normalizedPattern)).slice(0, 20);
+	if (matches.length === 0) return null;
+	return [`Find results for ${JSON.stringify(pattern)} in ${snapshot.refId}:`, ...matches.map(({ line, index }) => `L${index}: ${line}`)].join("\n");
+}
+function formatTime(utcOffset, now) {
+	const offsetMinutes = (utcOffset.startsWith("+") ? 1 : -1) * (Number.parseInt(utcOffset.slice(1, 3), 10) * 60 + Number.parseInt(utcOffset.slice(4, 6), 10));
+	return `Time at UTC${utcOffset}: ${new Date(now + offsetMinutes * 6e4).toISOString().slice(0, 19).replace("T", " ")}`;
+}
+function buildInstruction(operations, responseLength) {
+	return [
+		"The Operations JSON below is the complete and exclusive request for this response.",
+		"Use web_search to execute every listed operation and only those operations. Do not validate, infer, or mention operations absent from the JSON; the adapter already handled them.",
+		"Return only grounded results and citations for these operations. Do not discuss unrelated tasks or conversations.",
+		"For search operations, honor every query, recency, domain, market, date, league, team, and locale constraint.",
+		"For open operations, open the exact URL and return grounded page text plus cited links.",
+		"For find operations, find the exact pattern in the specified URL and return matching context.",
+		`Requested response length: ${responseLength ?? "medium"}.`,
+		`Operations:\n${JSON.stringify(operations, null, 2)}`
+	].join("\n");
+}
+function unavailableReference(refId) {
+	return `Reference ${JSON.stringify(refId)} is unavailable or expired. Search or open the URL again.`;
+}
+function invalidRequest$1(c, message) {
+	return c.json({ error: {
+		message,
+		type: "invalid_request_error"
+	} }, 400);
+}
+function createSearchOperationState(session, turn) {
+	return {
+		session,
+		turn,
+		output: [],
+		warnings: [],
+		resultReferences: /* @__PURE__ */ new Map(),
+		remoteOperations: [],
+		remotePages: []
+	};
+}
+function includeResult(state, reference) {
+	state.resultReferences.set(reference.result.url, reference);
+}
+function queuePage(state, kind, source, options = {}) {
+	state.remoteOperations.push({
+		operation: kind,
+		url: source.result.url,
+		...options.lineno === void 0 ? {} : { lineno: options.lineno },
+		...options.pattern === void 0 ? {} : { pattern: options.pattern }
+	});
+	state.remotePages.push({
+		kind,
+		source,
+		...options
+	});
+	includeResult(state, source);
+}
+function processSearchCommands(commands, state) {
+	for (const command of commands.search_query ?? []) state.remoteOperations.push({
+		...command,
+		operation: "search_query"
+	});
+}
+function processOpenCommands(commands, state) {
+	for (const command of commands.open ?? []) {
+		const directSnapshot = getSnapshot(state.session, command.ref_id);
+		if (directSnapshot) {
+			state.output.push(renderSnapshot(directSnapshot, command.lineno));
+			includeResult(state, directSnapshot.source);
+			continue;
+		}
+		const source = resolveUrlReference(state.session, command.ref_id, state.turn);
+		if (!source) {
+			state.output.push(unavailableReference(command.ref_id));
+			continue;
+		}
+		const cached = findSnapshotByUrl(state.session, source.result.url);
+		if (cached) {
+			state.output.push(renderSnapshot(cached, command.lineno));
+			includeResult(state, source);
+			continue;
+		}
+		queuePage(state, "open", source, { lineno: command.lineno });
+	}
+}
+function processClickCommands(commands, state) {
+	for (const command of commands.click ?? []) {
+		const source = getSnapshot(state.session, command.ref_id)?.links[command.id];
+		if (!source) {
+			state.output.push(unavailableReference(`${command.ref_id} link ${command.id}`));
+			continue;
+		}
+		const cached = findSnapshotByUrl(state.session, source.result.url);
+		if (cached) {
+			state.output.push(renderSnapshot(cached));
+			includeResult(state, source);
+			continue;
+		}
+		queuePage(state, "open", source);
+	}
+}
+function processFindCommands(commands, state) {
+	for (const command of commands.find ?? []) {
+		const directSnapshot = getSnapshot(state.session, command.ref_id);
+		const source = directSnapshot?.source ?? resolveUrlReference(state.session, command.ref_id, state.turn);
+		if (!source) {
+			state.output.push(unavailableReference(command.ref_id));
+			continue;
+		}
+		const snapshot = directSnapshot ?? findSnapshotByUrl(state.session, source.result.url);
+		const localResult = snapshot ? findInSnapshot(snapshot, command.pattern) : null;
+		if (localResult) {
+			state.output.push(localResult);
+			includeResult(state, source);
+			continue;
+		}
+		queuePage(state, "find", source, { pattern: command.pattern });
+	}
+}
+function processStructuredCommands(commands, state, now) {
+	for (const command of commands.finance ?? []) state.remoteOperations.push({
+		...command,
+		operation: "finance"
+	});
+	for (const command of commands.weather ?? []) state.remoteOperations.push({
+		...command,
+		operation: "weather"
+	});
+	for (const command of commands.sports ?? []) state.remoteOperations.push({
+		...command,
+		operation: "sports"
+	});
+	for (const command of commands.time ?? []) state.output.push(formatTime(command.utc_offset, now));
+}
+function processUnsupportedCommands(commands, state) {
+	for (const commandName of Object.keys(commands)) if (!KNOWN_COMMANDS.has(commandName)) state.warnings.push(`Unsupported by GitHub Copilot web search: ${commandName}. Do not retry this operation.`);
+}
+function processCommandOperations(commands, state, now) {
+	processSearchCommands(commands, state);
+	if ((commands.image_query?.length ?? 0) > 0) state.warnings.push(IMAGE_UNSUPPORTED);
+	processOpenCommands(commands, state);
+	processClickCommands(commands, state);
+	processFindCommands(commands, state);
+	if ((commands.screenshot?.length ?? 0) > 0) state.warnings.push(SCREENSHOT_UNSUPPORTED);
+	processStructuredCommands(commands, state, now);
+	processUnsupportedCommands(commands, state);
+}
+function supportsLiveAccess(request) {
+	const externalWebAccess = request.settings?.external_web_access;
+	return externalWebAccess === void 0 || externalWebAccess === true || externalWebAccess === "live";
+}
+function addLiveAccessWarning(request, state) {
+	if (state.remoteOperations.length === 0 || supportsLiveAccess(request)) return;
+	state.warnings.push(`GitHub Copilot alpha search supports live retrieval only; external_web_access=${JSON.stringify(request.settings?.external_web_access)} is unsupported. Do not retry this request in this mode.`);
+}
+function shouldExecuteRemoteOperations(request, state) {
+	return state.remoteOperations.length > 0 && supportsLiveAccess(request);
+}
+async function resolveRemoteModel(c, request, provider) {
+	const model = provider ? request.model : alphaSearchResponsesDependencies.resolveMappedModel(request.model);
+	if (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 (resolveEffectiveProviderType(providerConfig, model) !== "openai-responses") return invalidRequest$1(c, `Provider '${provider}' does not support the /v1/responses endpoint required for alpha search`);
+		return {
+			model,
+			providerConfig
+		};
+	}
+	if (!alphaSearchResponsesDependencies.findEndpointModel(model)?.supported_endpoints?.includes("/responses")) return invalidRequest$1(c, `Model '${model}' does not support the Copilot Responses endpoint required for alpha search`);
+	return { model };
+}
+function createRemoteResponsesPayload(request, model, instruction) {
+	return {
+		model,
+		input: instruction,
+		tools: [buildResponsesWebSearchTool({
+			allowedDomains: request.settings?.filters?.allowed_domains,
+			blockedDomains: request.settings?.filters?.blocked_domains,
+			userLocation: request.settings?.user_location,
+			searchContextSize: request.settings?.search_context_size
+		})],
+		tool_choice: "required",
+		store: false,
+		stream: false,
+		include: ["web_search_call.action.sources"],
+		reasoning: request.reasoning,
+		max_output_tokens: request.max_output_tokens
+	};
+}
+async function requestProviderSearch(c, providerConfig, payload, model, sessionId) {
+	debugJson(logger$15, "Alpha search provider Responses request:", {
+		payload,
+		provider: providerConfig.name
+	});
+	const upstreamResponse = await forwardProviderResponses(providerConfig, payload, c.req.raw.headers);
+	if (!upstreamResponse.ok) throw new HTTPError(`Failed to create ${providerConfig.name} responses for alpha search`, upstreamResponse);
+	const result = await upstreamResponse.json();
+	debugJson(logger$15, "Alpha search provider Responses result:", {
+		provider: providerConfig.name,
+		result
+	});
+	createProviderTokenUsageRecorder({
+		endpoint: "responses",
+		fallbackSessionId: sessionId,
+		model,
+		pricing: providerConfig.models?.[model]?.pricing,
+		pricingCurrency: providerConfig.pricingCurrency,
+		providerName: providerConfig.name,
+		sessionId
+	})(normalizeResponsesUsage(result.usage));
+	return result;
+}
+async function requestCopilotSearch(payload, model, requestId, sessionId) {
+	debugJson(logger$15, "Alpha search Copilot Responses request:", payload);
+	const result = await alphaSearchResponsesDependencies.createResponses(payload, {
+		vision: false,
+		initiator: "agent",
+		transport: "http",
+		requestId,
+		sessionId
+	});
+	debugJson(logger$15, "Alpha search Copilot Responses result:", result);
+	alphaSearchResponsesDependencies.createUsageRecorder(model, sessionId)({
+		...normalizeResponsesUsage(result.usage),
+		total_nano_aiu: normalizeOptionalToken(result.copilot_usage?.total_nano_aiu)
+	});
+	return result;
+}
+async function requestRemoteSearch(c, request, state, target) {
+	const instruction = buildInstruction(state.remoteOperations, request.commands?.response_length);
+	const sessionId = getUUID(request.id);
+	const requestId = generateRequestIdFromPayload({ messages: `${state.turn.number}:${instruction}` }, sessionId);
+	const payload = createRemoteResponsesPayload(request, target.model, instruction);
+	if (target.providerConfig) return await requestProviderSearch(c, target.providerConfig, payload, target.model, sessionId);
+	return await requestCopilotSearch(payload, target.model, requestId, sessionId);
+}
+function getActiveRemoteReferences(session, references) {
+	return references.filter((reference) => session.referencesById.get(reference.result.ref_id) === reference);
+}
+function buildSnapshotLinks(state, target, markdownReferences, remoteReferences) {
+	return [...new Map([...markdownReferences, ...getActiveRemoteReferences(state.session, remoteReferences)].filter((reference) => reference.result.url !== target.result.url && state.session.referencesById.get(reference.result.ref_id) === reference).map((reference) => [reference.result.url, reference])).values()];
+}
+function processRemotePages(state, answerText, markdownReferences, remoteReferences) {
+	for (const [index, page] of state.remotePages.entries()) {
+		const target = addUrlReference(state.session, {
+			url: page.source.result.url,
+			title: page.source.result.title,
+			snippet: answerText
+		}, state.turn) ?? page.source;
+		includeResult(state, target);
+		const snapshotLinks = buildSnapshotLinks(state, target, markdownReferences, remoteReferences);
+		if (page.kind === "find") {
+			state.output.push(`Find results for ${JSON.stringify(page.pattern ?? "")} in ${target.result.url}:\n${answerText}`);
+			if (!findSnapshotByUrl(state.session, target.result.url)) addSnapshot(state.session, target, state.turn.number, index, answerText, snapshotLinks);
+			continue;
+		}
+		const snapshot = addSnapshot(state.session, target, state.turn.number, index, answerText, snapshotLinks);
+		state.output.push(renderSnapshot(snapshot, page.lineno));
+	}
+}
+function appendActiveSources(state, references) {
+	if (references.length === 0) return;
+	state.output.push(["Sources:", ...references.map((reference) => `- [${reference.result.ref_id}] ${reference.result.title} — ${reference.result.url}`)].join("\n"));
+}
+function processRemoteResult(result, state) {
+	const extracted = extractWebSearchResult(result);
+	const citedSources = extracted.sources.filter((source) => source.snippet !== void 0);
+	const relevantSources = citedSources.length > 0 ? citedSources : extracted.sources;
+	consola.log(`--> web search: operations=${[...new Set(state.remoteOperations.map((remoteOperation) => remoteOperation.operation))].join(",")} queries=${JSON.stringify(extracted.queries)} sources=${relevantSources.length}`);
+	const remoteReferences = relevantSources.map((source) => addUrlReference(state.session, source, state.turn)).filter((reference) => Boolean(reference));
+	for (const reference of getActiveRemoteReferences(state.session, remoteReferences)) includeResult(state, reference);
+	const answerText = extracted.answerText || "GitHub Copilot web search returned no text.";
+	const markdownReferences = state.remotePages.length === 0 ? [] : extractMarkdownSources(answerText).map((source) => addUrlReference(state.session, source, state.turn)).filter((reference) => Boolean(reference));
+	for (const reference of markdownReferences) includeResult(state, reference);
+	if (state.remotePages.length === 0) state.output.push(answerText);
+	processRemotePages(state, answerText, markdownReferences, remoteReferences);
+	appendActiveSources(state, getActiveRemoteReferences(state.session, remoteReferences));
+}
+async function executeRemoteOperations(c, request, state, provider) {
+	const target = await resolveRemoteModel(c, request, provider);
+	if (target instanceof Response) return target;
+	processRemoteResult(await requestRemoteSearch(c, request, state, target), state);
+	return null;
+}
+function buildAlphaSearchResponse(state) {
+	state.output.push(...state.warnings);
+	if (state.output.length === 0) state.output.push("No supported search operations were requested.");
+	return {
+		encrypted_output: null,
+		output: state.output.join("\n\n"),
+		results: [...state.resultReferences.values()].filter((reference) => state.session.referencesById.get(reference.result.ref_id) === reference).map(({ result }) => result)
+	};
+}
+async function handleAlphaSearchResponses(c, options) {
+	const parsed = alphaSearchRequestSchema.safeParse(options.request);
+	if (!parsed.success) {
+		const issue = parsed.error.issues[0];
+		return invalidRequest$1(c, `Invalid alpha search request at ${issue?.path.join(".") || "body"}: ${issue?.message ?? "invalid value"}`);
+	}
+	const request = parsed.data;
+	const now = alphaSearchResponsesDependencies.now();
+	const reservation = reserveSession(request.id, now);
+	const session = reservation.session;
+	const state = createSearchOperationState(session, {
+		number: reservation.turn,
+		nextReferenceIndex: 0
+	});
+	processCommandOperations(request.commands ?? {}, state, now);
+	addLiveAccessWarning(request, state);
+	if (shouldExecuteRemoteOperations(request, state)) {
+		const remoteResponse = await executeRemoteOperations(c, request, state, options.provider);
+		if (remoteResponse) return remoteResponse;
+	}
+	return c.json(buildAlphaSearchResponse(state));
+}
+//#endregion
+//#region src/services/codex/alpha-search.ts
+const CODEX_ALPHA_SEARCH_URL = `${CODEX_API_BASE_URL}/codex/alpha/search`;
+function resolveCodexAlphaSearchUrl(requestUrl) {
+	const upstreamUrl = new URL(CODEX_ALPHA_SEARCH_URL);
+	upstreamUrl.search = new URL(requestUrl, "http://localhost").search;
+	return upstreamUrl.toString();
+}
+async function forwardCodexAlphaSearch(request) {
+	const headers = buildCodexRequestHeaders(request.headers);
+	if (!headers.has("accept")) headers.set("accept", "application/json");
+	const body = await request.arrayBuffer();
+	if (!headers.has("content-type")) headers.set("content-type", "application/json");
+	return await fetch(resolveCodexAlphaSearchUrl(request.url), {
+		method: "POST",
+		headers,
+		body
+	});
+}
+//#endregion
+//#region src/routes/alpha-search/route.ts
+const logger$14 = createHandlerLogger("alpha-search-handler");
+const alphaSearchRoutes = new Hono();
+function parseDebugBody(body) {
+	try {
+		return JSON.parse(body);
+	} catch {
+		return body;
+	}
+}
+async function forwardCodexAlphaSearchRequest(request) {
+	await debugJsonAsync(logger$14, "alpha_search.codex.request", async () => ({ body: parseDebugBody(await request.clone().text()) }));
+	const upstreamResponse = await forwardCodexAlphaSearch(request);
+	await debugJsonAsync(logger$14, "alpha_search.codex.response", async () => ({
+		body: parseDebugBody(await upstreamResponse.clone().text()),
+		statusCode: upstreamResponse.status
+	}));
+	return createProviderProxyResponse(upstreamResponse);
+}
+function createAlphaSearchRequest(request, payload) {
+	return new Request(request, {
+		body: JSON.stringify(payload),
+		method: "post"
+	});
+}
+async function handleCodexRequest(c, request, resolvedProviderConfig) {
+	if (!(resolvedProviderConfig ?? await resolveProviderConfig("codex"))) return c.json({ error: {
+		message: "Provider 'codex' not found or disabled",
+		type: "invalid_request_error"
+	} }, 404);
+	return await forwardCodexAlphaSearchRequest(request);
+}
+function invalidRequest(c, message) {
+	return c.json({ error: {
+		message,
+		type: "invalid_request_error"
+	} }, 400);
+}
+async function parseAlphaSearchBody(c) {
+	let body;
+	try {
+		body = await c.req.raw.clone().json();
+	} catch {
+		return invalidRequest(c, "Invalid alpha search request: expected JSON body");
+	}
+	if (typeof body?.model !== "string") return invalidRequest(c, "Invalid alpha search request: model must be a string");
+	return body;
+}
+/**
+* Handles top-level alpha-search dispatch. Pass `resolvedProviderConfig` when
+* the provider-scoped route has already resolved Codex. Codex is preferred
+* for every top-level request while alphaSearchCodexPriority stays enabled.
+*/
+async function handleAlphaSearchRequest(c, resolvedProviderConfig) {
+	if (resolvedProviderConfig) return await handleCodexRequest(c, c.req.raw, resolvedProviderConfig);
+	const payload = await parseAlphaSearchBody(c);
+	if (payload instanceof Response) return payload;
+	const requestedModel = payload.model;
+	payload.model = resolveMappedModel(requestedModel);
+	if (payload.model !== requestedModel) consola.debug(`Resolved model mapping: ${requestedModel} -> ${payload.model}`);
+	const providerModelAlias = parseProviderModelAlias(payload.model);
+	if (providerModelAlias) {
+		payload.model = providerModelAlias.model;
+		if (providerModelAlias.provider === "codex") return await handleCodexRequest(c, createAlphaSearchRequest(c.req.raw, payload));
+	}
+	if (isAlphaSearchCodexPriorityEnabled()) {
+		if (await resolveProviderConfig("codex")) return await forwardCodexAlphaSearchRequest(createAlphaSearchRequest(c.req.raw, payload));
+	}
+	if (providerModelAlias) return await handleAlphaSearchResponses(c, {
+		provider: providerModelAlias.provider,
+		request: payload
+	});
+	return await handleAlphaSearchResponses(c, { request: {
+		...payload,
+		model: requestedModel
+	} });
+}
+alphaSearchRoutes.post("/", async (c) => {
+	try {
+		return await handleAlphaSearchRequest(c);
+	} catch (error) {
+		logger$14.error("alpha_search.error", { error });
+		return await forwardError(c, error);
+	}
+});
+//#endregion
+//#region src/lib/dashscope.ts
+const OPENAI_COMPATIBLE_CONTEXT_CACHE_MARKER_LIMIT = 4;
+const OPENAI_COMPATIBLE_CONTEXT_CACHE_CONTROL = { type: "ephemeral" };
+const OPENAI_COMPATIBLE_CONTEXT_CACHE_ROLES = new Set([
+	"system",
+	"user",
+	"assistant",
+	"tool"
+]);
+const isDashScopeAliyunProvider = (providerConfig) => providerConfig.name === "dashscope" || providerConfig.baseUrl.includes("aliyuncs.com");
+const applyDashScopePreserveThinkingDefault = (payload, providerConfig) => {
+	if (!isDashScopeAliyunProvider(providerConfig)) return;
+	if (!Object.hasOwn(payload, "preserve_thinking")) payload.preserve_thinking = true;
+};
+const applyOpenAICompatibleContextCache = (payload) => {
+	const messageIndexes = selectContextCacheMessageIndexes(payload.messages);
+	for (const messageIndex of messageIndexes) applyContextCacheControl(payload.messages[messageIndex]);
+};
+const selectContextCacheMessageIndexes = (messages) => {
+	const cacheableIndexes = messages.flatMap((message, index) => isContextCacheMarkerEligible(message) ? [index] : []);
+	const systemIndexes = cacheableIndexes.filter((index) => messages[index]?.role === "system").slice(0, 2);
+	const finalIndexes = cacheableIndexes.filter((index) => messages[index]?.role !== "system").slice(-1);
+	return uniqueIndexes$1([...systemIndexes, ...finalIndexes]).sort((a, b) => a - b);
+};
+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 applyContextCacheControl = (message) => {
@@ -1767,123 +2722,50 @@ const applyMissingExtraBody$1 = (payload, options) => {
 	for (const [key, value] of Object.entries(options.extraBody ?? {})) if (!Object.hasOwn(payload, key)) payload[key] = value;
 };
 const applyProviderStreamOptions = (payload) => {
-	if (!payload.stream) return;
-	payload.stream_options = {
-		...payload.stream_options ?? {},
-		include_usage: true
-	};
-};
-const applyProviderContextCache = (payload, modelConfig, providerConfig) => {
-	const isDashScopeProvider = isDashScopeAliyunProvider(providerConfig);
-	if (modelConfig?.contextCache ?? isDashScopeProvider) applyOpenAICompatibleContextCache(payload);
-};
-const createProviderChatCompletionsUsageRecorder = (payload, provider, modelConfig, pricingCurrency) => createProviderTokenUsageRecorder({
-	endpoint: "chat_completions",
-	model: payload.model,
-	pricing: modelConfig?.pricing,
-	pricingCurrency,
-	providerName: provider
-});
-const streamProviderChatCompletions = (c, upstreamResponse, options) => {
-	logger$13.debug("provider.chat_completions.streaming", { provider: options.provider });
-	return streamSSE(c, async (stream) => {
-		let usage = {};
-		try {
-			for await (const chunk of events(upstreamResponse)) {
-				debugJson(logger$13, "provider.chat_completions.stream_chunk", chunk);
-				if (chunk.data && chunk.data !== "[DONE]") {
-					const parsedChunk = parseChatCompletionChunkData(chunk.data);
-					if (parsedChunk?.usage) usage = normalizeOpenAIUsage(parsedChunk.usage);
-				}
-				await stream.writeSSE({
-					event: chunk.event,
-					data: chunk.data ?? ""
-				});
-			}
-		} finally {
-			options.recordUsage(usage);
-		}
-	});
-};
-const parseChatCompletionChunkData = (data) => {
-	try {
-		return JSON.parse(data);
-	} catch {
-		return null;
-	}
-};
-//#endregion
-//#region src/lib/copilot-rate-limit.ts
-const copilotRateLimitTypes = ["session", "weekly"];
-const copilotRateLimitHeaders = {
-	session: "x-usage-ratelimit-session",
-	weekly: "x-usage-ratelimit-weekly"
-};
-const copilotQuotaSnapshotKeys = {
-	session: "5Hour-Session-RateLimits",
-	weekly: "Weekly-Session-RateLimits"
-};
-const hasGetMethod = (headers) => {
-	return "get" in headers && typeof headers.get === "function";
-};
-const getHeaderValue$1 = (headers, headerName) => {
-	if (hasGetMethod(headers)) return headers.get(headerName);
-	const normalizedHeaderName = headerName.toLowerCase();
-	return Object.entries(headers).find(([key]) => key.toLowerCase() === normalizedHeaderName)?.[1] ?? null;
-};
-const parseCopilotRateLimitHeader = (headerValue) => {
-	const params = new URLSearchParams(headerValue);
-	const remaining = params.get("rem");
-	const resetAt = params.get("rst");
-	if (!remaining || !resetAt) return null;
-	return {
-		remaining,
-		resetAt
-	};
-};
-const getCopilotRateLimitUsage = (headers, type) => {
-	const headerName = copilotRateLimitHeaders[type];
-	const headerValue = getHeaderValue$1(headers, headerName);
-	if (!headerValue) return null;
-	const parsed = parseCopilotRateLimitHeader(headerValue);
-	if (!parsed) return null;
-	return {
-		type,
-		...parsed
-	};
-};
-const getCopilotRateLimitUsageFromSnapshots = (snapshots, type) => {
-	const snapshot = snapshots?.[copilotQuotaSnapshotKeys[type]];
-	if (!isCopilotQuotaSnapshot(snapshot)) return null;
-	return {
-		remaining: String(snapshot.percent_remaining),
-		resetAt: snapshot.reset_date,
-		type
+	if (!payload.stream) return;
+	payload.stream_options = {
+		...payload.stream_options ?? {},
+		include_usage: true
 	};
 };
-const logCopilotRateLimits = (headers) => {
-	for (const type of copilotRateLimitTypes) {
-		const usage = getCopilotRateLimitUsage(headers, type);
-		if (!usage) continue;
-		logCopilotRateLimitUsage(usage);
-	}
-};
-const logCopilotQuotaSnapshots = (snapshots) => {
-	for (const type of copilotRateLimitTypes) {
-		const usage = getCopilotRateLimitUsageFromSnapshots(snapshots, type);
-		if (!usage) continue;
-		logCopilotRateLimitUsage(usage);
-	}
+const applyProviderContextCache = (payload, modelConfig, providerConfig) => {
+	const isDashScopeProvider = isDashScopeAliyunProvider(providerConfig);
+	if (modelConfig?.contextCache ?? isDashScopeProvider) applyOpenAICompatibleContextCache(payload);
 };
-const logCopilotRateLimitUsage = (usage) => {
-	const d = new Date(usage.resetAt);
-	const dateStr = Number.isNaN(d.getTime()) ? usage.resetAt : d.toLocaleString();
-	consola.log(`Copilot ${usage.type} quota remaining: ${usage.remaining}, resets at: ${dateStr}`);
+const createProviderChatCompletionsUsageRecorder = (payload, provider, modelConfig, pricingCurrency) => createProviderTokenUsageRecorder({
+	endpoint: "chat_completions",
+	model: payload.model,
+	pricing: modelConfig?.pricing,
+	pricingCurrency,
+	providerName: provider
+});
+const streamProviderChatCompletions = (c, upstreamResponse, options) => {
+	logger$13.debug("provider.chat_completions.streaming", { provider: options.provider });
+	return streamSSE(c, async (stream) => {
+		let usage = {};
+		try {
+			for await (const chunk of events(upstreamResponse)) {
+				debugJson(logger$13, "provider.chat_completions.stream_chunk", chunk);
+				if (chunk.data && chunk.data !== "[DONE]") {
+					const parsedChunk = parseChatCompletionChunkData(chunk.data);
+					if (parsedChunk?.usage) usage = normalizeOpenAIUsage(parsedChunk.usage);
+				}
+				await stream.writeSSE({
+					event: chunk.event,
+					data: chunk.data ?? ""
+				});
+			}
+		} finally {
+			options.recordUsage(usage);
+		}
+	});
 };
-const isCopilotQuotaSnapshot = (value) => {
-	if (!value || typeof value !== "object") return false;
-	const record = value;
-	return typeof record.entitlement === "string" && typeof record.percent_remaining === "number" && typeof record.overage_permitted === "boolean" && typeof record.overage_count === "number" && typeof record.reset_date === "string";
+const parseChatCompletionChunkData = (data) => {
+	try {
+		return JSON.parse(data);
+	} catch {
+		return null;
+	}
 };
 //#endregion
 //#region src/services/copilot/create-chat-completions.ts
@@ -3579,143 +4461,6 @@ function closeThinkingBlockIfOpen(state, events) {
 	}
 }
 //#endregion
-//#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 = {
-		...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}`);
-	const effectiveTransport = compactType === 1 ? "http" : transport;
-	if (payload.stream === true && effectiveTransport === "websocket") return createPooledResponsesWebSocketStream(prepareResponsesWebSocketRequest(payload, headers, {
-		requestId,
-		subagentMarker
-	}));
-	return await createHttpResponses(payload, headers);
-};
-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);
-	}
-	if (payload.stream) return events(response);
-	return await response.json();
-};
-const prepareResponsesWebSocketRequest = (payload, preparedHeaders, options) => {
-	const initiator = getResponsesWebSocketInitiator(preparedHeaders);
-	return {
-		headers: copilotWebSocketHeaders(preparedHeaders),
-		poolKey: buildResponsesWebSocketPoolKey(payload, options),
-		payload: buildResponsesWebSocketPayload(payload, initiator),
-		url: buildResponsesWebSocketUrl(copilotBaseUrl(state))
-	};
-};
-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) => createResponsesSafeStream(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 createResponsesSafeStream = async function* (source) {
-	try {
-		yield* source;
-	} catch (error) {
-		yield createResponsesErrorServerSentEventChunk(getErrorMessage(error));
-	}
-};
-const buildResponsesWebSocketPayload = (payload, initiator) => {
-	const websocketPayload = {
-		...payload,
-		type: "response.create",
-		initiator
-	};
-	delete websocketPayload.stream;
-	delete websocketPayload["background"];
-	delete websocketPayload.service_tier;
-	return websocketPayload;
-};
-const buildResponsesWebSocketUrl = (baseUrl) => {
-	return createWebSocketUrl(`${baseUrl.replace(/\/+$/u, "")}/responses`);
-};
-const getHeaderValue = (headers, headerName) => {
-	const normalizedHeaderName = headerName.toLowerCase();
-	return Object.entries(headers).find(([key]) => key.toLowerCase() === normalizedHeaderName)?.[1];
-};
-const encodePoolKeyPart = (value) => encodeURIComponent(value);
-const createResponsesWebSocketStreamChunk = (data) => {
-	if (data === "[DONE]") return { data };
-	try {
-		const parsed = JSON.parse(data);
-		if (parsed.type === "response.completed") logCopilotQuotaSnapshots(parsed.copilot_quota_snapshots);
-		if (parsed.type === "error" && parsed.error) {
-			consola.warn("Copilot responses websocket stream error:", parsed.error);
-			parsed.code = parsed.error.code;
-			parsed.message = parsed.error.message;
-		}
-		return {
-			event: typeof parsed.type === "string" ? parsed.type : void 0,
-			data: JSON.stringify(parsed),
-			id: typeof parsed.id === "string" ? parsed.id : void 0
-		};
-	} catch {
-		return { data };
-	}
-};
-const isTerminalResponsesStreamChunk = (chunk) => {
-	if (!chunk.data || chunk.data === "[DONE]") return false;
-	try {
-		const parsed = JSON.parse(chunk.data);
-		return parsed.type === "response.completed" || parsed.type === "response.failed" || parsed.type === "response.incomplete" || parsed.type === "error";
-	} catch {
-		return false;
-	}
-};
-const createResponsesErrorServerSentEventChunk = (message) => {
-	const errorEvent = {
-		code: null,
-		message,
-		param: null,
-		sequence_number: 0,
-		type: "error"
-	};
-	return {
-		event: errorEvent.type,
-		data: JSON.stringify(errorEvent)
-	};
-};
-const getErrorMessage = (error) => {
-	if (error instanceof Error && error.message) return error.message;
-	return String(error);
-};
-//#endregion
 //#region src/routes/messages/responses-translation.ts
 const MESSAGE_TYPE = "message";
 const COMPACTION_SIGNATURE_PREFIX = "cm1#";
@@ -5037,72 +5782,6 @@ const containsVisionContent = (value) => {
 	return false;
 };
 //#endregion
-//#region src/routes/messages/web-search/backend.ts
-/** Builds the Responses API web_search tool object from the Anthropic config. */
-const buildResponsesWebSearchTool = (config) => {
-	const tool = { type: "web_search" };
-	const filters = {};
-	if (config.allowedDomains?.length) filters.allowed_domains = config.allowedDomains;
-	if (config.blockedDomains?.length) filters.blocked_domains = config.blockedDomains;
-	if (Object.keys(filters).length > 0) tool.filters = filters;
-	if (config.userLocation) tool.user_location = config.userLocation;
-	return tool;
-};
-const isMessageItem = (item) => item.type === "message";
-const isValidUrlCitation = (annotation, seenUrls) => {
-	const ann = annotation;
-	return ann.type === "url_citation" && Boolean(ann.url) && !seenUrls.has(ann.url);
-};
-const collectTextParts = (blocks, seenUrls) => {
-	const textParts = [];
-	const sources = [];
-	for (const block of blocks ?? []) {
-		if (block.type !== "output_text") continue;
-		if (block.text) textParts.push(block.text);
-		for (const annotation of block.annotations ?? []) {
-			if (!isValidUrlCitation(annotation, seenUrls)) continue;
-			const ann = annotation;
-			seenUrls.add(ann.url);
-			sources.push({
-				url: ann.url,
-				title: ann.title ?? ann.url
-			});
-		}
-	}
-	return {
-		textParts,
-		sources
-	};
-};
-const collectQuery = (item, queries) => {
-	if (item.action?.queries?.length) queries.push(...item.action.queries);
-	else if (item.action?.query) queries.push(item.action.query);
-};
-/**
-* Extracts the answer text, deduped sources, and run queries from a GPT
-* /responses web_search result.
-*/
-const extractWebSearchResult = (result) => {
-	const textParts = [];
-	const sources = [];
-	const seenUrls = /* @__PURE__ */ new Set();
-	const queries = [];
-	for (const item of result.output) {
-		if (isMessageItem(item)) {
-			const collected = collectTextParts(item.content, seenUrls);
-			textParts.push(...collected.textParts);
-			sources.push(...collected.sources);
-			continue;
-		}
-		if (item.type === "web_search_call") collectQuery(item, queries);
-	}
-	return {
-		answerText: textParts.join("\n\n").trim() || (result.output_text ?? "").trim(),
-		sources,
-		queries
-	};
-};
-//#endregion
 //#region src/routes/messages/web-search/fulfill.ts
 const webSearchFlowDependencies = {
 	createResponses,
@@ -6686,7 +7365,7 @@ providerAlphaSearchRoutes.post("/", async (c) => {
 			message: `Provider '${provider}' not found or disabled`,
 			type: "invalid_request_error"
 		} }, 404);
-		if (providerConfig.name === "codex") return await handleCodexAlphaSearch(c, providerConfig);
+		if (providerConfig.name === "codex") return await handleAlphaSearchRequest(c, providerConfig);
 		await debugJsonAsync(logger$5, "provider.alpha_search.request", async () => ({
 			body: await c.req.raw.clone().text(),
 			provider
@@ -7259,4 +7938,4 @@ server.route("/:provider/images", providerImageRoutes);
 //#endregion
 export { server };
 
-//# sourceMappingURL=server-D8An7dpg.js.map
+//# sourceMappingURL=server-DZtBoW6V.js.map