@jeffreycao/copilot-api 1.5.3-beta.0 → 1.5.3-beta.2

package/dist/{server-DAyVU7jA.js → server-DP3qGqqy.js}

@@ -86,6 +86,9 @@ const FLUSH_INTERVAL_MS = 1e3;
 const MAX_BUFFER_SIZE = 100;
 const logStreams = /* @__PURE__ */ new Map();
 const logBuffers = /* @__PURE__ */ new Map();
+let runtimeInitialized = false;
+let flushInterval;
+let cleanupInterval;
 const ensureLogDirectory = () => {
 	if (!fs.existsSync(LOG_DIR)) fs.mkdirSync(LOG_DIR, { recursive: true });
 };
@@ -116,17 +119,8 @@ const sanitizeName = (name) => {
 	const normalized = name.toLowerCase().replaceAll(/[^a-z0-9]+/g, "-").replaceAll(/^-+|-+$/g, "");
 	return normalized === "" ? "handler" : normalized;
 };
-const getLogStream = (filePath) => {
-	let stream = logStreams.get(filePath);
-	if (!stream || stream.destroyed) {
-		stream = fs.createWriteStream(filePath, { flags: "a" });
-		logStreams.set(filePath, stream);
-		stream.on("error", (error) => {
-			console.warn("Log stream error", error);
-			logStreams.delete(filePath);
-		});
-	}
-	return stream;
+const maybeUnref = (timer) => {
+	timer.unref();
 };
 const flushBuffer = (filePath) => {
 	const buffer = logBuffers.get(filePath);
@@ -141,6 +135,52 @@ const flushBuffer = (filePath) => {
 const flushAllBuffers = () => {
 	for (const filePath of logBuffers.keys()) flushBuffer(filePath);
 };
+const cleanup = () => {
+	if (flushInterval) {
+		clearInterval(flushInterval);
+		flushInterval = void 0;
+	}
+	if (cleanupInterval) {
+		clearInterval(cleanupInterval);
+		cleanupInterval = void 0;
+	}
+	flushAllBuffers();
+	for (const stream of logStreams.values()) stream.end();
+	logStreams.clear();
+	logBuffers.clear();
+};
+const initializeLoggerRuntime = () => {
+	if (runtimeInitialized) return;
+	runtimeInitialized = true;
+	ensureLogDirectory();
+	cleanupOldLogs();
+	flushInterval = setInterval(flushAllBuffers, FLUSH_INTERVAL_MS);
+	maybeUnref(flushInterval);
+	cleanupInterval = setInterval(cleanupOldLogs, CLEANUP_INTERVAL_MS);
+	maybeUnref(cleanupInterval);
+	process.once("exit", cleanup);
+	process.once("SIGINT", () => {
+		cleanup();
+		process.exit(0);
+	});
+	process.once("SIGTERM", () => {
+		cleanup();
+		process.exit(0);
+	});
+};
+const getLogStream = (filePath) => {
+	initializeLoggerRuntime();
+	let stream = logStreams.get(filePath);
+	if (!stream || stream.destroyed) {
+		stream = fs.createWriteStream(filePath, { flags: "a" });
+		logStreams.set(filePath, stream);
+		stream.on("error", (error) => {
+			console.warn("Log stream error", error);
+			logStreams.delete(filePath);
+		});
+	}
+	return stream;
+};
 const appendLine = (filePath, line) => {
 	let buffer = logBuffers.get(filePath);
 	if (!buffer) {
@@ -150,35 +190,23 @@ const appendLine = (filePath, line) => {
 	buffer.push(line);
 	if (buffer.length >= MAX_BUFFER_SIZE) flushBuffer(filePath);
 };
-setInterval(flushAllBuffers, FLUSH_INTERVAL_MS);
-const cleanup = () => {
-	flushAllBuffers();
-	for (const stream of logStreams.values()) stream.end();
-	logStreams.clear();
-	logBuffers.clear();
+const debugLazy = (logger$7, factory) => {
+	if (!state.verbose) return;
+	logger$7.debug(...factory());
+};
+const debugJson = (logger$7, label, value) => {
+	debugLazy(logger$7, () => [label, JSON.stringify(value)]);
+};
+const debugJsonTail = (logger$7, label, { value, tailLength = 400 }) => {
+	debugLazy(logger$7, () => [label, JSON.stringify(value).slice(-tailLength)]);
 };
-process.on("exit", cleanup);
-process.on("SIGINT", () => {
-	cleanup();
-	process.exit(0);
-});
-process.on("SIGTERM", () => {
-	cleanup();
-	process.exit(0);
-});
-let lastCleanup = 0;
 const createHandlerLogger = (name) => {
-	ensureLogDirectory();
 	const sanitizedName = sanitizeName(name);
 	const instance = consola.withTag(name);
 	if (state.verbose) instance.level = 5;
 	instance.setReporters([]);
 	instance.addReporter({ log(logObj) {
-		ensureLogDirectory();
-		if (Date.now() - lastCleanup > CLEANUP_INTERVAL_MS) {
-			cleanupOldLogs();
-			lastCleanup = Date.now();
-		}
+		initializeLoggerRuntime();
 		const traceId = requestContext.getStore()?.traceId;
 		const date = logObj.date;
 		const dateKey = date.toLocaleDateString("sv-SE");
@@ -469,7 +497,10 @@ const logger$6 = createHandlerLogger("chat-completions-handler");
 async function handleCompletion$1(c) {
 	await checkRateLimit(state);
 	let payload = await c.req.json();
-	logger$6.debug("Request payload:", JSON.stringify(payload).slice(-400));
+	debugJsonTail(logger$6, "Request payload:", {
+		value: payload,
+		tailLength: 400
+	});
 	const selectedModel = state.models?.data.find((model) => model.id === payload.model);
 	try {
 		if (selectedModel) {
@@ -485,7 +516,7 @@ async function handleCompletion$1(c) {
 			...payload,
 			max_tokens: selectedModel?.capabilities.limits.max_output_tokens
 		};
-		logger$6.debug("Set max_tokens to:", JSON.stringify(payload.max_tokens));
+		debugJson(logger$6, "Set max_tokens to:", payload.max_tokens);
 	}
 	const requestId = generateRequestIdFromPayload(payload);
 	logger$6.debug("Generated request ID:", requestId);
@@ -496,13 +527,13 @@ async function handleCompletion$1(c) {
 		sessionId
 	});
 	if (isNonStreaming$1(response)) {
-		logger$6.debug("Non-streaming response:", JSON.stringify(response));
+		debugJson(logger$6, "Non-streaming response:", response);
 		return c.json(response);
 	}
 	logger$6.debug("Streaming response");
 	return streamSSE(c, async (stream) => {
 		for await (const chunk of response) {
-			logger$6.debug("Streaming chunk:", JSON.stringify(chunk));
+			debugJson(logger$6, "Streaming chunk:", chunk);
 			await stream.writeSSE(chunk);
 		}
 	});
@@ -1884,6 +1915,107 @@ const createMessages = async (payload, anthropicBetaHeader, options) => {
 	return await response.json();
 };
 
+//#endregion
+//#region src/routes/messages/preprocess.ts
+const compactSystemPromptStart = "You are a helpful AI assistant tasked with summarizing conversations";
+const compactTextOnlyGuard = "CRITICAL: Respond with TEXT ONLY. Do NOT call any tools.";
+const compactSummaryPromptStart = "Your task is to create a detailed summary of the conversation so far";
+const compactMessageSections = ["Pending Tasks:", "Current Work:"];
+const getAnthropicEffortForModel = (model) => {
+	const reasoningEffort = getReasoningEffortForModel(model);
+	if (reasoningEffort === "xhigh") return "max";
+	if (reasoningEffort === "none" || reasoningEffort === "minimal") return "low";
+	return reasoningEffort;
+};
+const getCompactCandidateText = (message) => {
+	if (message.role !== "user") return "";
+	if (typeof message.content === "string") return message.content;
+	return message.content.filter((block) => block.type === "text").map((block) => block.text.startsWith("<system-reminder>") ? "" : block.text).filter((text) => text.length > 0).join("\n\n");
+};
+const isCompactMessage = (lastMessage) => {
+	const text = getCompactCandidateText(lastMessage);
+	if (!text) return false;
+	return text.includes(compactTextOnlyGuard) && text.includes(compactSummaryPromptStart) && compactMessageSections.some((section) => text.includes(section));
+};
+const isCompactRequest = (anthropicPayload) => {
+	const lastMessage = anthropicPayload.messages.at(-1);
+	if (lastMessage && isCompactMessage(lastMessage)) return true;
+	const system = anthropicPayload.system;
+	if (typeof system === "string") return system.startsWith(compactSystemPromptStart);
+	if (!Array.isArray(system)) return false;
+	return system.some((msg) => typeof msg.text === "string" && msg.text.startsWith(compactSystemPromptStart));
+};
+const mergeContentWithText = (tr, textBlock) => {
+	if (typeof tr.content === "string") return {
+		...tr,
+		content: `${tr.content}\n\n${textBlock.text}`
+	};
+	return {
+		...tr,
+		content: [...tr.content, textBlock]
+	};
+};
+const mergeContentWithTexts = (tr, textBlocks) => {
+	if (typeof tr.content === "string") {
+		const appendedTexts = textBlocks.map((tb) => tb.text).join("\n\n");
+		return {
+			...tr,
+			content: `${tr.content}\n\n${appendedTexts}`
+		};
+	}
+	return {
+		...tr,
+		content: [...tr.content, ...textBlocks]
+	};
+};
+const mergeToolResult = (toolResults, textBlocks) => {
+	if (toolResults.length === textBlocks.length) return toolResults.map((tr, i) => mergeContentWithText(tr, textBlocks[i]));
+	const lastIndex = toolResults.length - 1;
+	return toolResults.map((tr, i) => i === lastIndex ? mergeContentWithTexts(tr, textBlocks) : tr);
+};
+const mergeToolResultForClaude = (anthropicPayload) => {
+	for (const msg of anthropicPayload.messages) {
+		if (msg.role !== "user" || !Array.isArray(msg.content)) continue;
+		const toolResults = [];
+		const textBlocks = [];
+		let valid = true;
+		for (const block of msg.content) if (block.type === "tool_result") toolResults.push(block);
+		else if (block.type === "text") textBlocks.push(block);
+		else {
+			valid = false;
+			break;
+		}
+		if (!valid || toolResults.length === 0 || textBlocks.length === 0) continue;
+		msg.content = mergeToolResult(toolResults, textBlocks);
+	}
+};
+const stripCacheControl = (payload) => {
+	if (Array.isArray(payload.system)) for (const block of payload.system) {
+		const systemBlock = block;
+		const cacheControl = systemBlock.cache_control;
+		if (cacheControl && typeof cacheControl === "object") {
+			const { scope,...rest } = cacheControl;
+			systemBlock.cache_control = rest;
+		}
+	}
+};
+const filterAssistantThinkingBlocks = (payload) => {
+	for (const msg of payload.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("@");
+	});
+};
+const prepareMessagesApiPayload = (payload, selectedModel) => {
+	stripCacheControl(payload);
+	filterAssistantThinkingBlocks(payload);
+	const toolChoice = payload.tool_choice;
+	const disableThink = toolChoice?.type === "any" || toolChoice?.type === "tool";
+	if (selectedModel?.capabilities.supports.adaptive_thinking && !disableThink) {
+		payload.thinking = { type: "adaptive" };
+		payload.output_config = { effort: getAnthropicEffortForModel(payload.model) };
+	}
+};
+
 //#endregion
 //#region src/routes/messages/stream-translation.ts
 function isToolBlockOpen(state$1) {
@@ -2135,105 +2267,11 @@ function closeThinkingBlockIfOpen(state$1, events$1) {
 }
 
 //#endregion
-//#region src/routes/messages/subagent-marker.ts
-const subagentMarkerPrefix = "__SUBAGENT_MARKER__";
-const parseSubagentMarkerFromFirstUser = (payload) => {
-	const firstUserMessage = payload.messages.find((msg) => msg.role === "user");
-	if (!firstUserMessage || !Array.isArray(firstUserMessage.content)) return null;
-	for (const block of firstUserMessage.content) {
-		if (block.type !== "text") continue;
-		const marker = parseSubagentMarkerFromSystemReminder(block.text);
-		if (marker) return marker;
-	}
-	return null;
-};
-const parseSubagentMarkerFromSystemReminder = (text) => {
-	const startTag = "<system-reminder>";
-	const endTag = "</system-reminder>";
-	let searchFrom = 0;
-	while (true) {
-		const reminderStart = text.indexOf(startTag, searchFrom);
-		if (reminderStart === -1) break;
-		const contentStart = reminderStart + 17;
-		const reminderEnd = text.indexOf(endTag, contentStart);
-		if (reminderEnd === -1) break;
-		const reminderContent = text.slice(contentStart, reminderEnd);
-		const markerIndex = reminderContent.indexOf(subagentMarkerPrefix);
-		if (markerIndex === -1) {
-			searchFrom = reminderEnd + 18;
-			continue;
-		}
-		const markerJson = reminderContent.slice(markerIndex + 19).trim();
-		try {
-			const parsed = JSON.parse(markerJson);
-			if (!parsed.session_id || !parsed.agent_id || !parsed.agent_type) {
-				searchFrom = reminderEnd + 18;
-				continue;
-			}
-			return parsed;
-		} catch {
-			searchFrom = reminderEnd + 18;
-			continue;
-		}
-	}
-	return null;
-};
-
-//#endregion
-//#region src/routes/messages/handler.ts
-const logger$5 = createHandlerLogger("messages-handler");
-const compactSystemPromptStart = "You are a helpful AI assistant tasked with summarizing conversations";
-const compactTextOnlyGuard = "CRITICAL: Respond with TEXT ONLY. Do NOT call any tools.";
-const compactSummaryPromptStart = "Your task is to create a detailed summary of the conversation so far";
-const compactMessageSections = ["Pending Tasks:", "Current Work:"];
-async function handleCompletion(c) {
-	await checkRateLimit(state);
-	const anthropicPayload = await c.req.json();
-	logger$5.debug("Anthropic request payload:", JSON.stringify(anthropicPayload));
-	const subagentMarker = parseSubagentMarkerFromFirstUser(anthropicPayload);
-	if (subagentMarker) logger$5.debug("Detected Subagent marker:", JSON.stringify(subagentMarker));
-	const sessionId = getRootSessionId(anthropicPayload, c);
-	logger$5.debug("Extracted session ID:", sessionId);
-	const isCompact = isCompactRequest(anthropicPayload);
-	const anthropicBeta = c.req.header("anthropic-beta");
-	logger$5.debug("Anthropic Beta header:", anthropicBeta);
-	const noTools = !anthropicPayload.tools || anthropicPayload.tools.length === 0;
-	if (anthropicBeta && noTools && !isCompact) anthropicPayload.model = getSmallModel();
-	if (isCompact) logger$5.debug("Is compact request:", isCompact);
-	else mergeToolResultForClaude(anthropicPayload);
-	const requestId = generateRequestIdFromPayload(anthropicPayload, sessionId);
-	logger$5.debug("Generated request ID:", requestId);
-	if (state.manualApprove) await awaitApproval();
-	const selectedModel = findEndpointModel(anthropicPayload.model);
-	anthropicPayload.model = selectedModel?.id ?? anthropicPayload.model;
-	if (shouldUseMessagesApi(selectedModel)) return await handleWithMessagesApi(c, anthropicPayload, {
-		anthropicBetaHeader: anthropicBeta,
-		subagentMarker,
-		selectedModel,
-		requestId,
-		sessionId,
-		isCompact
-	});
-	if (shouldUseResponsesApi(selectedModel)) return await handleWithResponsesApi(c, anthropicPayload, {
-		subagentMarker,
-		selectedModel,
-		requestId,
-		sessionId,
-		isCompact
-	});
-	return await handleWithChatCompletions(c, anthropicPayload, {
-		subagentMarker,
-		requestId,
-		sessionId,
-		isCompact
-	});
-}
-const RESPONSES_ENDPOINT$1 = "/responses";
-const MESSAGES_ENDPOINT = "/v1/messages";
+//#region src/routes/messages/api-flows.ts
 const handleWithChatCompletions = async (c, anthropicPayload, options) => {
-	const { subagentMarker, requestId, sessionId, isCompact } = options;
+	const { logger: logger$7, subagentMarker, requestId, sessionId, isCompact } = options;
 	const openAIPayload = translateToOpenAI(anthropicPayload);
-	logger$5.debug("Translated OpenAI request payload:", JSON.stringify(openAIPayload));
+	debugJson(logger$7, "Translated OpenAI request payload:", openAIPayload);
 	const response = await createChatCompletions(openAIPayload, {
 		subagentMarker,
 		requestId,
@@ -2241,12 +2279,12 @@ const handleWithChatCompletions = async (c, anthropicPayload, options) => {
 		isCompact
 	});
 	if (isNonStreaming(response)) {
-		logger$5.debug("Non-streaming response from Copilot:", JSON.stringify(response));
+		debugJson(logger$7, "Non-streaming response from Copilot:", response);
 		const anthropicResponse = translateToAnthropic(response);
-		logger$5.debug("Translated Anthropic response:", JSON.stringify(anthropicResponse));
+		debugJson(logger$7, "Translated Anthropic response:", anthropicResponse);
 		return c.json(anthropicResponse);
 	}
-	logger$5.debug("Streaming response from Copilot");
+	logger$7.debug("Streaming response from Copilot");
 	return streamSSE(c, async (stream) => {
 		const streamState = {
 			messageStartSent: false,
@@ -2256,27 +2294,28 @@ const handleWithChatCompletions = async (c, anthropicPayload, options) => {
 			thinkingBlockOpen: false
 		};
 		for await (const rawEvent of response) {
-			logger$5.debug("Copilot raw stream event:", JSON.stringify(rawEvent));
+			debugJson(logger$7, "Copilot raw stream event:", rawEvent);
 			if (rawEvent.data === "[DONE]") break;
 			if (!rawEvent.data) continue;
 			const chunk = JSON.parse(rawEvent.data);
 			const events$1 = translateChunkToAnthropicEvents(chunk, streamState);
 			for (const event of events$1) {
-				logger$5.debug("Translated Anthropic event:", JSON.stringify(event));
+				const eventData = JSON.stringify(event);
+				debugLazy(logger$7, () => ["Translated Anthropic event:", eventData]);
 				await stream.writeSSE({
 					event: event.type,
-					data: JSON.stringify(event)
+					data: eventData
 				});
 			}
 		}
 	});
 };
 const handleWithResponsesApi = async (c, anthropicPayload, options) => {
-	const { subagentMarker, selectedModel, requestId, sessionId, isCompact } = options;
+	const { logger: logger$7, subagentMarker, selectedModel, requestId, sessionId, isCompact } = options;
 	const responsesPayload = translateAnthropicMessagesToResponsesPayload(anthropicPayload);
 	applyResponsesApiContextManagement(responsesPayload, selectedModel?.capabilities.limits.max_prompt_tokens);
 	compactInputByLatestCompaction(responsesPayload);
-	logger$5.debug("Translated Responses payload:", JSON.stringify(responsesPayload));
+	debugJson(logger$7, "Translated Responses payload:", responsesPayload);
 	const { vision, initiator } = getResponsesRequestOptions(responsesPayload);
 	const response = await createResponses(responsesPayload, {
 		vision,
@@ -2287,7 +2326,7 @@ const handleWithResponsesApi = async (c, anthropicPayload, options) => {
 		isCompact
 	});
 	if (responsesPayload.stream && isAsyncIterable$1(response)) {
-		logger$5.debug("Streaming response from Copilot (Responses API)");
+		logger$7.debug("Streaming response from Copilot (Responses API)");
 		return streamSSE(c, async (stream) => {
 			const streamState = createResponsesStreamState();
 			for await (const chunk of response) {
@@ -2300,23 +2339,23 @@ const handleWithResponsesApi = async (c, anthropicPayload, options) => {
 				}
 				const data = chunk.data;
 				if (!data) continue;
-				logger$5.debug("Responses raw stream event:", data);
+				debugLazy(logger$7, () => ["Responses raw stream event:", data]);
 				const events$1 = translateResponsesStreamEvent(JSON.parse(data), streamState);
 				for (const event of events$1) {
 					const eventData = JSON.stringify(event);
-					logger$5.debug("Translated Anthropic event:", eventData);
+					debugLazy(logger$7, () => ["Translated Anthropic event:", eventData]);
 					await stream.writeSSE({
 						event: event.type,
 						data: eventData
 					});
 				}
 				if (streamState.messageCompleted) {
-					logger$5.debug("Message completed, ending stream");
+					logger$7.debug("Message completed, ending stream");
 					break;
 				}
 			}
 			if (!streamState.messageCompleted) {
-				logger$5.warn("Responses stream ended without completion; sending error event");
+				logger$7.warn("Responses stream ended without completion; sending error event");
 				const errorEvent = buildErrorEvent("Responses stream ended without completion");
 				await stream.writeSSE({
 					event: errorEvent.type,
@@ -2325,25 +2364,18 @@ const handleWithResponsesApi = async (c, anthropicPayload, options) => {
 			}
 		});
 	}
-	logger$5.debug("Non-streaming Responses result:", JSON.stringify(response).slice(-400));
+	debugJsonTail(logger$7, "Non-streaming Responses result:", {
+		value: response,
+		tailLength: 400
+	});
 	const anthropicResponse = translateResponsesResultToAnthropic(response);
-	logger$5.debug("Translated Anthropic response:", JSON.stringify(anthropicResponse));
+	debugJson(logger$7, "Translated Anthropic response:", anthropicResponse);
 	return c.json(anthropicResponse);
 };
 const handleWithMessagesApi = async (c, anthropicPayload, options) => {
-	const { anthropicBetaHeader, subagentMarker, selectedModel, requestId, sessionId, isCompact } = options;
-	stripCacheControl(anthropicPayload);
-	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("@");
-	});
-	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$5.debug("Translated Messages payload:", JSON.stringify(anthropicPayload));
+	const { logger: logger$7, anthropicBetaHeader, subagentMarker, selectedModel, requestId, sessionId, isCompact } = options;
+	prepareMessagesApiPayload(anthropicPayload, selectedModel);
+	debugJson(logger$7, "Translated Messages payload:", anthropicPayload);
 	const response = await createMessages(anthropicPayload, anthropicBetaHeader, {
 		subagentMarker,
 		requestId,
@@ -2351,12 +2383,12 @@ const handleWithMessagesApi = async (c, anthropicPayload, options) => {
 		isCompact
 	});
 	if (isAsyncIterable$1(response)) {
-		logger$5.debug("Streaming response from Copilot (Messages API)");
+		logger$7.debug("Streaming response from Copilot (Messages API)");
 		return streamSSE(c, async (stream) => {
 			for await (const event of response) {
 				const eventName = event.event;
 				const data = event.data ?? "";
-				logger$5.debug("Messages raw stream event:", data);
+				debugLazy(logger$7, () => ["Messages raw stream event:", data]);
 				await stream.writeSSE({
 					event: eventName,
 					data
@@ -2364,95 +2396,116 @@ const handleWithMessagesApi = async (c, anthropicPayload, options) => {
 			}
 		});
 	}
-	logger$5.debug("Non-streaming Messages result:", JSON.stringify(response).slice(-400));
+	debugJsonTail(logger$7, "Non-streaming Messages result:", {
+		value: response,
+		tailLength: 400
+	});
 	return c.json(response);
 };
-const shouldUseResponsesApi = (selectedModel) => {
-	return selectedModel?.supported_endpoints?.includes(RESPONSES_ENDPOINT$1) ?? false;
-};
-const shouldUseMessagesApi = (selectedModel) => {
-	if (!isMessagesApiEnabled()) return false;
-	return selectedModel?.supported_endpoints?.includes(MESSAGES_ENDPOINT) ?? false;
-};
 const isNonStreaming = (response) => Object.hasOwn(response, "choices");
 const isAsyncIterable$1 = (value) => Boolean(value) && typeof value[Symbol.asyncIterator] === "function";
-const getAnthropicEffortForModel = (model) => {
-	const reasoningEffort = getReasoningEffortForModel(model);
-	if (reasoningEffort === "xhigh") return "max";
-	if (reasoningEffort === "none" || reasoningEffort === "minimal") return "low";
-	return reasoningEffort;
-};
-const getCompactCandidateText = (message) => {
-	if (message.role !== "user") return "";
-	if (typeof message.content === "string") return message.content;
-	return message.content.filter((block) => block.type === "text").map((block) => block.text.startsWith("<system-reminder>") ? "" : block.text).filter((text) => text.length > 0).join("\n\n");
-};
-const isCompactMessage = (lastMessage) => {
-	const text = getCompactCandidateText(lastMessage);
-	if (!text) return false;
-	return text.includes(compactTextOnlyGuard) && text.includes(compactSummaryPromptStart) && compactMessageSections.some((section) => text.includes(section));
-};
-const isCompactRequest = (anthropicPayload) => {
-	const lastMessage = anthropicPayload.messages.at(-1);
-	if (lastMessage && isCompactMessage(lastMessage)) return true;
-	const system = anthropicPayload.system;
-	if (typeof system === "string") return system.startsWith(compactSystemPromptStart);
-	if (!Array.isArray(system)) return false;
-	return system.some((msg) => typeof msg.text === "string" && msg.text.startsWith(compactSystemPromptStart));
-};
-const mergeContentWithText = (tr, textBlock) => {
-	if (typeof tr.content === "string") return {
-		...tr,
-		content: `${tr.content}\n\n${textBlock.text}`
-	};
-	return {
-		...tr,
-		content: [...tr.content, textBlock]
-	};
-};
-const mergeContentWithTexts = (tr, textBlocks) => {
-	if (typeof tr.content === "string") {
-		const appendedTexts = textBlocks.map((tb) => tb.text).join("\n\n");
-		return {
-			...tr,
-			content: `${tr.content}\n\n${appendedTexts}`
-		};
+
+//#endregion
+//#region src/routes/messages/subagent-marker.ts
+const subagentMarkerPrefix = "__SUBAGENT_MARKER__";
+const parseSubagentMarkerFromFirstUser = (payload) => {
+	const firstUserMessage = payload.messages.find((msg) => msg.role === "user");
+	if (!firstUserMessage || !Array.isArray(firstUserMessage.content)) return null;
+	for (const block of firstUserMessage.content) {
+		if (block.type !== "text") continue;
+		const marker = parseSubagentMarkerFromSystemReminder(block.text);
+		if (marker) return marker;
 	}
-	return {
-		...tr,
-		content: [...tr.content, ...textBlocks]
-	};
+	return null;
 };
-const mergeToolResultForClaude = (anthropicPayload) => {
-	for (const msg of anthropicPayload.messages) {
-		if (msg.role !== "user" || !Array.isArray(msg.content)) continue;
-		const toolResults = [];
-		const textBlocks = [];
-		let valid = true;
-		for (const block of msg.content) if (block.type === "tool_result") toolResults.push(block);
-		else if (block.type === "text") textBlocks.push(block);
-		else {
-			valid = false;
-			break;
+const parseSubagentMarkerFromSystemReminder = (text) => {
+	const startTag = "<system-reminder>";
+	const endTag = "</system-reminder>";
+	let searchFrom = 0;
+	while (true) {
+		const reminderStart = text.indexOf(startTag, searchFrom);
+		if (reminderStart === -1) break;
+		const contentStart = reminderStart + 17;
+		const reminderEnd = text.indexOf(endTag, contentStart);
+		if (reminderEnd === -1) break;
+		const reminderContent = text.slice(contentStart, reminderEnd);
+		const markerIndex = reminderContent.indexOf(subagentMarkerPrefix);
+		if (markerIndex === -1) {
+			searchFrom = reminderEnd + 18;
+			continue;
+		}
+		const markerJson = reminderContent.slice(markerIndex + 19).trim();
+		try {
+			const parsed = JSON.parse(markerJson);
+			if (!parsed.session_id || !parsed.agent_id || !parsed.agent_type) {
+				searchFrom = reminderEnd + 18;
+				continue;
+			}
+			return parsed;
+		} catch {
+			searchFrom = reminderEnd + 18;
+			continue;
 		}
-		if (!valid || toolResults.length === 0 || textBlocks.length === 0) continue;
-		msg.content = mergeToolResult(toolResults, textBlocks);
 	}
+	return null;
 };
-const mergeToolResult = (toolResults, textBlocks) => {
-	if (toolResults.length === textBlocks.length) return toolResults.map((tr, i) => mergeContentWithText(tr, textBlocks[i]));
-	const lastIndex = toolResults.length - 1;
-	return toolResults.map((tr, i) => i === lastIndex ? mergeContentWithTexts(tr, textBlocks) : tr);
+
+//#endregion
+//#region src/routes/messages/handler.ts
+const logger$5 = createHandlerLogger("messages-handler");
+async function handleCompletion(c) {
+	await checkRateLimit(state);
+	const anthropicPayload = await c.req.json();
+	debugJson(logger$5, "Anthropic request payload:", anthropicPayload);
+	const subagentMarker = parseSubagentMarkerFromFirstUser(anthropicPayload);
+	if (subagentMarker) debugJson(logger$5, "Detected Subagent marker:", subagentMarker);
+	const sessionId = getRootSessionId(anthropicPayload, c);
+	logger$5.debug("Extracted session ID:", sessionId);
+	const isCompact = isCompactRequest(anthropicPayload);
+	const anthropicBeta = c.req.header("anthropic-beta");
+	logger$5.debug("Anthropic Beta header:", anthropicBeta);
+	const noTools = !anthropicPayload.tools || anthropicPayload.tools.length === 0;
+	if (anthropicBeta && noTools && !isCompact) anthropicPayload.model = getSmallModel();
+	if (isCompact) logger$5.debug("Is compact request:", isCompact);
+	else mergeToolResultForClaude(anthropicPayload);
+	const requestId = generateRequestIdFromPayload(anthropicPayload, sessionId);
+	logger$5.debug("Generated request ID:", requestId);
+	if (state.manualApprove) await awaitApproval();
+	const selectedModel = findEndpointModel(anthropicPayload.model);
+	anthropicPayload.model = selectedModel?.id ?? anthropicPayload.model;
+	if (shouldUseMessagesApi(selectedModel)) return await handleWithMessagesApi(c, anthropicPayload, {
+		anthropicBetaHeader: anthropicBeta,
+		subagentMarker,
+		selectedModel,
+		requestId,
+		sessionId,
+		isCompact,
+		logger: logger$5
+	});
+	if (shouldUseResponsesApi(selectedModel)) return await handleWithResponsesApi(c, anthropicPayload, {
+		subagentMarker,
+		selectedModel,
+		requestId,
+		sessionId,
+		isCompact,
+		logger: logger$5
+	});
+	return await handleWithChatCompletions(c, anthropicPayload, {
+		subagentMarker,
+		requestId,
+		sessionId,
+		isCompact,
+		logger: logger$5
+	});
+}
+const RESPONSES_ENDPOINT$1 = "/responses";
+const MESSAGES_ENDPOINT = "/v1/messages";
+const shouldUseResponsesApi = (selectedModel) => {
+	return selectedModel?.supported_endpoints?.includes(RESPONSES_ENDPOINT$1) ?? false;
 };
-const stripCacheControl = (payload) => {
-	if (Array.isArray(payload.system)) for (const block of payload.system) {
-		const b = block;
-		const cc = b.cache_control;
-		if (cc && typeof cc === "object") {
-			const { scope,...rest } = cc;
-			b.cache_control = rest;
-		}
-	}
+const shouldUseMessagesApi = (selectedModel) => {
+	if (!isMessagesApiEnabled()) return false;
+	return selectedModel?.supported_endpoints?.includes(MESSAGES_ENDPOINT) ?? false;
 };
 
 //#endregion
@@ -2622,10 +2675,10 @@ async function handleProviderMessages(c) {
 		payload.temperature ??= modelConfig?.temperature;
 		payload.top_p ??= modelConfig?.topP;
 		payload.top_k ??= modelConfig?.topK;
-		logger$3.debug("provider.messages.request", JSON.stringify({
+		debugJson(logger$3, "provider.messages.request", {
 			payload,
 			provider
-		}));
+		});
 		const upstreamResponse = await forwardProviderMessages(providerConfig, payload, c.req.raw.headers);
 		if (!upstreamResponse.ok) {
 			logger$3.error("Failed to create responses", upstreamResponse);
@@ -2668,7 +2721,7 @@ async function handleProviderMessages(c) {
 		}
 		const jsonBody = await upstreamResponse.json();
 		adjustInputTokens(providerConfig, jsonBody.usage);
-		logger$3.debug("provider.messages.no_stream result:", JSON.stringify(jsonBody));
+		debugJson(logger$3, "provider.messages.no_stream result:", jsonBody);
 		return c.json(jsonBody);
 	} catch (error) {
 		logger$3.error("provider.messages.error", {
@@ -2681,7 +2734,7 @@ async function handleProviderMessages(c) {
 const adjustInputTokens = (providerConfig, usage) => {
 	if (!providerConfig.adjustInputTokens || !usage) return;
 	usage.input_tokens = Math.max(0, (usage.input_tokens ?? 0) - (usage.cache_read_input_tokens ?? 0) - (usage.cache_creation_input_tokens ?? 0));
-	logger$3.debug("provider.messages.adjusted_usage:", JSON.stringify(usage));
+	debugJson(logger$3, "provider.messages.adjusted_usage:", usage);
 };
 
 //#endregion
@@ -2773,7 +2826,7 @@ const RESPONSES_ENDPOINT = "/responses";
 const handleResponses = async (c) => {
 	await checkRateLimit(state);
 	const payload = await c.req.json();
-	logger$1.debug("Responses request payload:", JSON.stringify(payload));
+	debugJson(logger$1, "Responses request payload:", payload);
 	const requestId = generateRequestIdFromPayload({ messages: payload.input });
 	logger$1.debug("Generated request ID:", requestId);
 	const sessionId = getUUID(requestId);
@@ -2787,7 +2840,7 @@ const handleResponses = async (c) => {
 		type: "invalid_request_error"
 	} }, 400);
 	applyResponsesApiContextManagement(payload, selectedModel?.capabilities.limits.max_prompt_tokens);
-	logger$1.debug("Translated Responses payload:", JSON.stringify(payload));
+	debugJson(logger$1, "Translated Responses payload:", payload);
 	const { vision, initiator } = getResponsesRequestOptions(payload);
 	if (state.manualApprove) await awaitApproval();
 	const response = await createResponses(payload, {
@@ -2801,7 +2854,7 @@ const handleResponses = async (c) => {
 		return streamSSE(c, async (stream) => {
 			const idTracker = createStreamIdTracker();
 			for await (const chunk of response) {
-				logger$1.debug("Responses stream chunk:", JSON.stringify(chunk));
+				debugJson(logger$1, "Responses stream chunk:", chunk);
 				const processedData = fixStreamIds(chunk.data ?? "", chunk.event, idTracker);
 				await stream.writeSSE({
 					id: chunk.id,
@@ -2811,7 +2864,10 @@ const handleResponses = async (c) => {
 			}
 		});
 	}
-	logger$1.debug("Forwarding native Responses result:", JSON.stringify(response).slice(-400));
+	debugJsonTail(logger$1, "Forwarding native Responses result:", {
+		value: response,
+		tailLength: 400
+	});
 	return c.json(response);
 };
 const isAsyncIterable = (value) => Boolean(value) && typeof value[Symbol.asyncIterator] === "function";
@@ -2920,4 +2976,4 @@ server.route("/:provider/v1/models", providerModelRoutes);
 
 //#endregion
 export { server };
-//# sourceMappingURL=server-DAyVU7jA.js.map
+//# sourceMappingURL=server-DP3qGqqy.js.map