@jeffreycao/copilot-api 1.10.36 → 1.11.0

package/dist/{server-DYlw1xSW.js → server-xtwGZKXj.js}

@@ -1,5 +1,5 @@
-import { _ as resolveMappedModel, a as getModelMappings, b as PATHS, c as getRawProviderConfig, d as isMessagesApiEnabled, f as isResponsesApiContextManagementEnabled, i as getExtraPromptForModel, l as getReasoningEffortForModel, m as isResponsesApiWebSocketEnabled, n as getClaudeTokenMultiplier, o as getModelResponsesApiCompactThreshold$1, p as isResponsesApiWebSearchEnabled, r as getConfig, s as getProviderConfig, t as getAnthropicApiKey, u as getSmallModel, v as setModelMappings } from "./config-CgDUUqnp.js";
-import { B as forwardError, C as prepareMessageProxyHeaders, E as compactMessageSections, F as createPooledWebSocketStream, I as createWebSocketUrl, M as generateTraceId, N as requestContext, O as compactSystemPromptStarts, P as resolveTraceId$1, R as state, S as prepareInteractionHeaders, T as compactAutoContinuePromptStarts, _ as getCopilotUsage, b as copilotWebSocketHeaders, d as generateRequestIdFromPayload, f as getRootSessionId, g as sleep, h as parseUserIdMetadata, j as forwardCodexResponses, m as isNullish, p as getUUID, r as setupCodexToken, s as cacheModels, v as copilotBaseUrl, x as prepareForCompact, y as copilotHeaders, z as HTTPError } from "./token-CHTEbXZd.js";
+import { S as PATHS, a as getMessageApiWebSearchModel, b as setModelMappings, c as getProviderConfig, d as getReasoningEffortForModel, f as getSmallModel, g as isResponsesApiWebSocketEnabled, h as isResponsesApiWebSearchEnabled, i as getExtraPromptForModel, l as getProviderMessageApiWebSearchModel, m as isResponsesApiContextManagementEnabled, n as getClaudeTokenMultiplier, o as getModelMappings, p as isMessagesApiEnabled, r as getConfig, s as getModelResponsesApiCompactThreshold$1, t as getAnthropicApiKey, u as getRawProviderConfig, y as resolveMappedModel } from "./config-Cni8ffEV.js";
+import { B as forwardError, C as prepareMessageProxyHeaders, E as compactMessageSections, F as createPooledWebSocketStream, I as createWebSocketUrl, M as generateTraceId, N as requestContext, O as compactSystemPromptStarts, P as resolveTraceId$1, R as state, S as prepareInteractionHeaders, T as compactAutoContinuePromptStarts, _ as getCopilotUsage, b as copilotWebSocketHeaders, d as generateRequestIdFromPayload, f as getRootSessionId, g as sleep, h as parseUserIdMetadata, j as forwardCodexResponses, m as isNullish, p as getUUID, r as setupCodexToken, s as cacheModels, v as copilotBaseUrl, x as prepareForCompact, y as copilotHeaders, z as HTTPError } from "./token-ZyYn_xJt.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 { createHash } from "node:crypto";
@@ -1020,6 +1020,7 @@ function createProviderProxyResponse(upstreamResponse, body) {
 	});
 }
 async function forwardProviderMessages(providerConfig, payload, requestHeaders) {
+	consola.log(`<-- model: ${payload.model}`);
 	return await fetch(`${providerConfig.baseUrl}/v1/messages`, {
 		method: "POST",
 		headers: buildProviderUpstreamHeaders(providerConfig, requestHeaders),
@@ -1027,6 +1028,7 @@ async function forwardProviderMessages(providerConfig, payload, requestHeaders)
 	});
 }
 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),
@@ -1034,6 +1036,7 @@ async function forwardProviderChatCompletions(providerConfig, payload, requestHe
 	});
 }
 async function forwardProviderResponses(providerConfig, payload, requestHeaders) {
+	consola.log(`<-- model: ${payload.model}`);
 	return await fetch(`${providerConfig.baseUrl}/v1/responses`, {
 		method: "POST",
 		headers: buildProviderUpstreamHeaders(providerConfig, requestHeaders),
@@ -4149,6 +4152,303 @@ 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,
+	createUsageRecorder: (payload, sessionId, webSearchModel) => createCopilotTokenUsageRecorder({
+		endpoint: "responses",
+		fallbackSessionId: sessionId,
+		model: webSearchModel ?? payload.model,
+		sessionId: parseUserIdMetadata(payload.metadata?.user_id).sessionId
+	})
+};
+const isWebSearchServerTool = (tool) => typeof tool.type === "string" && tool.type.startsWith("web_search") && !tool.input_schema;
+/** True when the payload carries an Anthropic server-side web_search tool. */
+const hasWebSearchServerTool = (payload) => Array.isArray(payload.tools) && payload.tools.some(isWebSearchServerTool);
+/**
+* True when web_search is the ONLY tool in the request. Mixing web_search with
+* other tools is intentionally unsupported, so only these requests are switched
+* to the web search model.
+*/
+const isWebSearchOnlyRequest = (payload) => Array.isArray(payload.tools) && payload.tools.length > 0 && payload.tools.every(isWebSearchServerTool);
+/** Removes web_search server tools (used for unsupported mixed-tool requests). */
+const stripWebSearchServerTool = (payload) => {
+	if (!Array.isArray(payload.tools)) return;
+	payload.tools = payload.tools.filter((tool) => !isWebSearchServerTool(tool));
+};
+const resolveWebSearchRoute = (payload, options) => {
+	const { webSearchModel, responsesWebSearchEnabled } = options;
+	if (!webSearchModel || !isWebSearchOnlyRequest(payload)) return { kind: "strip" };
+	const alias = parseProviderModelAlias(webSearchModel);
+	if (alias) return {
+		kind: "provider",
+		alias
+	};
+	if (responsesWebSearchEnabled) return {
+		kind: "responses",
+		model: webSearchModel
+	};
+	return { kind: "strip" };
+};
+const extractWebSearchConfig = (payload) => {
+	const tool = payload.tools?.find(isWebSearchServerTool);
+	return {
+		allowedDomains: tool?.allowed_domains,
+		blockedDomains: tool?.blocked_domains,
+		userLocation: tool?.user_location
+	};
+};
+const buildWebSearchResultBlock = (toolUseId, extract) => {
+	return {
+		type: "web_search_tool_result",
+		tool_use_id: toolUseId,
+		content: extract.sources.map((source) => ({
+			type: "web_search_result",
+			url: source.url,
+			title: source.title,
+			page_age: source.page_age ?? null,
+			encrypted_content: ""
+		}))
+	};
+};
+/**
+* Reconstructs a native Anthropic assistant response from the GPT web search
+* result: one server_tool_use + web_search_tool_result pair, then the answer.
+*/
+const buildResponseContent = (requestId, extract) => {
+	const blocks = [];
+	const query = extract.queries[0] ?? "";
+	if (extract.sources.length > 0 || query) {
+		const toolUseId = `srvtoolu_${getUUID(requestId)}`;
+		blocks.push({
+			type: "server_tool_use",
+			id: toolUseId,
+			name: "web_search",
+			input: { query }
+		}, buildWebSearchResultBlock(toolUseId, extract));
+	}
+	blocks.push({
+		type: "text",
+		text: extract.answerText
+	});
+	return blocks;
+};
+const prepareWebSearchResponsesPayload = (payload, options = {}) => {
+	const config = extractWebSearchConfig(payload);
+	const responsesPayload = translateAnthropicMessagesToResponsesPayload({
+		...payload,
+		model: options.model ?? payload.model,
+		tools: [],
+		stream: false
+	}, options.subagentAgentId);
+	responsesPayload.tools = [buildResponsesWebSearchTool(config)];
+	responsesPayload.tool_choice = void 0;
+	return responsesPayload;
+};
+const reconstructWebSearchResponse = (payload, result, options) => {
+	const extract = extractWebSearchResult(result);
+	return {
+		extract,
+		response: {
+			id: result.id || getUUID(options.requestId),
+			type: "message",
+			role: "assistant",
+			content: buildResponseContent(options.requestId, extract),
+			model: payload.model,
+			stop_reason: "end_turn",
+			stop_sequence: null,
+			usage: {
+				input_tokens: result.usage?.input_tokens ?? 0,
+				output_tokens: result.usage?.output_tokens ?? 0,
+				server_tool_use: { web_search_requests: Math.max(extract.queries.length, 1) }
+			}
+		}
+	};
+};
+const createUsageRecorder = (payload, sessionId, webSearchModel) => webSearchFlowDependencies.createUsageRecorder(payload, sessionId, webSearchModel);
+/**
+* Handles a web-search-only Claude (Messages API) request by switching it to a
+* Responses-capable GPT model (`webSearchModel`), running Copilot's native
+* /responses web_search in a single call, and reconstructing native Anthropic
+* server_tool_use + web_search_tool_result blocks. Streaming and non-streaming
+* are both supported (streaming replays the result as a synthetic SSE stream).
+*/
+const handleWebSearchViaResponses = async (c, payload, options) => {
+	const { logger, webSearchModel } = options;
+	const wantsStream = Boolean(payload.stream);
+	const responsesPayload = prepareWebSearchResponsesPayload(payload, {
+		model: webSearchModel,
+		subagentAgentId: options.subagentMarker?.agent_id
+	});
+	const selectedModel = findEndpointModel(webSearchModel);
+	const { vision, initiator } = getResponsesRequestOptions(responsesPayload);
+	const transport = getResponsesTransportForModel(selectedModel, { compactType: options.compactType }) ?? "http";
+	logger.debug(`Switching web search request to model: ${webSearchModel} ${JSON.stringify(responsesPayload)}`);
+	const result = await webSearchFlowDependencies.createResponses(responsesPayload, {
+		vision,
+		initiator,
+		transport,
+		subagentMarker: options.subagentMarker,
+		requestId: options.requestId,
+		sessionId: options.sessionId,
+		compactType: options.compactType
+	});
+	const { extract, response } = reconstructWebSearchResponse(payload, result, { requestId: options.requestId });
+	logger.debug(`Web search via responses: ${extract.queries.length} quer(y/ies), ${extract.sources.length} source(s), ${JSON.stringify(result)}`);
+	createUsageRecorder(payload, options.sessionId, webSearchModel)(normalizeResponsesUsage(result.usage));
+	if (!wantsStream) return c.json(response);
+	return streamSSE(c, async (stream) => {
+		for (const event of buildSyntheticStreamEvents(response)) await stream.writeSSE({
+			event: event.type,
+			data: JSON.stringify(event)
+		});
+	});
+};
+const blockToStreamEvents = (block, index) => {
+	const start = (contentBlock) => ({
+		type: "content_block_start",
+		index,
+		content_block: contentBlock
+	});
+	const stop = {
+		type: "content_block_stop",
+		index
+	};
+	switch (block.type) {
+		case "text": return [
+			start({
+				type: "text",
+				text: ""
+			}),
+			{
+				type: "content_block_delta",
+				index,
+				delta: {
+					type: "text_delta",
+					text: block.text
+				}
+			},
+			stop
+		];
+		case "server_tool_use": return [
+			start({
+				type: "server_tool_use",
+				id: block.id,
+				name: block.name,
+				input: {}
+			}),
+			{
+				type: "content_block_delta",
+				index,
+				delta: {
+					type: "input_json_delta",
+					partial_json: JSON.stringify(block.input)
+				}
+			},
+			stop
+		];
+		case "web_search_tool_result": return [start(block), stop];
+		default: return [start(block), stop];
+	}
+};
+const buildSyntheticStreamEvents = (response) => {
+	const events = [];
+	events.push({
+		type: "message_start",
+		message: {
+			id: response.id,
+			type: "message",
+			role: "assistant",
+			content: [],
+			model: response.model,
+			stop_reason: null,
+			stop_sequence: null,
+			usage: {
+				...response.usage,
+				output_tokens: 0
+			}
+		}
+	});
+	response.content.forEach((block, index) => {
+		events.push(...blockToStreamEvents(block, index));
+	});
+	events.push({
+		type: "message_delta",
+		delta: {
+			stop_reason: response.stop_reason,
+			stop_sequence: response.stop_sequence
+		},
+		usage: { output_tokens: response.usage.output_tokens }
+	}, { type: "message_stop" });
+	return events;
+};
+//#endregion
 //#region src/services/codex/get-models.ts
 const CODEX_MODELS = [
 	{
@@ -4244,6 +4544,7 @@ async function handleProviderMessages(c) {
 }
 async function handleProviderMessagesForProvider(c, options) {
 	const { payload, provider } = options;
+	const webSearchRerouteDepth = options.webSearchRerouteDepth ?? 0;
 	const providerConfig = await resolveProviderConfig(provider);
 	if (!providerConfig) return c.json({ error: {
 		message: `Provider '${provider}' not found or disabled`,
@@ -4256,19 +4557,41 @@ async function handleProviderMessagesForProvider(c, options) {
 			provider
 		});
 		normalizeSystemMessages(payload);
-		applyModelDefaults(payload, modelConfig);
-		if (providerConfig.type === "openai-responses") return await handleOpenAIResponsesProviderMessages(c, {
-			modelConfig,
-			payload,
-			provider,
-			providerConfig
-		});
-		if (providerConfig.type === "openai-compatible") return await handleOpenAICompatibleProviderMessages(c, {
-			modelConfig,
-			payload,
-			provider,
-			providerConfig
+		const providerWebSearchRoute = webSearchRerouteDepth === 0 ? resolveProviderWebSearchRoute(payload, { provider }) : null;
+		if (providerWebSearchRoute) return await handleProviderMessagesForProvider(c, {
+			payload: {
+				...payload,
+				model: providerWebSearchRoute.model
+			},
+			provider: providerWebSearchRoute.provider,
+			webSearchRerouteDepth: webSearchRerouteDepth + 1
 		});
+		applyModelDefaults(payload, modelConfig);
+		if (providerConfig.type === "openai-responses") {
+			if (hasWebSearchServerTool(payload)) {
+				if (isWebSearchOnlyRequest(payload)) return await handleOpenAIResponsesProviderWebSearchMessages(c, {
+					payload,
+					provider,
+					providerConfig
+				});
+				stripWebSearchServerTool(payload);
+			}
+			return await handleOpenAIResponsesProviderMessages(c, {
+				modelConfig,
+				payload,
+				provider,
+				providerConfig
+			});
+		}
+		if (providerConfig.type === "openai-compatible") {
+			stripWebSearchServerTool(payload);
+			return await handleOpenAICompatibleProviderMessages(c, {
+				modelConfig,
+				payload,
+				provider,
+				providerConfig
+			});
+		}
 		applyMissingExtraBody(payload, { extraBody: modelConfig?.extraBody });
 		debugJson(logger$5, "Translated provider.messages.request", {
 			payload,
@@ -4301,6 +4624,48 @@ async function handleProviderMessagesForProvider(c, options) {
 		throw error;
 	}
 }
+const resolveProviderWebSearchRoute = (payload, options) => {
+	if (!hasWebSearchServerTool(payload) || !isWebSearchOnlyRequest(payload)) return null;
+	const configuredModel = getProviderMessageApiWebSearchModel();
+	if (!configuredModel) return null;
+	const alias = parseProviderModelAlias(configuredModel);
+	const provider = alias?.provider ?? options.provider;
+	const model = alias?.model ?? configuredModel;
+	if (provider === options.provider && model === payload.model) return null;
+	return {
+		model,
+		provider
+	};
+};
+const handleOpenAIResponsesProviderWebSearchMessages = 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 = prepareWebSearchResponsesPayload(payload);
+	applyResponsesApiContextManagement(responsesPayload, selectedModel?.capabilities.limits.max_prompt_tokens);
+	compactInputByLatestCompaction(responsesPayload);
+	debugJson(logger$5, "provider.messages.responses.web_search.request", {
+		payload: responsesPayload,
+		provider
+	});
+	if (providerConfig.name === "codex") return respondWebSearchProviderMessagesJson(c, {
+		body: await forwardCodexResponses(responsesPayload, c.req.raw.headers, providerConfig.baseUrl),
+		payload,
+		provider
+	});
+	const upstreamResponse = await forwardProviderResponses(providerConfig, responsesPayload, c.req.raw.headers);
+	if (!upstreamResponse.ok) {
+		logger$5.error("Failed to create provider web search responses", {
+			provider,
+			upstreamResponse
+		});
+		throw new HTTPError("Failed to create provider web search responses", upstreamResponse);
+	}
+	return respondWebSearchProviderMessagesJson(c, {
+		body: await upstreamResponse.json(),
+		payload,
+		provider
+	});
+};
 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;
@@ -4666,6 +5031,19 @@ const respondResponsesProviderMessagesJson = (c, options) => {
 	if (providerConfig.name === "codex") logger$5.debug("provider.messages.codex.no_stream.result");
 	return c.json(anthropicResponse);
 };
+const respondWebSearchProviderMessagesJson = (c, options) => {
+	const { body, payload, provider } = options;
+	createProviderMessagesUsageRecorder(payload, provider)(normalizeResponsesUsage(body.usage));
+	const { extract, response } = reconstructWebSearchResponse(payload, body, { requestId: body.id || `${provider}:${payload.model}` });
+	logger$5.debug(`provider.messages.responses.web_search: ${extract.queries.length} quer(y/ies), ${extract.sources.length} source(s)`);
+	if (!payload.stream) return c.json(response);
+	return streamSSE(c, async (stream) => {
+		for (const event of buildSyntheticStreamEvents(response)) await stream.writeSSE({
+			event: event.type,
+			data: JSON.stringify(event)
+		});
+	});
+};
 const createProviderMessagesUsageRecorder = (payload, provider) => createProviderTokenUsageRecorder({
 	endpoint: "provider_messages",
 	model: payload.model,
@@ -5043,6 +5421,28 @@ async function handleCompletion(c) {
 	if (state.manualApprove) await awaitApproval();
 	const selectedModel = findEndpointModel(anthropicPayload.model);
 	anthropicPayload.model = selectedModel?.id ?? anthropicPayload.model;
+	if (hasWebSearchServerTool(anthropicPayload)) {
+		const route = resolveWebSearchRoute(anthropicPayload, {
+			webSearchModel: getMessageApiWebSearchModel(),
+			responsesWebSearchEnabled: isResponsesApiWebSearchEnabled()
+		});
+		if (route.kind === "provider") {
+			anthropicPayload.model = route.alias.model;
+			return await handleProviderMessagesForProvider(c, {
+				payload: anthropicPayload,
+				provider: route.alias.provider
+			});
+		}
+		if (route.kind === "responses") return await handleWebSearchViaResponses(c, anthropicPayload, {
+			subagentMarker,
+			webSearchModel: route.model,
+			requestId,
+			sessionId,
+			compactType,
+			logger: logger$4
+		});
+		stripWebSearchServerTool(anthropicPayload);
+	}
 	if (shouldUseMessagesApi(selectedModel)) return await messagesFlowHandlers.handleWithMessagesApi(c, anthropicPayload, {
 		anthropicBetaHeader: anthropicBeta,
 		subagentMarker,
@@ -5570,4 +5970,4 @@ server.route("/:provider/v1/models", providerModelRoutes);
 //#endregion
 export { server };
 
-//# sourceMappingURL=server-DYlw1xSW.js.map
+//# sourceMappingURL=server-xtwGZKXj.js.map