@jeffreycao/copilot-api 1.2.2 → 1.2.4

package/dist/{server-BHzEoq4-.js → server-BPTBrSfO.js}

@@ -1,4 +1,4 @@
-import { HTTPError, PATHS, cacheModels, copilotBaseUrl, copilotHeaders, forwardError, getConfig, getCopilotUsage, getExtraPromptForModel, getReasoningEffortForModel, getSmallModel, isNullish, shouldCompactUseSmallModel, sleep, state } from "./config-DYI6xs3W.js";
+import { HTTPError, PATHS, cacheModels, copilotBaseUrl, copilotHeaders, forwardError, generateRequestIdFromPayload, getConfig, getCopilotUsage, getExtraPromptForModel, getReasoningEffortForModel, getRootSessionId, getSmallModel, getUUID, isNullish, isResponsesApiContextManagementModel, shouldCompactUseSmallModel, sleep, state } from "./config-BD6sOCuT.js";
 import consola from "consola";
 import path from "node:path";
 import fs, { readFileSync } from "node:fs";
@@ -426,9 +426,14 @@ const createChatCompletions = async (payload, options) => {
 		if (lastMessage) isAgentCall = ["assistant", "tool"].includes(lastMessage.role);
 	}
 	const headers = {
-		...copilotHeaders(state, enableVision),
-		"X-Initiator": options?.initiator ?? (isAgentCall ? "agent" : "user")
+		...copilotHeaders(state, options.requestId, enableVision),
+		"x-initiator": isAgentCall ? "agent" : "user"
 	};
+	if (options.subagentMarker) {
+		headers["x-initiator"] = "agent";
+		headers["x-interaction-type"] = "conversation-subagent";
+	}
+	if (options.sessionId) headers["x-interaction-id"] = options.sessionId;
 	const response = await fetch(`${copilotBaseUrl(state)}/chat/completions`, {
 		method: "POST",
 		headers,
@@ -466,7 +471,14 @@ async function handleCompletion$1(c) {
 		};
 		logger$3.debug("Set max_tokens to:", JSON.stringify(payload.max_tokens));
 	}
-	const response = await createChatCompletions(payload);
+	const requestId = generateRequestIdFromPayload(payload);
+	logger$3.debug("Generated request ID:", requestId);
+	const sessionId = getUUID(requestId);
+	logger$3.debug("Extracted session ID:", sessionId);
+	const response = await createChatCompletions(payload, {
+		requestId,
+		sessionId
+	});
 	if (isNonStreaming$1(response)) {
 		logger$3.debug("Non-streaming response:", JSON.stringify(response));
 		return c.json(response);
@@ -805,12 +817,17 @@ async function handleCountTokens(c) {
 
 //#endregion
 //#region src/services/copilot/create-responses.ts
-const createResponses = async (payload, { vision, initiator }) => {
+const createResponses = async (payload, { vision, initiator, subagentMarker, requestId, sessionId }) => {
 	if (!state.copilotToken) throw new Error("Copilot token not found");
 	const headers = {
-		...copilotHeaders(state, vision),
-		"X-Initiator": initiator
+		...copilotHeaders(state, requestId, vision),
+		"x-initiator": initiator
 	};
+	if (subagentMarker) {
+		headers["x-initiator"] = "agent";
+		headers["x-interaction-type"] = "conversation-subagent";
+	}
+	if (sessionId) headers["x-interaction-id"] = sessionId;
 	payload.service_tier = null;
 	const response = await fetch(`${copilotBaseUrl(state)}/responses`, {
 		method: "POST",
@@ -828,6 +845,8 @@ const createResponses = async (payload, { vision, initiator }) => {
 //#endregion
 //#region src/routes/messages/responses-translation.ts
 const MESSAGE_TYPE = "message";
+const COMPACTION_SIGNATURE_PREFIX = "cm1#";
+const COMPACTION_SIGNATURE_SEPARATOR = "@";
 const THINKING_TEXT$1 = "Thinking...";
 const translateAnthropicMessagesToResponsesPayload = (payload) => {
 	const input = [];
@@ -858,6 +877,23 @@ const translateAnthropicMessagesToResponsesPayload = (payload) => {
 		include: ["reasoning.encrypted_content"]
 	};
 };
+const encodeCompactionCarrierSignature = (compaction) => {
+	return `${COMPACTION_SIGNATURE_PREFIX}${compaction.encrypted_content}${COMPACTION_SIGNATURE_SEPARATOR}${compaction.id}`;
+};
+const decodeCompactionCarrierSignature = (signature) => {
+	if (signature.startsWith(COMPACTION_SIGNATURE_PREFIX)) {
+		const raw = signature.slice(4);
+		const separatorIndex = raw.indexOf(COMPACTION_SIGNATURE_SEPARATOR);
+		if (separatorIndex <= 0 || separatorIndex === raw.length - 1) return;
+		const encrypted_content = raw.slice(0, separatorIndex);
+		const id = raw.slice(separatorIndex + 1);
+		if (!encrypted_content) return;
+		return {
+			id,
+			encrypted_content
+		};
+	}
+};
 const translateMessage = (message, model, applyPhase) => {
 	if (message.role === "user") return translateUserMessage(message);
 	return translateAssistantMessage(message, model, applyPhase);
@@ -894,13 +930,24 @@ const translateAssistantMessage = (message, model, applyPhase) => {
 			items.push(createFunctionToolCall(block));
 			continue;
 		}
-		if (block.type === "thinking" && block.signature && block.signature.includes("@")) {
-			flushPendingContent(pendingContent, items, {
-				role: "assistant",
-				phase: assistantPhase
-			});
-			items.push(createReasoningContent(block));
-			continue;
+		if (block.type === "thinking" && block.signature) {
+			const compactionContent = createCompactionContent(block);
+			if (compactionContent) {
+				flushPendingContent(pendingContent, items, {
+					role: "assistant",
+					phase: assistantPhase
+				});
+				items.push(compactionContent);
+				continue;
+			}
+			if (block.signature.includes("@")) {
+				flushPendingContent(pendingContent, items, {
+					role: "assistant",
+					phase: assistantPhase
+				});
+				items.push(createReasoningContent(block));
+				continue;
+			}
 		}
 		const converted = translateAssistantContentBlock(block);
 		if (converted) pendingContent.push(converted);
@@ -960,9 +1007,7 @@ const createImageContent = (block) => ({
 	detail: "auto"
 });
 const createReasoningContent = (block) => {
-	const array = block.signature.split("@");
-	const signature = array[0];
-	const id = array[1];
+	const { encryptedContent, id } = parseReasoningSignature(block.signature);
 	const thinking = block.thinking === THINKING_TEXT$1 ? "" : block.thinking;
 	return {
 		id,
@@ -971,7 +1016,27 @@ const createReasoningContent = (block) => {
 			type: "summary_text",
 			text: thinking
 		}] : [],
-		encrypted_content: signature
+		encrypted_content: encryptedContent
+	};
+};
+const createCompactionContent = (block) => {
+	const compaction = decodeCompactionCarrierSignature(block.signature);
+	if (!compaction) return;
+	return {
+		id: compaction.id,
+		type: "compaction",
+		encrypted_content: compaction.encrypted_content
+	};
+};
+const parseReasoningSignature = (signature) => {
+	const splitIndex = signature.lastIndexOf("@");
+	if (splitIndex <= 0 || splitIndex === signature.length - 1) return {
+		encryptedContent: signature,
+		id: ""
+	};
+	return {
+		encryptedContent: signature.slice(0, splitIndex),
+		id: signature.slice(splitIndex + 1)
 	};
 };
 const createFunctionToolCall = (block) => ({
@@ -1062,6 +1127,11 @@ const mapOutputToAnthropicContent = (output) => {
 			});
 			break;
 		}
+		case "compaction": {
+			const compactionBlock = createCompactionThinkingBlock(item);
+			if (compactionBlock) contentBlocks.push(compactionBlock);
+			break;
+		}
 		default: {
 			const combinedText = combineMessageTextContent(item.content);
 			if (combinedText.length > 0) contentBlocks.push({
@@ -1119,6 +1189,17 @@ const createToolUseContentBlock = (call) => {
 		input
 	};
 };
+const createCompactionThinkingBlock = (item) => {
+	if (!item.id || !item.encrypted_content) return null;
+	return {
+		type: "thinking",
+		thinking: THINKING_TEXT$1,
+		signature: encodeCompactionCarrierSignature({
+			id: item.id,
+			encrypted_content: item.encrypted_content
+		})
+	};
+};
 const parseFunctionCallArguments = (rawArguments) => {
 	if (typeof rawArguments !== "string" || rawArguments.trim().length === 0) return {};
 	try {
@@ -1281,8 +1362,34 @@ const handleOutputItemAdded$1 = (rawEvent, state$1) => {
 const handleOutputItemDone$1 = (rawEvent, state$1) => {
 	const events$1 = new Array();
 	const item = rawEvent.item;
-	if (item.type !== "reasoning") return events$1;
+	const itemType = item.type;
 	const outputIndex = rawEvent.output_index;
+	if (itemType === "compaction") {
+		if (!item.id || !item.encrypted_content) return events$1;
+		const blockIndex$1 = openThinkingBlockIfNeeded(state$1, outputIndex, events$1);
+		if (!state$1.blockHasDelta.has(blockIndex$1)) events$1.push({
+			type: "content_block_delta",
+			index: blockIndex$1,
+			delta: {
+				type: "thinking_delta",
+				thinking: THINKING_TEXT$1
+			}
+		});
+		events$1.push({
+			type: "content_block_delta",
+			index: blockIndex$1,
+			delta: {
+				type: "signature_delta",
+				signature: encodeCompactionCarrierSignature({
+					id: item.id,
+					encrypted_content: item.encrypted_content
+				})
+			}
+		});
+		state$1.blockHasDelta.add(blockIndex$1);
+		return events$1;
+	}
+	if (itemType !== "reasoning") return events$1;
 	const blockIndex = openThinkingBlockIfNeeded(state$1, outputIndex, events$1);
 	const signature = (item.encrypted_content ?? "") + "@" + item.id;
 	if (signature) {
@@ -1620,6 +1727,31 @@ const hasAgentInitiator = (payload) => {
 const hasVisionInput = (payload) => {
 	return getPayloadItems(payload).some((item) => containsVisionContent(item));
 };
+const resolveResponsesCompactThreshold = (maxPromptTokens) => {
+	if (typeof maxPromptTokens === "number" && maxPromptTokens > 0) return Math.floor(maxPromptTokens * .9);
+	return 5e4;
+};
+const createCompactionContextManagement = (compactThreshold) => [{
+	type: "compaction",
+	compact_threshold: compactThreshold
+}];
+const applyResponsesApiContextManagement = (payload, maxPromptTokens) => {
+	if (payload.context_management !== void 0) return;
+	if (!isResponsesApiContextManagementModel(payload.model)) return;
+	payload.context_management = createCompactionContextManagement(resolveResponsesCompactThreshold(maxPromptTokens));
+};
+const compactInputByLatestCompaction = (payload) => {
+	if (!Array.isArray(payload.input) || payload.input.length === 0) return;
+	const latestCompactionMessageIndex = getLatestCompactionMessageIndex(payload.input);
+	if (latestCompactionMessageIndex === void 0) return;
+	payload.input = payload.input.slice(latestCompactionMessageIndex);
+};
+const getLatestCompactionMessageIndex = (input) => {
+	for (let index = input.length - 1; index >= 0; index -= 1) if (isCompactionInputItem(input[index])) return index;
+};
+const isCompactionInputItem = (value) => {
+	return "type" in value && typeof value.type === "string" && value.type === "compaction";
+};
 const getPayloadItems = (payload) => {
 	const result = [];
 	const { input } = payload;
@@ -1661,11 +1793,15 @@ const createMessages = async (payload, anthropicBetaHeader, options) => {
 	let isInitiateRequest = false;
 	const lastMessage = payload.messages.at(-1);
 	if (lastMessage?.role === "user") isInitiateRequest = Array.isArray(lastMessage.content) ? lastMessage.content.some((block) => block.type !== "tool_result") : true;
-	const initiator = options?.initiator ?? (isInitiateRequest ? "user" : "agent");
 	const headers = {
-		...copilotHeaders(state, enableVision),
-		"X-Initiator": initiator
+		...copilotHeaders(state, options.requestId, enableVision),
+		"x-initiator": isInitiateRequest ? "user" : "agent"
 	};
+	if (options.subagentMarker) {
+		headers["x-initiator"] = "agent";
+		headers["x-interaction-type"] = "conversation-subagent";
+	}
+	if (options.sessionId) headers["x-interaction-id"] = options.sessionId;
 	const anthropicBeta = buildAnthropicBetaHeader(anthropicBetaHeader, payload.thinking);
 	if (anthropicBeta) headers["anthropic-beta"] = anthropicBeta;
 	const response = await fetch(`${copilotBaseUrl(state)}/v1/messages`, {
@@ -1985,8 +2121,9 @@ async function handleCompletion(c) {
 	const anthropicPayload = await c.req.json();
 	logger$2.debug("Anthropic request payload:", JSON.stringify(anthropicPayload));
 	const subagentMarker = parseSubagentMarkerFromFirstUser(anthropicPayload);
-	const initiatorOverride = subagentMarker ? "agent" : void 0;
 	if (subagentMarker) logger$2.debug("Detected Subagent marker:", JSON.stringify(subagentMarker));
+	const sessionId = getRootSessionId(anthropicPayload, c);
+	logger$2.debug("Extracted session ID:", sessionId);
 	const isCompact = isCompactRequest(anthropicPayload);
 	const anthropicBeta = c.req.header("anthropic-beta");
 	logger$2.debug("Anthropic Beta header:", anthropicBeta);
@@ -1996,22 +2133,40 @@ async function handleCompletion(c) {
 		logger$2.debug("Is compact request:", isCompact);
 		if (shouldCompactUseSmallModel()) anthropicPayload.model = getSmallModel();
 	} else mergeToolResultForClaude(anthropicPayload);
+	const requestId = generateRequestIdFromPayload(anthropicPayload, sessionId);
+	logger$2.debug("Generated request ID:", requestId);
 	if (state.manualApprove) await awaitApproval();
 	const selectedModel = state.models?.data.find((m) => m.id === anthropicPayload.model);
 	if (shouldUseMessagesApi(selectedModel)) return await handleWithMessagesApi(c, anthropicPayload, {
 		anthropicBetaHeader: anthropicBeta,
-		initiatorOverride,
-		selectedModel
+		subagentMarker,
+		selectedModel,
+		requestId,
+		sessionId
+	});
+	if (shouldUseResponsesApi(selectedModel)) return await handleWithResponsesApi(c, anthropicPayload, {
+		subagentMarker,
+		selectedModel,
+		requestId,
+		sessionId
+	});
+	return await handleWithChatCompletions(c, anthropicPayload, {
+		subagentMarker,
+		requestId,
+		sessionId
 	});
-	if (shouldUseResponsesApi(selectedModel)) return await handleWithResponsesApi(c, anthropicPayload, initiatorOverride);
-	return await handleWithChatCompletions(c, anthropicPayload, initiatorOverride);
 }
 const RESPONSES_ENDPOINT$1 = "/responses";
 const MESSAGES_ENDPOINT = "/v1/messages";
-const handleWithChatCompletions = async (c, anthropicPayload, initiatorOverride) => {
+const handleWithChatCompletions = async (c, anthropicPayload, options) => {
+	const { subagentMarker, requestId, sessionId } = options;
 	const openAIPayload = translateToOpenAI(anthropicPayload);
 	logger$2.debug("Translated OpenAI request payload:", JSON.stringify(openAIPayload));
-	const response = await createChatCompletions(openAIPayload, { initiator: initiatorOverride });
+	const response = await createChatCompletions(openAIPayload, {
+		subagentMarker,
+		requestId,
+		sessionId
+	});
 	if (isNonStreaming(response)) {
 		logger$2.debug("Non-streaming response from Copilot:", JSON.stringify(response));
 		const anthropicResponse = translateToAnthropic(response);
@@ -2043,13 +2198,19 @@ const handleWithChatCompletions = async (c, anthropicPayload, initiatorOverride)
 		}
 	});
 };
-const handleWithResponsesApi = async (c, anthropicPayload, initiatorOverride) => {
+const handleWithResponsesApi = async (c, anthropicPayload, options) => {
+	const { subagentMarker, selectedModel, requestId, sessionId } = options;
 	const responsesPayload = translateAnthropicMessagesToResponsesPayload(anthropicPayload);
+	applyResponsesApiContextManagement(responsesPayload, selectedModel?.capabilities.limits.max_prompt_tokens);
+	compactInputByLatestCompaction(responsesPayload);
 	logger$2.debug("Translated Responses payload:", JSON.stringify(responsesPayload));
 	const { vision, initiator } = getResponsesRequestOptions(responsesPayload);
 	const response = await createResponses(responsesPayload, {
 		vision,
-		initiator: initiatorOverride ?? initiator
+		initiator,
+		subagentMarker,
+		requestId,
+		sessionId
 	});
 	if (responsesPayload.stream && isAsyncIterable$1(response)) {
 		logger$2.debug("Streaming response from Copilot (Responses API)");
@@ -2096,17 +2257,23 @@ const handleWithResponsesApi = async (c, anthropicPayload, initiatorOverride) =>
 	return c.json(anthropicResponse);
 };
 const handleWithMessagesApi = async (c, anthropicPayload, options) => {
-	const { anthropicBetaHeader, initiatorOverride, selectedModel } = options ?? {};
+	const { anthropicBetaHeader, subagentMarker, selectedModel, requestId, sessionId } = options;
 	for (const msg of anthropicPayload.messages) if (msg.role === "assistant" && Array.isArray(msg.content)) msg.content = msg.content.filter((block) => {
 		if (block.type !== "thinking") return true;
 		return block.thinking && block.thinking !== "Thinking..." && block.signature && !block.signature.includes("@");
 	});
-	if (selectedModel?.capabilities.supports.adaptive_thinking) {
+	const toolChoice = anthropicPayload.tool_choice;
+	const disableThink = toolChoice?.type === "any" || toolChoice?.type === "tool";
+	if (selectedModel?.capabilities.supports.adaptive_thinking && !disableThink) {
 		anthropicPayload.thinking = { type: "adaptive" };
 		anthropicPayload.output_config = { effort: getAnthropicEffortForModel(anthropicPayload.model) };
 	}
 	logger$2.debug("Translated Messages payload:", JSON.stringify(anthropicPayload));
-	const response = await createMessages(anthropicPayload, anthropicBetaHeader, { initiator: initiatorOverride });
+	const response = await createMessages(anthropicPayload, anthropicBetaHeader, {
+		subagentMarker,
+		requestId,
+		sessionId
+	});
 	if (isAsyncIterable$1(response)) {
 		logger$2.debug("Streaming response from Copilot (Messages API)");
 		return streamSSE(c, async (stream) => {
@@ -2277,17 +2444,27 @@ const handleResponses = async (c) => {
 	await checkRateLimit(state);
 	const payload = await c.req.json();
 	logger$1.debug("Responses request payload:", JSON.stringify(payload));
+	const requestId = generateRequestIdFromPayload({ messages: payload.input });
+	logger$1.debug("Generated request ID:", requestId);
+	const sessionId = getUUID(requestId);
+	logger$1.debug("Extracted session ID:", sessionId);
 	useFunctionApplyPatch(payload);
 	removeWebSearchTool(payload);
-	if (!((state.models?.data.find((model) => model.id === payload.model))?.supported_endpoints?.includes(RESPONSES_ENDPOINT) ?? false)) return c.json({ error: {
+	compactInputByLatestCompaction(payload);
+	const selectedModel = state.models?.data.find((model) => model.id === payload.model);
+	if (!(selectedModel?.supported_endpoints?.includes(RESPONSES_ENDPOINT) ?? false)) return c.json({ error: {
 		message: "This model does not support the responses endpoint. Please choose a different model.",
 		type: "invalid_request_error"
 	} }, 400);
+	applyResponsesApiContextManagement(payload, selectedModel?.capabilities.limits.max_prompt_tokens);
+	logger$1.debug("Translated Responses payload:", JSON.stringify(payload));
 	const { vision, initiator } = getResponsesRequestOptions(payload);
 	if (state.manualApprove) await awaitApproval();
 	const response = await createResponses(payload, {
 		vision,
-		initiator
+		initiator,
+		requestId,
+		sessionId
 	});
 	if (isStreamingRequested(payload) && isAsyncIterable(response)) {
 		logger$1.debug("Forwarding native Responses stream");
@@ -2410,4 +2587,4 @@ server.route("/v1/messages", messageRoutes);
 
 //#endregion
 export { server };
-//# sourceMappingURL=server-BHzEoq4-.js.map
+//# sourceMappingURL=server-BPTBrSfO.js.map