@nick3/copilot-api 1.10.4 → 1.10.7

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

@@ -2,7 +2,8 @@ import { A as state, D as prepareInteractionHeaders, E as prepareForCompact, I a
 import { a as getAccountClientIdentityByLoginAndApp, b as getCurrentIdentityEnvironment, d as loadRegistry, g as saveRegistry, h as saveAccountToken, l as listAccountsFromRegistry, m as removeAccountToken, p as removeAccountFromRegistry, r as addAccountToRegistry, t as isAccountType } from "./account-COtMmvzU.js";
 import { r as ensurePaths, t as PATHS } from "./paths-CclKwouX.js";
 import { i as getRequestOutboundStore, r as getRedactedHeaderKeys } from "./request-outbound-Pu1kp2x8.js";
-import { A as getModelRefreshIntervalMs, B as isResponsesApiWebSocketEnabled, C as getAnthropicApiKey, D as getLogLevel, E as getExtraPromptForModel, F as isForceAgentEnabled, H as resolveModelAlias, I as isMessageStartInputTokensFallbackEnabled, L as isMessagesApiEnabled, M as getReasoningEffortForModel, N as getSmallModel, O as getModelAliases, P as isAccountAffinityEnabled, R as isResponsesApiContextManagementModel, S as getAliasTargetSet, T as getConfig, U as shouldCompactUseSmallModel, V as mergeConfigWithDefaults, _ as toLocalDateString, b as isDevModeEnabled, c as applySharedSessionAffinityRetention, d as getClientIpInfo, f as getRequestHistoryStore, g as normalizeMessagesUsage, h as normalizeEmbeddingsUsage, j as getProviderConfig, k as getModelAliasesInfo, l as extractResponsesUsageFromResult, m as normalizeChatCompletionsUsage, o as updateQuotaRefreshSchedulerFromConfig, p as getStatsStore, s as accountsManager, t as getProxyEnvDispatcher, u as extractResponsesUsageFromStreamEvent, v as copilotFetch, w as getClaudeTokenMultiplier, x as PROVIDER_TYPE_ANTHROPIC, y as flushPendingCapture, z as isResponsesApiWebSearchEnabled } from "./proxy-BwmADhKh.js";
+import { a as isDeferredToolName, c as parseMcpToolSearchSentinel, i as isBridgeToolSearchName, l as selectDeferredToolsByNames, o as listDeferredToolNames, r as formatToolSearchBridgeArguments, s as normalizeToolSearchBridgeArguments, t as BRIDGE_TOOL_SEARCH_NAME, u as shouldEnableResponsesToolSearch } from "./tool-search-BrN7M0Dd.js";
+import { A as getModelRefreshIntervalMs, B as isResponsesApiWebSocketEnabled, C as getAnthropicApiKey, D as getLogLevel, E as getExtraPromptForModel, F as isForceAgentEnabled, H as resolveModelAlias, I as isMessageStartInputTokensFallbackEnabled, L as isMessagesApiEnabled, M as getReasoningEffortForModel, N as getSmallModel, O as getModelAliases, P as isAccountAffinityEnabled, R as isResponsesApiContextManagementModel, S as getAliasTargetSet, T as getConfig, U as shouldCompactUseSmallModel, V as mergeConfigWithDefaults, _ as toLocalDateString, b as isDevModeEnabled, c as applySharedSessionAffinityRetention, d as getClientIpInfo, f as getRequestHistoryStore, g as normalizeMessagesUsage, h as normalizeEmbeddingsUsage, j as getProviderConfig, k as getModelAliasesInfo, l as extractResponsesUsageFromResult, m as normalizeChatCompletionsUsage, o as updateQuotaRefreshSchedulerFromConfig, p as getStatsStore, s as accountsManager, t as getProxyEnvDispatcher, u as extractResponsesUsageFromStreamEvent, v as copilotFetch, w as getClaudeTokenMultiplier, x as PROVIDER_TYPE_ANTHROPIC, y as flushPendingCapture, z as isResponsesApiWebSearchEnabled } from "./proxy-YVh74m0I.js";
 import consola from "consola";
 import fs, { readFile } from "node:fs/promises";
 import { createHash, randomUUID, timingSafeEqual } from "node:crypto";
@@ -696,6 +697,25 @@ const IDE_EXECUTE_CODE_TOOL = "mcp__ide__executeCode";
 const IDE_GET_DIAGNOSTICS_TOOL = "mcp__ide__getDiagnostics";
 const IDE_GET_DIAGNOSTICS_DESCRIPTION = "Get language diagnostics from VS Code. Returns errors, warnings, information, and hints for files in the workspace.";
 const PDF_FILE_READ_PREFIX = "PDF file read:";
+const getBlockCacheControl = (block) => {
+	if (!block || block.type === "thinking") return;
+	const cacheControl = block.cache_control;
+	if (!cacheControl || typeof cacheControl !== "object") return;
+	return cacheControl;
+};
+const getLastMessageContentCacheControl = (lastMessage) => {
+	if (!lastMessage || !Array.isArray(lastMessage.content)) return;
+	const cacheControl = getBlockCacheControl(lastMessage.content.at(-1));
+	return cacheControl ? { ...cacheControl } : void 0;
+};
+const applyLastMessageCacheControl = (anthropicPayload, lastMessageCacheControl) => {
+	const cacheControl = lastMessageCacheControl ?? { type: "ephemeral" };
+	const lastMessage = anthropicPayload.messages.at(-1);
+	if (!lastMessage || !Array.isArray(lastMessage.content)) return;
+	const lastBlock = lastMessage.content.at(-1);
+	if (!lastBlock || lastBlock.type === "thinking" || lastBlock.cache_control) return;
+	lastBlock.cache_control = { ...cacheControl };
+};
 const getCompactCandidateText = (message) => {
 	if (message.role !== "user") return "";
 	if (typeof message.content === "string") return message.content;
@@ -5013,10 +5033,19 @@ const translateAnthropicMessagesToResponsesPayload = (payload, options = {}) =>
 	const model = options.modelOverride ?? payload.model;
 	const input = [];
 	const applyPhase = shouldApplyPhase(payload.model);
-	for (const message of payload.messages) input.push(...translateMessage(message, payload.model, applyPhase));
+	const toolSearchEnabled = shouldEnableResponsesToolSearch({
+		model: payload.model,
+		tools: payload.tools
+	});
+	const translationState = {
+		originalTools: payload.tools ?? [],
+		toolSearchEnabled,
+		toolUseNameById: /* @__PURE__ */ new Map()
+	};
+	for (const message of payload.messages) input.push(...translateMessage(message, payload.model, applyPhase, translationState));
 	const hasOriginalTools = Array.isArray(payload.tools) && payload.tools.length > 0;
-	const translatedTools = convertAnthropicTools(payload.tools);
-	const toolChoice = convertAnthropicToolChoice(payload.tool_choice);
+	const translatedTools = convertAnthropicTools(payload.tools, toolSearchEnabled);
+	const toolChoice = convertAnthropicToolChoice(payload.tool_choice, toolSearchEnabled);
 	const { sessionId: metadataPromptCacheKey } = parseUserIdMetadata(payload.metadata?.user_id);
 	const sessionAffinity = requestContext.getStore()?.sessionAffinity?.trim() || null;
 	const promptCacheKey = buildPromptCacheKey(metadataPromptCacheKey ?? sessionAffinity, options.subagentAgentId);
@@ -5059,11 +5088,11 @@ const decodeCompactionCarrierSignature = (signature) => {
 		};
 	}
 };
-const translateMessage = (message, model, applyPhase) => {
-	if (message.role === "user") return translateUserMessage(message);
-	return translateAssistantMessage(message, model, applyPhase);
+const translateMessage = (message, model, applyPhase, state) => {
+	if (message.role === "user") return translateUserMessage(message, state);
+	return translateAssistantMessage(message, model, applyPhase, state);
 };
-const translateUserMessage = (message) => {
+const translateUserMessage = (message, state) => {
 	if (typeof message.content === "string") return [createMessage("user", message.content)];
 	if (!Array.isArray(message.content)) return [];
 	const items = [];
@@ -5071,7 +5100,7 @@ const translateUserMessage = (message) => {
 	for (const block of message.content) {
 		if (block.type === "tool_result") {
 			flushPendingContent(pendingContent, items, { role: "user" });
-			items.push(createFunctionCallOutput(block));
+			items.push(createToolCallOutput(block, state));
 			continue;
 		}
 		const converted = translateUserContentBlock(block);
@@ -5080,7 +5109,7 @@ const translateUserMessage = (message) => {
 	flushPendingContent(pendingContent, items, { role: "user" });
 	return items;
 };
-const translateAssistantMessage = (message, model, applyPhase) => {
+const translateAssistantMessage = (message, model, applyPhase, state) => {
 	const assistantPhase = resolveAssistantPhase(model, message.content, applyPhase);
 	if (typeof message.content === "string") return [createMessage("assistant", message.content, assistantPhase)];
 	if (!Array.isArray(message.content)) return [];
@@ -5088,11 +5117,12 @@ const translateAssistantMessage = (message, model, applyPhase) => {
 	const pendingContent = [];
 	for (const block of message.content) {
 		if (block.type === "tool_use") {
+			state.toolUseNameById.set(block.id, block.name);
 			flushPendingContent(pendingContent, items, {
 				role: "assistant",
 				phase: assistantPhase
 			});
-			items.push(createFunctionToolCall(block));
+			items.push(createToolCall(block, state));
 			continue;
 		}
 		if (block.type === "thinking" && block.signature) {
@@ -5210,19 +5240,79 @@ const parseReasoningSignature$1 = (signature) => {
 		id: signature.slice(splitIndex + 1)
 	};
 };
-const createFunctionToolCall = (block) => ({
+const createFunctionToolCall = (block, state) => ({
 	type: "function_call",
 	call_id: block.id,
 	name: block.name,
 	arguments: JSON.stringify(block.input),
+	status: "completed",
+	...state.toolSearchEnabled && isDeferredToolName(block.name) ? { namespace: block.name } : {}
+});
+const createToolSearchCall = (block) => ({
+	type: "tool_search_call",
+	call_id: block.id,
+	arguments: normalizeToolSearchBridgeArguments(block.input),
+	execution: "client",
 	status: "completed"
 });
+const createToolCall = (block, state) => {
+	if (state.toolSearchEnabled && isBridgeToolSearchName(block.name)) return createToolSearchCall(block);
+	return createFunctionToolCall(block, state);
+};
 const createFunctionCallOutput = (block) => ({
 	type: "function_call_output",
 	call_id: block.tool_use_id,
 	output: convertToolResultContent(block.content),
 	status: block.is_error ? "incomplete" : "completed"
 });
+const createToolCallOutput = (block, state) => {
+	const toolUseName = state.toolUseNameById.get(block.tool_use_id);
+	if (state.toolSearchEnabled && isBridgeToolSearchName(toolUseName ?? "")) return createToolSearchOutput(block, state.originalTools);
+	return createFunctionCallOutput(block);
+};
+const createToolSearchOutput = (block, originalTools) => {
+	const referencedToolNames = resolveToolSearchReferencedToolNames(block.content, originalTools);
+	return {
+		type: "tool_search_output",
+		call_id: block.tool_use_id,
+		tools: referencedToolNames.map((toolName) => convertDeferredToolToNamespace(resolveDeferredTool(toolName, originalTools))),
+		execution: "client",
+		status: block.is_error ? "incomplete" : "completed"
+	};
+};
+const resolveToolSearchReferencedToolNames = (content, originalTools) => {
+	const explicitReferences = extractToolReferenceNames(content);
+	if (explicitReferences.length > 0) return uniqueToolNames(explicitReferences);
+	const sentinel = extractMcpToolSearchSentinel(content);
+	if (sentinel) return selectDeferredToolsByNames(sentinel.names, originalTools).map((tool) => tool.name);
+	return [];
+};
+const extractToolReferenceNames = (content) => {
+	if (!Array.isArray(content)) return [];
+	return content.flatMap((block) => block.type === "tool_reference" ? [block.tool_name] : []);
+};
+const extractMcpToolSearchSentinel = (content) => {
+	if (typeof content === "string") return parseMcpToolSearchSentinel(content);
+	for (const block of content) {
+		if (block.type !== "text") continue;
+		const sentinel = parseMcpToolSearchSentinel(block.text);
+		if (sentinel) return sentinel;
+	}
+	return null;
+};
+const resolveDeferredTool = (toolName, originalTools) => {
+	const tool = originalTools.find((candidate) => candidate.name === toolName);
+	if (tool && isDeferredToolName(tool.name)) return tool;
+	throw createInvalidRequestError(`Tool reference '${toolName}' has no corresponding deferred tool definition`);
+};
+const uniqueToolNames = (toolNames) => [...new Set(toolNames)];
+const createInvalidRequestError = (message) => new HTTPError(message, new Response(JSON.stringify({ error: {
+	message,
+	type: "invalid_request_error"
+} }), {
+	status: 400,
+	headers: { "content-type": "application/json" }
+}));
 const translateSystemPrompt = (system, model) => {
 	if (!system) return null;
 	const extraPrompt = getExtraPromptForModel(model);
@@ -5233,31 +5323,83 @@ const translateSystemPrompt = (system, model) => {
 	}).join(" ");
 	return text.length > 0 ? text : null;
 };
-const convertAnthropicTools = (tools) => {
+const convertAnthropicTools = (tools, toolSearchEnabled) => {
 	if (!tools || tools.length === 0) return null;
-	return tools.map((tool) => ({
+	const converted = [];
+	let addedToolSearch = false;
+	const searchableToolNames = toolSearchEnabled ? listDeferredToolNames(tools) : [];
+	for (const tool of tools) {
+		if (isBridgeToolSearchName(tool.name)) {
+			if (toolSearchEnabled && !addedToolSearch) {
+				converted.push(createResponsesToolSearchDefinition(searchableToolNames));
+				addedToolSearch = true;
+			}
+			continue;
+		}
+		if (toolSearchEnabled && isDeferredToolName(tool.name)) {
+			converted.push(convertDeferredToolToNamespace(tool));
+			continue;
+		}
+		converted.push(convertToolToFunction(tool));
+	}
+	return converted;
+};
+const createResponsesToolSearchDefinition = (searchableToolNames) => ({
+	type: "tool_search",
+	execution: "client",
+	description: "Load deferred tools by exact name before using them. Return only the searchable tool names you need for the next step.",
+	parameters: {
+		type: "object",
+		properties: { names: {
+			type: "array",
+			description: "Exact deferred tool names to load.",
+			items: {
+				type: "string",
+				enum: searchableToolNames
+			},
+			minItems: 1
+		} },
+		required: ["names"],
+		additionalProperties: false
+	}
+});
+const convertToolToFunction = (tool) => ({
+	type: "function",
+	name: tool.name,
+	parameters: normalizeToolSchema(tool.input_schema),
+	strict: false,
+	...tool.description ? { description: tool.description } : {}
+});
+const convertDeferredToolToNamespace = (tool) => ({
+	type: "namespace",
+	name: tool.name,
+	...tool.description ? { description: tool.description } : {},
+	tools: [{
 		type: "function",
 		name: tool.name,
 		parameters: normalizeToolSchema(tool.input_schema),
 		strict: false,
+		defer_loading: true,
 		...tool.description ? { description: tool.description } : {}
-	}));
-};
-const convertAnthropicToolChoice = (choice) => {
+	}]
+});
+const convertAnthropicToolChoice = (choice, toolSearchEnabled) => {
 	if (!choice) return "auto";
 	switch (choice.type) {
 		case "auto": return "auto";
 		case "any": return "required";
-		case "tool": return choice.name ? {
-			type: "function",
-			name: choice.name
-		} : "auto";
+		case "tool":
+			if (toolSearchEnabled && choice.name && isBridgeToolSearchName(choice.name)) return "auto";
+			return choice.name ? {
+				type: "function",
+				name: choice.name
+			} : "auto";
 		case "none": return "none";
 		default: return "auto";
 	}
 };
-const translateResponsesResultToAnthropic = (response) => {
-	const contentBlocks = mapOutputToAnthropicContent(response.output);
+const translateResponsesResultToAnthropic = (response, options) => {
+	const contentBlocks = mapOutputToAnthropicContent(response.output, options);
 	const usage = mapResponsesUsage(response);
 	let anthropicContent = fallbackContentBlocks(response.output_text);
 	if (contentBlocks.length > 0) anthropicContent = contentBlocks;
@@ -5273,7 +5415,7 @@ const translateResponsesResultToAnthropic = (response) => {
 		usage
 	};
 };
-const mapOutputToAnthropicContent = (output) => {
+const mapOutputToAnthropicContent = (output, options) => {
 	const contentBlocks = [];
 	for (const item of output) switch (item.type) {
 		case "reasoning": {
@@ -5290,6 +5432,12 @@ const mapOutputToAnthropicContent = (output) => {
 			if (toolUseBlock) contentBlocks.push(toolUseBlock);
 			break;
 		}
+		case "tool_search_call": {
+			const toolUseBlock = createToolSearchUseContentBlock(item, options?.toolSearchName);
+			if (toolUseBlock) contentBlocks.push(toolUseBlock);
+			break;
+		}
+		case "tool_search_output": break;
 		case "message": {
 			const combinedText = combineMessageTextContent(item.content);
 			if (combinedText.length > 0) contentBlocks.push({
@@ -5351,15 +5499,29 @@ const extractReasoningText = (item) => {
 };
 const createToolUseContentBlock = (call) => {
 	const toolId = call.call_id;
-	if (!call.name || !toolId) return null;
-	const input = parseFunctionCallArguments(call.arguments);
+	const toolName = resolveToolUseName(call);
+	if (!toolName || !toolId) return null;
 	return {
 		type: "tool_use",
 		id: toolId,
-		name: call.name,
-		input
+		name: toolName,
+		input: parseFunctionCallArguments(call.arguments)
 	};
 };
+const createToolSearchUseContentBlock = (call, toolSearchName = BRIDGE_TOOL_SEARCH_NAME) => {
+	const toolId = call.call_id;
+	if (!toolId) return null;
+	return {
+		type: "tool_use",
+		id: toolId,
+		name: toolSearchName,
+		input: parseToolSearchArguments(call.arguments)
+	};
+};
+const resolveToolUseName = (call) => {
+	if (typeof call.namespace === "string" && call.namespace.length > 0) return call.namespace;
+	return call.name;
+};
 const createCompactionThinkingBlock = (item) => {
 	if (!item.id || !item.encrypted_content) return null;
 	return {
@@ -5385,6 +5547,9 @@ const parseFunctionCallArguments = (rawArguments) => {
 	}
 	return { raw_arguments: rawArguments };
 };
+const parseToolSearchArguments = (argumentsValue) => {
+	return formatToolSearchBridgeArguments(argumentsValue);
+};
 const fallbackContentBlocks = (outputText) => {
 	if (!outputText) return [];
 	return [{
@@ -5395,7 +5560,7 @@ const fallbackContentBlocks = (outputText) => {
 const mapResponsesStopReason = (response) => {
 	const { status, incomplete_details: incompleteDetails } = response;
 	if (status === "completed") {
-		if (response.output.some((item) => item.type === "function_call")) return "tool_use";
+		if (response.output.some((item) => item.type === "function_call" || item.type === "tool_search_call")) return "tool_use";
 		return "end_turn";
 	}
 	if (status === "incomplete") {
@@ -6329,14 +6494,15 @@ const updateWhitespaceRunState = (previousCount, chunk) => {
 		exceeded: false
 	};
 };
-const createResponsesStreamState = () => ({
+const createResponsesStreamState = (options) => ({
 	messageStartSent: false,
 	messageCompleted: false,
 	nextContentBlockIndex: 0,
 	blockIndexByKey: /* @__PURE__ */ new Map(),
 	openBlocks: /* @__PURE__ */ new Set(),
 	blockHasDelta: /* @__PURE__ */ new Set(),
-	functionCallStateByOutputIndex: /* @__PURE__ */ new Map()
+	functionCallStateByOutputIndex: /* @__PURE__ */ new Map(),
+	toolSearchName: options?.toolSearchName ?? "mcp__tool_search__search"
 });
 const translateResponsesStreamEvent = (rawEvent, state) => {
 	switch (rawEvent.type) {
@@ -6361,7 +6527,7 @@ const handleResponseCreated = (rawEvent, state) => {
 };
 const handleOutputItemAdded$1 = (rawEvent, state) => {
 	const events = new Array();
-	const functionCallDetails = extractFunctionCallDetails(rawEvent);
+	const functionCallDetails = extractFunctionCallDetails(rawEvent, state);
 	if (!functionCallDetails) return events;
 	const { outputIndex, toolCallId, name, initialArguments } = functionCallDetails;
 	const blockIndex = openFunctionCallBlock(state, {
@@ -6388,6 +6554,28 @@ const handleOutputItemDone$1 = (rawEvent, state) => {
 	const item = rawEvent.item;
 	const itemType = item.type;
 	const outputIndex = rawEvent.output_index;
+	if (itemType === "tool_search_call") {
+		const blockIndex = openFunctionCallBlock(state, {
+			outputIndex,
+			toolCallId: item.call_id,
+			name: state.toolSearchName,
+			events
+		});
+		const finalArguments = stringifyToolSearchArguments(item.arguments);
+		if (!state.blockHasDelta.has(blockIndex) && finalArguments) {
+			events.push({
+				type: "content_block_delta",
+				index: blockIndex,
+				delta: {
+					type: "input_json_delta",
+					partial_json: finalArguments
+				}
+			});
+			state.blockHasDelta.add(blockIndex);
+		}
+		state.functionCallStateByOutputIndex.delete(outputIndex);
+		return events;
+	}
 	if (itemType === "compaction") {
 		if (!item.id || !item.encrypted_content) return events;
 		const blockIndex = openThinkingBlockIfNeeded(state, outputIndex, events);
@@ -6723,16 +6911,30 @@ const openFunctionCallBlock = (state, params) => {
 	}
 	return blockIndex;
 };
-const extractFunctionCallDetails = (rawEvent) => {
+const extractFunctionCallDetails = (rawEvent, state) => {
 	const item = rawEvent.item;
-	if (item.type !== "function_call") return;
+	const itemType = item.type;
+	if (itemType === "tool_search_call") return {
+		outputIndex: rawEvent.output_index,
+		toolCallId: item.call_id,
+		name: state.toolSearchName,
+		initialArguments: ""
+	};
+	if (itemType !== "function_call") return;
 	return {
 		outputIndex: rawEvent.output_index,
 		toolCallId: item.call_id,
-		name: item.name,
+		name: resolveToolUseName(item),
 		initialArguments: item.arguments
 	};
 };
+const stringifyToolSearchArguments = (argumentsValue) => {
+	try {
+		return JSON.stringify(formatToolSearchBridgeArguments(argumentsValue));
+	} catch {
+		return;
+	}
+};
 const responsesUtilsDependencies = {
 	isResponsesApiContextManagementModel,
 	isResponsesApiWebSocketEnabled
@@ -7176,11 +7378,13 @@ async function handleCompletion(c) {
 	const originalRequestModel = anthropicPayload.model;
 	if (anthropicBeta && isWarmupProbeRequest(anthropicPayload)) anthropicPayload.model = getSmallModel();
 	if (compactType !== 0) logger$3.debug("Compact request type:", compactType);
+	const lastMessageCacheControl = getLastMessageContentCacheControl(anthropicPayload.messages.at(-1));
 	if (compactType === 1 && shouldCompactUseSmallModel()) anthropicPayload.model = getSmallModel();
 	if (compactType === 0) {
 		stripToolReferenceTurnBoundary(anthropicPayload);
 		mergeToolResultForClaude(anthropicPayload);
 	}
+	applyLastMessageCacheControl(anthropicPayload, lastMessageCacheControl);
 	const upstreamRequestId = generateRequestIdFromPayload(anthropicPayload, sessionId);
 	logger$3.debug("Generated request ID:", upstreamRequestId);
 	const clientModel = anthropicPayload.model;
@@ -8723,4 +8927,4 @@ server.route("/:provider/v1/models", providerModelRoutes);
 //#endregion
 export { server };
 
-//# sourceMappingURL=server-DxQsi1x2.js.map
+//# sourceMappingURL=server-DmDAepfa.js.map