copilot-relay 0.4.4 → 0.4.5

package/dist/main.js

@@ -831,6 +831,7 @@ const normalizeClaudeModelId = (model, contextWindowTokens) => {
 	return contextWindowTokens !== void 0 && contextWindowTokens !== 1e6 ? normalized : `${normalized}[1m]`;
 };
 const normalizeCopilotModelId = (model) => normalizeOneMillionContextModel(model) ?? model;
+const isClaudeModelId = (model) => model.startsWith("claude-");
 const getConfiguredModelRouting = () => getRuntimeState().modelRouting ?? defaultModelRouting;
 const getModelRouting = () => {
 	const routing = getConfiguredModelRouting();
@@ -2570,12 +2571,12 @@ const copilotEndpoints = [
 	"/responses",
 	"/v1/messages"
 ];
-const legacyResponsesPattern = /^(?:gpt-5\.5|gpt-5\.6|gpt-6-astra)(?:-|$)/i;
+const legacyResponsesPattern = /^(?:gpt-5\.4(?!-mini)|gpt-5\.5|gpt-5\.6|gpt-6-astra)(?:-|$)/i;
 function selectCopilotEndpoint(config, model) {
 	const capabilities = getCachedCopilotModel(config, model);
 	const advertisedEndpoints = capabilities?.supportedEndpoints;
 	if (capabilities?.type !== void 0 && capabilities.type !== "chat") return { reason: "unsupported-model-type" };
-	const isClaude = model.startsWith("claude-");
+	const isClaude = isClaudeModelId(model);
 	const protocolMode = config.claudeUpstreamApi ?? "chat-completions";
 	if (isClaude && protocolMode === "messages") return {
 		endpoint: "/v1/messages",
@@ -2911,7 +2912,7 @@ const createClaudeToolNameMapper = (tools, options = {}) => {
 function translateModelName(model) {
 	return routeModelId(model);
 }
-function translateToOpenAI(payload, _settings, toolNameMapper) {
+function translateToOpenAI(payload, _settings, toolNameMapper, options = {}) {
 	const model = translateModelName(payload.model);
 	const mapper = toolNameMapper ?? createClaudeToolNameMapper(payload.tools, { ...getToolNameMapperOptionsForModel(model) });
 	const tools = translateClaudeToolsToOpenAI(payload.tools, mapper);
@@ -2919,7 +2920,7 @@ function translateToOpenAI(payload, _settings, toolNameMapper) {
 	validateClaudeMessages(payload.messages);
 	return {
 		model,
-		messages: normalizeFinalAssistantPrefill$1(translateClaudeMessagesToOpenAI(payload.messages, payload.system, mapper)),
+		messages: normalizeFinalAssistantPrefill$1(translateClaudeMessagesToOpenAI(payload.messages, payload.system, mapper, options.endpoint === "/chat/completions" && isClaudeModelId(model))),
 		max_tokens: payload.max_tokens,
 		stop: payload.stop_sequences,
 		stream: payload.stream,
@@ -2945,20 +2946,50 @@ function validateClaudeMessages(messages, native = false) {
 		if (typeof message.content !== "string" && (!Array.isArray(message.content) || message.content.some((block) => !block || block.type !== "text" || typeof block.text !== "string"))) throw invalidMessage("System message content must contain only text.");
 	}
 }
-function translateClaudeMessagesToOpenAI(claudeMessages, system, toolNameMapper) {
-	const systemMessages = handleSystemPrompt(system);
-	const otherMessages = claudeMessages.flatMap((message) => {
-		switch (message.role) {
-			case "user": return handleUserMessage(message);
-			case "assistant": return handleAssistantMessage(message, toolNameMapper);
-			case "system":
-				if (message.output_config !== void 0 && (typeof message.content === "string" ? message.content.length === 0 : message.content.every((block) => block.text.length === 0))) return [];
-				return handleSystemPrompt(message.content);
-			default: throw invalidMessage("Unsupported message role.");
-		}
-	});
-	return [...systemMessages, ...otherMessages];
+function translateClaudeMessagesToOpenAI(claudeMessages, system, toolNameMapper, claudeChatRoute) {
+	const translated = handleSystemPrompt(system);
+	if (claudeChatRoute && hasCacheBreakpoint(system)) markCacheBreakpoint(translated.at(-1));
+	for (const message of claudeMessages) {
+		const start$1 = translated.length;
+		translated.push(...translateClaudeMessage(message, toolNameMapper, claudeChatRoute));
+		if (claudeChatRoute) markMessageBreakpoints(message, translated, start$1);
+	}
+	return translated;
+}
+function markMessageBreakpoints(message, translated, start$1) {
+	if (message.role !== "user" || !Array.isArray(message.content)) {
+		if (hasCacheBreakpoint(message.content)) markCacheBreakpoint(translated.at(-1));
+		return;
+	}
+	let toolIndex = start$1;
+	for (const block of message.content) if (block.type === "tool_result") {
+		if (isCacheBreakpoint(block)) markCacheBreakpoint(translated[toolIndex]);
+		toolIndex += 1;
+	} else if (isCacheBreakpoint(block)) markCacheBreakpoint(translated.at(-1));
+}
+function translateClaudeMessage(message, toolNameMapper, claudeChatRoute) {
+	switch (message.role) {
+		case "user": return handleUserMessage(message);
+		case "assistant": return handleAssistantMessage(message, toolNameMapper);
+		case "system":
+			if (message.output_config !== void 0 && (typeof message.content === "string" ? message.content.length === 0 : message.content.every((block) => block.text.length === 0))) return [];
+			return claudeChatRoute ? toSystemReminder(message.content) : handleSystemPrompt(message.content);
+		default: throw invalidMessage("Unsupported message role.");
+	}
 }
+function toSystemReminder(content) {
+	const text$1 = typeof content === "string" ? content : content.map((block) => block.text).join("\n\n");
+	if (text$1.trim().length === 0) return [];
+	return [{
+		role: "user",
+		content: `<system-reminder>\n${text$1}\n</system-reminder>`
+	}];
+}
+const isCacheBreakpoint = (block) => "cache_control" in block && Boolean(block.cache_control);
+const hasCacheBreakpoint = (content) => Array.isArray(content) && content.some(isCacheBreakpoint);
+const markCacheBreakpoint = (message) => {
+	if (message) message.copilot_cache_control = { type: "ephemeral" };
+};
 const invalidMessage = (message) => new HTTPError(message, new Response(JSON.stringify({
 	type: "error",
 	error: {
@@ -4818,14 +4849,14 @@ async function logUpstreamError(message, response, context, signal, timeoutMs) {
 		route: context.route,
 		model: context.model,
 		requestId: context.requestId,
-		request: context.request,
 		response: {
 			status: response.status,
 			statusText: response.statusText || void 0,
 			url: response.url || void 0,
 			headers: Object.fromEntries(response.headers.entries()),
 			body: errorBody || void 0
-		}
+		},
+		request: context.request
 	});
 	return detail;
 }
@@ -5452,6 +5483,10 @@ const createQueuedClaudeStreamWriter = (write) => {
 const writeClaudeStreamEvents = async (events$1, writeEvent) => {
 	for (const event of events$1) await writeEvent(event);
 };
+const translationEndpoint = (config, model) => {
+	const selection = selectCopilotEndpoint(config, normalizeCopilotModelId(model));
+	return selection.endpoint && !selection.responsesFallback ? selection.endpoint : void 0;
+};
 const handleClaudeMessageRequest = async (config, claudePayload, requestSignal, requestId, writeEvent, requestHeaders) => {
 	const upstreamModel = translateModelName(claudePayload.model);
 	if (shouldUseNativeMessages(config, upstreamModel)) return handleNativeMessages(config, {
@@ -5465,7 +5500,7 @@ const handleClaudeMessageRequest = async (config, claudePayload, requestSignal,
 	const shouldLetModelDecideWebSearch = hasClaudeWebSearch(claudePayload);
 	const decisionPayload = shouldLetModelDecideWebSearch ? prepareClaudeWebSearchDecisionPayload(claudePayload) : claudePayload;
 	const toolNameMapper = createClaudeToolNameMapper(decisionPayload.tools, { ...getToolNameMapperOptionsForModel(upstreamModel) });
-	const openAIPayload = translateToOpenAI(decisionPayload, void 0, toolNameMapper);
+	const openAIPayload = translateToOpenAI(decisionPayload, void 0, toolNameMapper, { endpoint: translationEndpoint(config, upstreamModel) });
 	const canStreamWebSearchDecision = shouldLetModelDecideWebSearch && !!writeEvent;
 	if (shouldLetModelDecideWebSearch && !canStreamWebSearchDecision) openAIPayload.stream = false;
 	const response = await createChatCompletions(config, openAIPayload, {
@@ -5717,7 +5752,7 @@ claudeRoutes.post("/messages/count_tokens", async (c) => {
 				const { output_config: _outputConfig, clear_at: _clearAt,...textMessage } = message;
 				return textMessage;
 			})
-		} : claudePayload);
+		} : claudePayload, void 0, void 0, { endpoint: translationEndpoint(c.get("config"), translateModelName(claudePayload.model)) });
 		const exposedModels = getExposedModelIds();
 		const upstreamModel = getCachedCopilotModel(c.get("config"), openAIPayload.model);
 		const hasDiscoveredTokenizer = upstreamModel?.tokenizer !== void 0 && isSupportedTokenizer(upstreamModel.tokenizer);