@jeffreycao/copilot-api 1.0.0

package/dist/server-IY-mTdPh.js

@@ -0,0 +1,2252 @@
+import { HTTPError, PATHS, cacheModels, copilotBaseUrl, copilotHeaders, forwardError, getConfig, getCopilotUsage, getExtraPromptForModel, getReasoningEffortForModel, getSmallModel, isNullish, shouldCompactUseSmallModel, sleep, state } from "./config-BKsHEU7z.js";
+import consola from "consola";
+import path from "node:path";
+import fs from "node:fs";
+import { Hono } from "hono";
+import { cors } from "hono/cors";
+import { logger } from "hono/logger";
+import { streamSSE } from "hono/streaming";
+import util from "node:util";
+import { events } from "fetch-event-stream";
+
+//#region src/lib/approval.ts
+const awaitApproval = async () => {
+	if (!await consola.prompt(`Accept incoming request?`, { type: "confirm" })) throw new HTTPError("Request rejected", Response.json({ message: "Request rejected" }, { status: 403 }));
+};
+
+//#endregion
+//#region src/lib/logger.ts
+const LOG_RETENTION_MS = 10080 * 60 * 1e3;
+const CLEANUP_INTERVAL_MS = 1440 * 60 * 1e3;
+const LOG_DIR = path.join(PATHS.APP_DIR, "logs");
+const FLUSH_INTERVAL_MS = 1e3;
+const MAX_BUFFER_SIZE = 100;
+const logStreams = /* @__PURE__ */ new Map();
+const logBuffers = /* @__PURE__ */ new Map();
+const ensureLogDirectory = () => {
+	if (!fs.existsSync(LOG_DIR)) fs.mkdirSync(LOG_DIR, { recursive: true });
+};
+const cleanupOldLogs = () => {
+	if (!fs.existsSync(LOG_DIR)) return;
+	const now = Date.now();
+	for (const entry of fs.readdirSync(LOG_DIR)) {
+		const filePath = path.join(LOG_DIR, entry);
+		let stats;
+		try {
+			stats = fs.statSync(filePath);
+		} catch {
+			continue;
+		}
+		if (!stats.isFile()) continue;
+		if (now - stats.mtimeMs > LOG_RETENTION_MS) try {
+			fs.rmSync(filePath);
+		} catch {
+			continue;
+		}
+	}
+};
+const formatArgs = (args) => args.map((arg) => typeof arg === "string" ? arg : util.inspect(arg, {
+	depth: null,
+	colors: false
+})).join(" ");
+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 flushBuffer = (filePath) => {
+	const buffer = logBuffers.get(filePath);
+	if (!buffer || buffer.length === 0) return;
+	const stream = getLogStream(filePath);
+	const content = buffer.join("\n") + "\n";
+	stream.write(content, (error) => {
+		if (error) console.warn("Failed to write handler log", error);
+	});
+	logBuffers.set(filePath, []);
+};
+const flushAllBuffers = () => {
+	for (const filePath of logBuffers.keys()) flushBuffer(filePath);
+};
+const appendLine = (filePath, line) => {
+	let buffer = logBuffers.get(filePath);
+	if (!buffer) {
+		buffer = [];
+		logBuffers.set(filePath, buffer);
+	}
+	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();
+};
+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();
+		}
+		const date = logObj.date;
+		const dateKey = date.toLocaleDateString("sv-SE");
+		const timestamp = date.toLocaleString("sv-SE", { hour12: false });
+		const filePath = path.join(LOG_DIR, `${sanitizedName}-${dateKey}.log`);
+		const message = formatArgs(logObj.args);
+		const line = `[${timestamp}] [${logObj.type}] [${logObj.tag || name}]${message ? ` ${message}` : ""}`;
+		appendLine(filePath, line);
+	} });
+	return instance;
+};
+
+//#endregion
+//#region src/lib/rate-limit.ts
+async function checkRateLimit(state$1) {
+	if (state$1.rateLimitSeconds === void 0) return;
+	const now = Date.now();
+	if (!state$1.lastRequestTimestamp) {
+		state$1.lastRequestTimestamp = now;
+		return;
+	}
+	const elapsedSeconds = (now - state$1.lastRequestTimestamp) / 1e3;
+	if (elapsedSeconds > state$1.rateLimitSeconds) {
+		state$1.lastRequestTimestamp = now;
+		return;
+	}
+	const waitTimeSeconds = Math.ceil(state$1.rateLimitSeconds - elapsedSeconds);
+	if (!state$1.rateLimitWait) {
+		consola.warn(`Rate limit exceeded. Need to wait ${waitTimeSeconds} more seconds.`);
+		throw new HTTPError("Rate limit exceeded", Response.json({ message: "Rate limit exceeded" }, { status: 429 }));
+	}
+	const waitTimeMs = waitTimeSeconds * 1e3;
+	consola.warn(`Rate limit reached. Waiting ${waitTimeSeconds} seconds before proceeding...`);
+	await sleep(waitTimeMs);
+	state$1.lastRequestTimestamp = now;
+	consola.info("Rate limit wait completed, proceeding with request");
+}
+
+//#endregion
+//#region src/lib/tokenizer.ts
+const ENCODING_MAP = {
+	o200k_base: () => import("gpt-tokenizer/encoding/o200k_base"),
+	cl100k_base: () => import("gpt-tokenizer/encoding/cl100k_base"),
+	p50k_base: () => import("gpt-tokenizer/encoding/p50k_base"),
+	p50k_edit: () => import("gpt-tokenizer/encoding/p50k_edit"),
+	r50k_base: () => import("gpt-tokenizer/encoding/r50k_base")
+};
+const encodingCache = /* @__PURE__ */ new Map();
+/**
+* Calculate tokens for tool calls
+*/
+const calculateToolCallsTokens = (toolCalls, encoder, constants) => {
+	let tokens = 0;
+	for (const toolCall of toolCalls) {
+		tokens += constants.funcInit;
+		tokens += encoder.encode(toolCall.id).length;
+		tokens += encoder.encode(toolCall.function.name).length;
+		tokens += encoder.encode(toolCall.function.arguments).length;
+	}
+	tokens += constants.funcEnd;
+	return tokens;
+};
+/**
+* Calculate tokens for content parts
+*/
+const calculateContentPartsTokens = (contentParts, encoder) => {
+	let tokens = 0;
+	for (const part of contentParts) if (part.type === "image_url") tokens += encoder.encode(part.image_url.url).length + 85;
+	else if (part.text) tokens += encoder.encode(part.text).length;
+	return tokens;
+};
+/**
+* Calculate tokens for a single message
+*/
+const calculateMessageTokens = (message, encoder, constants) => {
+	const tokensPerMessage = 3;
+	const tokensPerName = 1;
+	let tokens = tokensPerMessage;
+	for (const [key, value] of Object.entries(message)) {
+		if (key === "reasoning_opaque") continue;
+		if (typeof value === "string") tokens += encoder.encode(value).length;
+		if (key === "name") tokens += tokensPerName;
+		if (key === "tool_calls") tokens += calculateToolCallsTokens(value, encoder, constants);
+		if (key === "content" && Array.isArray(value)) tokens += calculateContentPartsTokens(value, encoder);
+	}
+	return tokens;
+};
+/**
+* Calculate tokens using custom algorithm
+*/
+const calculateTokens = (messages, encoder, constants) => {
+	if (messages.length === 0) return 0;
+	let numTokens = 0;
+	for (const message of messages) numTokens += calculateMessageTokens(message, encoder, constants);
+	numTokens += 3;
+	return numTokens;
+};
+/**
+* Get the corresponding encoder module based on encoding type
+*/
+const getEncodeChatFunction = async (encoding) => {
+	if (encodingCache.has(encoding)) {
+		const cached = encodingCache.get(encoding);
+		if (cached) return cached;
+	}
+	const supportedEncoding = encoding;
+	if (!(supportedEncoding in ENCODING_MAP)) {
+		const fallbackModule = await ENCODING_MAP.o200k_base();
+		encodingCache.set(encoding, fallbackModule);
+		return fallbackModule;
+	}
+	const encodingModule = await ENCODING_MAP[supportedEncoding]();
+	encodingCache.set(encoding, encodingModule);
+	return encodingModule;
+};
+/**
+* Get tokenizer type from model information
+*/
+const getTokenizerFromModel = (model) => {
+	return model.capabilities.tokenizer || "o200k_base";
+};
+/**
+* Get model-specific constants for token calculation
+*/
+const getModelConstants = (model) => {
+	return model.id === "gpt-3.5-turbo" || model.id === "gpt-4" ? {
+		funcInit: 10,
+		propInit: 3,
+		propKey: 3,
+		enumInit: -3,
+		enumItem: 3,
+		funcEnd: 12,
+		isGpt: true
+	} : {
+		funcInit: 7,
+		propInit: 3,
+		propKey: 3,
+		enumInit: -3,
+		enumItem: 3,
+		funcEnd: 12,
+		isGpt: model.id.startsWith("gpt-")
+	};
+};
+/**
+* Calculate tokens for a single parameter
+*/
+const calculateParameterTokens = (key, prop, context) => {
+	const { encoder, constants } = context;
+	let tokens = constants.propKey;
+	if (typeof prop !== "object" || prop === null) return tokens;
+	const param = prop;
+	const paramName = key;
+	const paramType = param.type || "string";
+	let paramDesc = param.description || "";
+	if (param.enum && Array.isArray(param.enum)) {
+		tokens += constants.enumInit;
+		for (const item of param.enum) {
+			tokens += constants.enumItem;
+			tokens += encoder.encode(String(item)).length;
+		}
+	}
+	if (paramDesc.endsWith(".")) paramDesc = paramDesc.slice(0, -1);
+	const line = `${paramName}:${paramType}:${paramDesc}`;
+	tokens += encoder.encode(line).length;
+	if (param.type === "array" && param["items"]) tokens += calculateParametersTokens(param["items"], encoder, constants);
+	const excludedKeys = new Set([
+		"type",
+		"description",
+		"enum",
+		"items"
+	]);
+	for (const propertyName of Object.keys(param)) if (!excludedKeys.has(propertyName)) {
+		const propertyValue = param[propertyName];
+		const propertyText = typeof propertyValue === "string" ? propertyValue : JSON.stringify(propertyValue);
+		tokens += encoder.encode(`${propertyName}:${propertyText}`).length;
+	}
+	return tokens;
+};
+/**
+* Calculate tokens for properties object
+*/
+const calculatePropertiesTokens = (properties, encoder, constants) => {
+	let tokens = 0;
+	if (Object.keys(properties).length > 0) {
+		tokens += constants.propInit;
+		for (const propKey of Object.keys(properties)) tokens += calculateParameterTokens(propKey, properties[propKey], {
+			encoder,
+			constants
+		});
+	}
+	return tokens;
+};
+/**
+* Calculate tokens for function parameters
+*/
+const calculateParametersTokens = (parameters, encoder, constants) => {
+	if (!parameters || typeof parameters !== "object") return 0;
+	const params = parameters;
+	let tokens = 0;
+	const excludedKeys = new Set(["$schema", "additionalProperties"]);
+	for (const [key, value] of Object.entries(params)) {
+		if (excludedKeys.has(key)) continue;
+		if (key === "properties") tokens += calculatePropertiesTokens(value, encoder, constants);
+		else {
+			const paramText = typeof value === "string" ? value : JSON.stringify(value);
+			tokens += encoder.encode(`${key}:${paramText}`).length;
+		}
+	}
+	return tokens;
+};
+/**
+* Calculate tokens for a single tool
+*/
+const calculateToolTokens = (tool, encoder, constants) => {
+	let tokens = constants.funcInit;
+	const func = tool.function;
+	const fName = func.name;
+	let fDesc = func.description || "";
+	if (fDesc.endsWith(".")) fDesc = fDesc.slice(0, -1);
+	const line = fName + ":" + fDesc;
+	tokens += encoder.encode(line).length;
+	if (typeof func.parameters === "object" && func.parameters !== null) tokens += calculateParametersTokens(func.parameters, encoder, constants);
+	return tokens;
+};
+/**
+* Calculate token count for tools based on model
+*/
+const numTokensForTools = (tools, encoder, constants) => {
+	let funcTokenCount = 0;
+	if (constants.isGpt) {
+		for (const tool of tools) funcTokenCount += calculateToolTokens(tool, encoder, constants);
+		funcTokenCount += constants.funcEnd;
+	} else for (const tool of tools) funcTokenCount += encoder.encode(JSON.stringify(tool)).length;
+	return funcTokenCount;
+};
+/**
+* Calculate the token count of messages, supporting multiple GPT encoders
+*/
+const getTokenCount = async (payload, model) => {
+	const tokenizer = getTokenizerFromModel(model);
+	const encoder = await getEncodeChatFunction(tokenizer);
+	const simplifiedMessages = payload.messages;
+	const inputMessages = simplifiedMessages.filter((msg) => msg.role !== "assistant");
+	const outputMessages = simplifiedMessages.filter((msg) => msg.role === "assistant");
+	const constants = getModelConstants(model);
+	let inputTokens = calculateTokens(inputMessages, encoder, constants);
+	if (payload.tools && payload.tools.length > 0) inputTokens += numTokensForTools(payload.tools, encoder, constants);
+	const outputTokens = calculateTokens(outputMessages, encoder, constants);
+	return {
+		input: inputTokens,
+		output: outputTokens
+	};
+};
+
+//#endregion
+//#region src/services/copilot/create-chat-completions.ts
+const createChatCompletions = async (payload) => {
+	if (!state.copilotToken) throw new Error("Copilot token not found");
+	const enableVision = payload.messages.some((x) => typeof x.content !== "string" && x.content?.some((x$1) => x$1.type === "image_url"));
+	let isAgentCall = false;
+	if (payload.messages.length > 0) {
+		const lastMessage = payload.messages.at(-1);
+		if (lastMessage) isAgentCall = ["assistant", "tool"].includes(lastMessage.role);
+	}
+	const headers = {
+		...copilotHeaders(state, enableVision),
+		"X-Initiator": isAgentCall ? "agent" : "user"
+	};
+	const response = await fetch(`${copilotBaseUrl(state)}/chat/completions`, {
+		method: "POST",
+		headers,
+		body: JSON.stringify(payload)
+	});
+	if (!response.ok) {
+		consola.error("Failed to create chat completions", response);
+		throw new HTTPError("Failed to create chat completions", response);
+	}
+	if (payload.stream) return events(response);
+	return await response.json();
+};
+
+//#endregion
+//#region src/routes/chat-completions/handler.ts
+const logger$3 = createHandlerLogger("chat-completions-handler");
+async function handleCompletion$1(c) {
+	await checkRateLimit(state);
+	let payload = await c.req.json();
+	logger$3.debug("Request payload:", JSON.stringify(payload).slice(-400));
+	const selectedModel = state.models?.data.find((model) => model.id === payload.model);
+	try {
+		if (selectedModel) {
+			const tokenCount = await getTokenCount(payload, selectedModel);
+			logger$3.info("Current token count:", tokenCount);
+		} else logger$3.warn("No model selected, skipping token count calculation");
+	} catch (error) {
+		logger$3.warn("Failed to calculate token count:", error);
+	}
+	if (state.manualApprove) await awaitApproval();
+	if (isNullish(payload.max_tokens)) {
+		payload = {
+			...payload,
+			max_tokens: selectedModel?.capabilities.limits.max_output_tokens
+		};
+		logger$3.debug("Set max_tokens to:", JSON.stringify(payload.max_tokens));
+	}
+	const response = await createChatCompletions(payload);
+	if (isNonStreaming$1(response)) {
+		logger$3.debug("Non-streaming response:", JSON.stringify(response));
+		return c.json(response);
+	}
+	logger$3.debug("Streaming response");
+	return streamSSE(c, async (stream) => {
+		for await (const chunk of response) {
+			logger$3.debug("Streaming chunk:", JSON.stringify(chunk));
+			await stream.writeSSE(chunk);
+		}
+	});
+}
+const isNonStreaming$1 = (response) => Object.hasOwn(response, "choices");
+
+//#endregion
+//#region src/routes/chat-completions/route.ts
+const completionRoutes = new Hono();
+completionRoutes.post("/", async (c) => {
+	try {
+		return await handleCompletion$1(c);
+	} catch (error) {
+		return await forwardError(c, error);
+	}
+});
+
+//#endregion
+//#region src/services/copilot/create-embeddings.ts
+const createEmbeddings = async (payload) => {
+	if (!state.copilotToken) throw new Error("Copilot token not found");
+	const response = await fetch(`${copilotBaseUrl(state)}/embeddings`, {
+		method: "POST",
+		headers: copilotHeaders(state),
+		body: JSON.stringify(payload)
+	});
+	if (!response.ok) throw new HTTPError("Failed to create embeddings", response);
+	return await response.json();
+};
+
+//#endregion
+//#region src/routes/embeddings/route.ts
+const embeddingRoutes = new Hono();
+embeddingRoutes.post("/", async (c) => {
+	try {
+		const paylod = await c.req.json();
+		const response = await createEmbeddings(paylod);
+		return c.json(response);
+	} catch (error) {
+		return await forwardError(c, error);
+	}
+});
+
+//#endregion
+//#region src/routes/messages/utils.ts
+function mapOpenAIStopReasonToAnthropic(finishReason) {
+	if (finishReason === null) return null;
+	return {
+		stop: "end_turn",
+		length: "max_tokens",
+		tool_calls: "tool_use",
+		content_filter: "end_turn"
+	}[finishReason];
+}
+
+//#endregion
+//#region src/routes/messages/non-stream-translation.ts
+const THINKING_TEXT = "Thinking...";
+function translateToOpenAI(payload) {
+	const modelId = translateModelName(payload.model);
+	const model = state.models?.data.find((m) => m.id === modelId);
+	const thinkingBudget = getThinkingBudget(payload, model);
+	return {
+		model: modelId,
+		messages: translateAnthropicMessagesToOpenAI(payload, modelId, thinkingBudget),
+		max_tokens: payload.max_tokens,
+		stop: payload.stop_sequences,
+		stream: payload.stream,
+		temperature: payload.temperature,
+		top_p: payload.top_p,
+		user: payload.metadata?.user_id,
+		tools: translateAnthropicToolsToOpenAI(payload.tools),
+		tool_choice: translateAnthropicToolChoiceToOpenAI(payload.tool_choice),
+		thinking_budget: thinkingBudget
+	};
+}
+function getThinkingBudget(payload, model) {
+	const thinking = payload.thinking;
+	if (model && thinking) {
+		const maxThinkingBudget = Math.min(model.capabilities.supports.max_thinking_budget ?? 0, (model.capabilities.limits.max_output_tokens ?? 0) - 1);
+		if (maxThinkingBudget > 0 && thinking.budget_tokens !== void 0) {
+			const budgetTokens = Math.min(thinking.budget_tokens, maxThinkingBudget);
+			return Math.max(budgetTokens, model.capabilities.supports.min_thinking_budget ?? 1024);
+		}
+	}
+}
+function translateModelName(model) {
+	if (model.startsWith("claude-sonnet-4-")) return model.replace(/^claude-sonnet-4-.*/, "claude-sonnet-4");
+	else if (model.startsWith("claude-opus-4-")) return model.replace(/^claude-opus-4-.*/, "claude-opus-4");
+	return model;
+}
+function translateAnthropicMessagesToOpenAI(payload, modelId, thinkingBudget) {
+	const systemMessages = handleSystemPrompt(payload.system, modelId, thinkingBudget);
+	const otherMessages = payload.messages.flatMap((message) => message.role === "user" ? handleUserMessage(message) : handleAssistantMessage(message, modelId));
+	if (modelId.startsWith("claude") && thinkingBudget) {
+		const reminder = "<system-reminder>you MUST follow interleaved_thinking_protocol</system-reminder>";
+		const firstUserIndex = otherMessages.findIndex((m) => m.role === "user");
+		if (firstUserIndex !== -1) {
+			const userMessage = otherMessages[firstUserIndex];
+			if (typeof userMessage.content === "string") userMessage.content = reminder + "\n\n" + userMessage.content;
+			else if (Array.isArray(userMessage.content)) userMessage.content = [{
+				type: "text",
+				text: reminder
+			}, ...userMessage.content];
+		}
+	}
+	return [...systemMessages, ...otherMessages];
+}
+function handleSystemPrompt(system, modelId, thinkingBudget) {
+	if (!system) return [];
+	let extraPrompt = "";
+	if (modelId.startsWith("claude") && thinkingBudget) extraPrompt = `
+<interleaved_thinking_protocol>
+ABSOLUTE REQUIREMENT - NON-NEGOTIABLE:
+The current thinking_mode is interleaved, Whenever you have the result of a function call, think carefully , MUST output a thinking block
+RULES:
+Tool result → thinking block (ALWAYS, no exceptions)
+This is NOT optional - it is a hard requirement
+The thinking block must contain substantive reasoning (minimum 3-5 sentences)
+Think about: what the results mean, what to do next, how to answer the user
+NEVER skip this step, even if the result seems simple or obvious
+</interleaved_thinking_protocol>`;
+	if (typeof system === "string") return [{
+		role: "system",
+		content: system + extraPrompt
+	}];
+	else return [{
+		role: "system",
+		content: system.map((block, index) => {
+			if (index === 0) return block.text + extraPrompt;
+			return block.text;
+		}).join("\n\n")
+	}];
+}
+function handleUserMessage(message) {
+	const newMessages = [];
+	if (Array.isArray(message.content)) {
+		const toolResultBlocks = message.content.filter((block) => block.type === "tool_result");
+		const otherBlocks = message.content.filter((block) => block.type !== "tool_result");
+		for (const block of toolResultBlocks) newMessages.push({
+			role: "tool",
+			tool_call_id: block.tool_use_id,
+			content: mapContent(block.content)
+		});
+		if (otherBlocks.length > 0) newMessages.push({
+			role: "user",
+			content: mapContent(otherBlocks)
+		});
+	} else newMessages.push({
+		role: "user",
+		content: mapContent(message.content)
+	});
+	return newMessages;
+}
+function handleAssistantMessage(message, modelId) {
+	if (!Array.isArray(message.content)) return [{
+		role: "assistant",
+		content: mapContent(message.content)
+	}];
+	const toolUseBlocks = message.content.filter((block) => block.type === "tool_use");
+	let thinkingBlocks = message.content.filter((block) => block.type === "thinking");
+	if (modelId.startsWith("claude")) thinkingBlocks = thinkingBlocks.filter((b) => b.thinking && b.thinking !== THINKING_TEXT && b.signature && !b.signature.includes("@"));
+	const thinkingContents = thinkingBlocks.filter((b) => b.thinking && b.thinking !== THINKING_TEXT).map((b) => b.thinking);
+	const allThinkingContent = thinkingContents.length > 0 ? thinkingContents.join("\n\n") : void 0;
+	const signature = thinkingBlocks.find((b) => b.signature)?.signature;
+	return toolUseBlocks.length > 0 ? [{
+		role: "assistant",
+		content: mapContent(message.content),
+		reasoning_text: allThinkingContent,
+		reasoning_opaque: signature,
+		tool_calls: toolUseBlocks.map((toolUse) => ({
+			id: toolUse.id,
+			type: "function",
+			function: {
+				name: toolUse.name,
+				arguments: JSON.stringify(toolUse.input)
+			}
+		}))
+	}] : [{
+		role: "assistant",
+		content: mapContent(message.content),
+		reasoning_text: allThinkingContent,
+		reasoning_opaque: signature
+	}];
+}
+function mapContent(content) {
+	if (typeof content === "string") return content;
+	if (!Array.isArray(content)) return null;
+	if (!content.some((block) => block.type === "image")) return content.filter((block) => block.type === "text").map((block) => block.text).join("\n\n");
+	const contentParts = [];
+	for (const block of content) switch (block.type) {
+		case "text":
+			contentParts.push({
+				type: "text",
+				text: block.text
+			});
+			break;
+		case "image":
+			contentParts.push({
+				type: "image_url",
+				image_url: { url: `data:${block.source.media_type};base64,${block.source.data}` }
+			});
+			break;
+	}
+	return contentParts;
+}
+function translateAnthropicToolsToOpenAI(anthropicTools) {
+	if (!anthropicTools) return;
+	return anthropicTools.map((tool) => ({
+		type: "function",
+		function: {
+			name: tool.name,
+			description: tool.description,
+			parameters: tool.input_schema
+		}
+	}));
+}
+function translateAnthropicToolChoiceToOpenAI(anthropicToolChoice) {
+	if (!anthropicToolChoice) return;
+	switch (anthropicToolChoice.type) {
+		case "auto": return "auto";
+		case "any": return "required";
+		case "tool":
+			if (anthropicToolChoice.name) return {
+				type: "function",
+				function: { name: anthropicToolChoice.name }
+			};
+			return;
+		case "none": return "none";
+		default: return;
+	}
+}
+function translateToAnthropic(response) {
+	const assistantContentBlocks = [];
+	let stopReason = response.choices[0]?.finish_reason ?? null;
+	for (const choice of response.choices) {
+		const textBlocks = getAnthropicTextBlocks(choice.message.content);
+		const thinkBlocks = getAnthropicThinkBlocks(choice.message.reasoning_text, choice.message.reasoning_opaque);
+		const toolUseBlocks = getAnthropicToolUseBlocks(choice.message.tool_calls);
+		assistantContentBlocks.push(...thinkBlocks, ...textBlocks, ...toolUseBlocks);
+		if (choice.finish_reason === "tool_calls" || stopReason === "stop") stopReason = choice.finish_reason;
+	}
+	return {
+		id: response.id,
+		type: "message",
+		role: "assistant",
+		model: response.model,
+		content: assistantContentBlocks,
+		stop_reason: mapOpenAIStopReasonToAnthropic(stopReason),
+		stop_sequence: null,
+		usage: {
+			input_tokens: (response.usage?.prompt_tokens ?? 0) - (response.usage?.prompt_tokens_details?.cached_tokens ?? 0),
+			output_tokens: response.usage?.completion_tokens ?? 0,
+			...response.usage?.prompt_tokens_details?.cached_tokens !== void 0 && { cache_read_input_tokens: response.usage.prompt_tokens_details.cached_tokens }
+		}
+	};
+}
+function getAnthropicTextBlocks(messageContent) {
+	if (typeof messageContent === "string" && messageContent.length > 0) return [{
+		type: "text",
+		text: messageContent
+	}];
+	if (Array.isArray(messageContent)) return messageContent.filter((part) => part.type === "text").map((part) => ({
+		type: "text",
+		text: part.text
+	}));
+	return [];
+}
+function getAnthropicThinkBlocks(reasoningText, reasoningOpaque) {
+	if (reasoningText && reasoningText.length > 0) return [{
+		type: "thinking",
+		thinking: reasoningText,
+		signature: reasoningOpaque || ""
+	}];
+	if (reasoningOpaque && reasoningOpaque.length > 0) return [{
+		type: "thinking",
+		thinking: THINKING_TEXT,
+		signature: reasoningOpaque
+	}];
+	return [];
+}
+function getAnthropicToolUseBlocks(toolCalls) {
+	if (!toolCalls) return [];
+	return toolCalls.map((toolCall) => ({
+		type: "tool_use",
+		id: toolCall.id,
+		name: toolCall.function.name,
+		input: JSON.parse(toolCall.function.arguments)
+	}));
+}
+
+//#endregion
+//#region src/routes/messages/count-tokens-handler.ts
+/**
+* Handles token counting for Anthropic messages
+*/
+async function handleCountTokens(c) {
+	try {
+		const anthropicBeta = c.req.header("anthropic-beta");
+		const anthropicPayload = await c.req.json();
+		const openAIPayload = translateToOpenAI(anthropicPayload);
+		const selectedModel = state.models?.data.find((model) => model.id === anthropicPayload.model);
+		if (!selectedModel) {
+			consola.warn("Model not found, returning default token count");
+			return c.json({ input_tokens: 1 });
+		}
+		const tokenCount = await getTokenCount(openAIPayload, selectedModel);
+		if (anthropicPayload.tools && anthropicPayload.tools.length > 0) {
+			let addToolSystemPromptCount = false;
+			if (anthropicBeta) {
+				const toolsLength = anthropicPayload.tools.length;
+				addToolSystemPromptCount = !anthropicPayload.tools.some((tool) => tool.name.startsWith("mcp__") || tool.name === "Skill" && toolsLength === 1);
+			}
+			if (addToolSystemPromptCount) {
+				if (anthropicPayload.model.startsWith("claude")) tokenCount.input = tokenCount.input + 346;
+				else if (anthropicPayload.model.startsWith("grok")) tokenCount.input = tokenCount.input + 120;
+			}
+		}
+		let finalTokenCount = tokenCount.input + tokenCount.output;
+		if (anthropicPayload.model.startsWith("claude")) finalTokenCount = Math.round(finalTokenCount * 1.15);
+		consola.info("Token count:", finalTokenCount);
+		return c.json({ input_tokens: finalTokenCount });
+	} catch (error) {
+		consola.error("Error counting tokens:", error);
+		return c.json({ input_tokens: 1 });
+	}
+}
+
+//#endregion
+//#region src/services/copilot/create-responses.ts
+const createResponses = async (payload, { vision, initiator }) => {
+	if (!state.copilotToken) throw new Error("Copilot token not found");
+	const headers = {
+		...copilotHeaders(state, vision),
+		"X-Initiator": initiator
+	};
+	payload.service_tier = null;
+	const response = await fetch(`${copilotBaseUrl(state)}/responses`, {
+		method: "POST",
+		headers,
+		body: JSON.stringify(payload)
+	});
+	if (!response.ok) {
+		consola.error("Failed to create responses", response);
+		throw new HTTPError("Failed to create responses", response);
+	}
+	if (payload.stream) return events(response);
+	return await response.json();
+};
+
+//#endregion
+//#region src/routes/messages/responses-translation.ts
+const MESSAGE_TYPE = "message";
+const THINKING_TEXT$1 = "Thinking...";
+const translateAnthropicMessagesToResponsesPayload = (payload) => {
+	const input = [];
+	for (const message of payload.messages) input.push(...translateMessage(message));
+	const translatedTools = convertAnthropicTools(payload.tools);
+	const toolChoice = convertAnthropicToolChoice(payload.tool_choice);
+	const { safetyIdentifier, promptCacheKey } = parseUserId(payload.metadata?.user_id);
+	return {
+		model: payload.model,
+		input,
+		instructions: translateSystemPrompt(payload.system, payload.model),
+		temperature: 1,
+		top_p: payload.top_p ?? null,
+		max_output_tokens: Math.max(payload.max_tokens, 12800),
+		tools: translatedTools,
+		tool_choice: toolChoice,
+		metadata: payload.metadata ? { ...payload.metadata } : null,
+		safety_identifier: safetyIdentifier,
+		prompt_cache_key: promptCacheKey,
+		stream: payload.stream ?? null,
+		store: false,
+		parallel_tool_calls: true,
+		reasoning: {
+			effort: getReasoningEffortForModel(payload.model),
+			summary: "detailed"
+		},
+		include: ["reasoning.encrypted_content"]
+	};
+};
+const translateMessage = (message) => {
+	if (message.role === "user") return translateUserMessage(message);
+	return translateAssistantMessage(message);
+};
+const translateUserMessage = (message) => {
+	if (typeof message.content === "string") return [createMessage("user", message.content)];
+	if (!Array.isArray(message.content)) return [];
+	const items = [];
+	const pendingContent = [];
+	for (const block of message.content) {
+		if (block.type === "tool_result") {
+			flushPendingContent("user", pendingContent, items);
+			items.push(createFunctionCallOutput(block));
+			continue;
+		}
+		const converted = translateUserContentBlock(block);
+		if (converted) pendingContent.push(converted);
+	}
+	flushPendingContent("user", pendingContent, items);
+	return items;
+};
+const translateAssistantMessage = (message) => {
+	if (typeof message.content === "string") return [createMessage("assistant", message.content)];
+	if (!Array.isArray(message.content)) return [];
+	const items = [];
+	const pendingContent = [];
+	for (const block of message.content) {
+		if (block.type === "tool_use") {
+			flushPendingContent("assistant", pendingContent, items);
+			items.push(createFunctionToolCall(block));
+			continue;
+		}
+		if (block.type === "thinking" && block.signature && block.signature.includes("@")) {
+			flushPendingContent("assistant", pendingContent, items);
+			items.push(createReasoningContent(block));
+			continue;
+		}
+		const converted = translateAssistantContentBlock(block);
+		if (converted) pendingContent.push(converted);
+	}
+	flushPendingContent("assistant", pendingContent, items);
+	return items;
+};
+const translateUserContentBlock = (block) => {
+	switch (block.type) {
+		case "text": return createTextContent(block.text);
+		case "image": return createImageContent(block);
+		default: return;
+	}
+};
+const translateAssistantContentBlock = (block) => {
+	switch (block.type) {
+		case "text": return createOutPutTextContent(block.text);
+		default: return;
+	}
+};
+const flushPendingContent = (role, pendingContent, target) => {
+	if (pendingContent.length === 0) return;
+	const messageContent = [...pendingContent];
+	target.push(createMessage(role, messageContent));
+	pendingContent.length = 0;
+};
+const createMessage = (role, content) => ({
+	type: MESSAGE_TYPE,
+	role,
+	content
+});
+const createTextContent = (text) => ({
+	type: "input_text",
+	text
+});
+const createOutPutTextContent = (text) => ({
+	type: "output_text",
+	text
+});
+const createImageContent = (block) => ({
+	type: "input_image",
+	image_url: `data:${block.source.media_type};base64,${block.source.data}`,
+	detail: "auto"
+});
+const createReasoningContent = (block) => {
+	const array = block.signature.split("@");
+	const signature = array[0];
+	const id = array[1];
+	const thinking = block.thinking === THINKING_TEXT$1 ? "" : block.thinking;
+	return {
+		id,
+		type: "reasoning",
+		summary: thinking ? [{
+			type: "summary_text",
+			text: thinking
+		}] : [],
+		encrypted_content: signature
+	};
+};
+const createFunctionToolCall = (block) => ({
+	type: "function_call",
+	call_id: block.id,
+	name: block.name,
+	arguments: JSON.stringify(block.input),
+	status: "completed"
+});
+const createFunctionCallOutput = (block) => ({
+	type: "function_call_output",
+	call_id: block.tool_use_id,
+	output: convertToolResultContent(block.content),
+	status: block.is_error ? "incomplete" : "completed"
+});
+const translateSystemPrompt = (system, model) => {
+	if (!system) return null;
+	const extraPrompt = getExtraPromptForModel(model);
+	if (typeof system === "string") return system + extraPrompt;
+	const text = system.map((block, index) => {
+		if (index === 0) return block.text + extraPrompt;
+		return block.text;
+	}).join(" ");
+	return text.length > 0 ? text : null;
+};
+const convertAnthropicTools = (tools) => {
+	if (!tools || tools.length === 0) return null;
+	return tools.map((tool) => ({
+		type: "function",
+		name: tool.name,
+		parameters: tool.input_schema,
+		strict: false,
+		...tool.description ? { description: tool.description } : {}
+	}));
+};
+const convertAnthropicToolChoice = (choice) => {
+	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 "none": return "none";
+		default: return "auto";
+	}
+};
+const translateResponsesResultToAnthropic = (response) => {
+	const contentBlocks = mapOutputToAnthropicContent(response.output);
+	const usage = mapResponsesUsage(response);
+	let anthropicContent = fallbackContentBlocks(response.output_text);
+	if (contentBlocks.length > 0) anthropicContent = contentBlocks;
+	const stopReason = mapResponsesStopReason(response);
+	return {
+		id: response.id,
+		type: "message",
+		role: "assistant",
+		content: anthropicContent,
+		model: response.model,
+		stop_reason: stopReason,
+		stop_sequence: null,
+		usage
+	};
+};
+const mapOutputToAnthropicContent = (output) => {
+	const contentBlocks = [];
+	for (const item of output) switch (item.type) {
+		case "reasoning": {
+			const thinkingText = extractReasoningText(item);
+			if (thinkingText.length > 0) contentBlocks.push({
+				type: "thinking",
+				thinking: thinkingText,
+				signature: (item.encrypted_content ?? "") + "@" + item.id
+			});
+			break;
+		}
+		case "function_call": {
+			const toolUseBlock = createToolUseContentBlock(item);
+			if (toolUseBlock) contentBlocks.push(toolUseBlock);
+			break;
+		}
+		case "message": {
+			const combinedText = combineMessageTextContent(item.content);
+			if (combinedText.length > 0) contentBlocks.push({
+				type: "text",
+				text: combinedText
+			});
+			break;
+		}
+		default: {
+			const combinedText = combineMessageTextContent(item.content);
+			if (combinedText.length > 0) contentBlocks.push({
+				type: "text",
+				text: combinedText
+			});
+		}
+	}
+	return contentBlocks;
+};
+const combineMessageTextContent = (content) => {
+	if (!Array.isArray(content)) return "";
+	let aggregated = "";
+	for (const block of content) {
+		if (isResponseOutputText(block)) {
+			aggregated += block.text;
+			continue;
+		}
+		if (isResponseOutputRefusal(block)) {
+			aggregated += block.refusal;
+			continue;
+		}
+		if (typeof block.text === "string") {
+			aggregated += block.text;
+			continue;
+		}
+		if (typeof block.reasoning === "string") {
+			aggregated += block.reasoning;
+			continue;
+		}
+	}
+	return aggregated;
+};
+const extractReasoningText = (item) => {
+	const segments = [];
+	const collectFromBlocks = (blocks) => {
+		if (!Array.isArray(blocks)) return;
+		for (const block of blocks) if (typeof block.text === "string") {
+			segments.push(block.text);
+			continue;
+		}
+	};
+	if (!item.summary || item.summary.length === 0) return THINKING_TEXT$1;
+	collectFromBlocks(item.summary);
+	return segments.join("").trim();
+};
+const createToolUseContentBlock = (call) => {
+	const toolId = call.call_id;
+	if (!call.name || !toolId) return null;
+	const input = parseFunctionCallArguments(call.arguments);
+	return {
+		type: "tool_use",
+		id: toolId,
+		name: call.name,
+		input
+	};
+};
+const parseFunctionCallArguments = (rawArguments) => {
+	if (typeof rawArguments !== "string" || rawArguments.trim().length === 0) return {};
+	try {
+		const parsed = JSON.parse(rawArguments);
+		if (Array.isArray(parsed)) return { arguments: parsed };
+		if (parsed && typeof parsed === "object") return parsed;
+	} catch (error) {
+		consola.warn("Failed to parse function call arguments", {
+			error,
+			rawArguments
+		});
+	}
+	return { raw_arguments: rawArguments };
+};
+const fallbackContentBlocks = (outputText) => {
+	if (!outputText) return [];
+	return [{
+		type: "text",
+		text: 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";
+		return "end_turn";
+	}
+	if (status === "incomplete") {
+		if (incompleteDetails?.reason === "max_output_tokens") return "max_tokens";
+		if (incompleteDetails?.reason === "content_filter") return "end_turn";
+	}
+	return null;
+};
+const mapResponsesUsage = (response) => {
+	const inputTokens = response.usage?.input_tokens ?? 0;
+	const outputTokens = response.usage?.output_tokens ?? 0;
+	const inputCachedTokens = response.usage?.input_tokens_details?.cached_tokens;
+	return {
+		input_tokens: inputTokens - (inputCachedTokens ?? 0),
+		output_tokens: outputTokens,
+		...response.usage?.input_tokens_details?.cached_tokens !== void 0 && { cache_read_input_tokens: response.usage.input_tokens_details.cached_tokens }
+	};
+};
+const isRecord = (value) => typeof value === "object" && value !== null;
+const isResponseOutputText = (block) => isRecord(block) && "type" in block && block.type === "output_text";
+const isResponseOutputRefusal = (block) => isRecord(block) && "type" in block && block.type === "refusal";
+const parseUserId = (userId) => {
+	if (!userId || typeof userId !== "string") return {
+		safetyIdentifier: null,
+		promptCacheKey: null
+	};
+	const userMatch = userId.match(/user_([^_]+)_account/);
+	const safetyIdentifier = userMatch ? userMatch[1] : null;
+	const sessionMatch = userId.match(/_session_(.+)$/);
+	const promptCacheKey = sessionMatch ? sessionMatch[1] : null;
+	return {
+		safetyIdentifier,
+		promptCacheKey
+	};
+};
+const convertToolResultContent = (content) => {
+	if (typeof content === "string") return content;
+	if (Array.isArray(content)) {
+		const result = [];
+		for (const block of content) switch (block.type) {
+			case "text":
+				result.push(createTextContent(block.text));
+				break;
+			case "image":
+				result.push(createImageContent(block));
+				break;
+			default: break;
+		}
+		return result;
+	}
+	return "";
+};
+
+//#endregion
+//#region src/routes/messages/responses-stream-translation.ts
+const MAX_CONSECUTIVE_FUNCTION_CALL_WHITESPACE = 20;
+var FunctionCallArgumentsValidationError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "FunctionCallArgumentsValidationError";
+	}
+};
+const updateWhitespaceRunState = (previousCount, chunk) => {
+	let count = previousCount;
+	for (const char of chunk) {
+		if (char === "\r" || char === "\n" || char === "	") {
+			count += 1;
+			if (count > MAX_CONSECUTIVE_FUNCTION_CALL_WHITESPACE) return {
+				nextCount: count,
+				exceeded: true
+			};
+			continue;
+		}
+		if (char !== " ") count = 0;
+	}
+	return {
+		nextCount: count,
+		exceeded: false
+	};
+};
+const createResponsesStreamState = () => ({
+	messageStartSent: false,
+	messageCompleted: false,
+	nextContentBlockIndex: 0,
+	blockIndexByKey: /* @__PURE__ */ new Map(),
+	openBlocks: /* @__PURE__ */ new Set(),
+	blockHasDelta: /* @__PURE__ */ new Set(),
+	functionCallStateByOutputIndex: /* @__PURE__ */ new Map()
+});
+const translateResponsesStreamEvent = (rawEvent, state$1) => {
+	switch (rawEvent.type) {
+		case "response.created": return handleResponseCreated(rawEvent, state$1);
+		case "response.output_item.added": return handleOutputItemAdded$1(rawEvent, state$1);
+		case "response.reasoning_summary_text.delta": return handleReasoningSummaryTextDelta(rawEvent, state$1);
+		case "response.output_text.delta": return handleOutputTextDelta(rawEvent, state$1);
+		case "response.reasoning_summary_text.done": return handleReasoningSummaryTextDone(rawEvent, state$1);
+		case "response.output_text.done": return handleOutputTextDone(rawEvent, state$1);
+		case "response.output_item.done": return handleOutputItemDone$1(rawEvent, state$1);
+		case "response.function_call_arguments.delta": return handleFunctionCallArgumentsDelta(rawEvent, state$1);
+		case "response.function_call_arguments.done": return handleFunctionCallArgumentsDone(rawEvent, state$1);
+		case "response.completed":
+		case "response.incomplete": return handleResponseCompleted(rawEvent, state$1);
+		case "response.failed": return handleResponseFailed(rawEvent, state$1);
+		case "error": return handleErrorEvent(rawEvent, state$1);
+		default: return [];
+	}
+};
+const handleResponseCreated = (rawEvent, state$1) => {
+	return messageStart(state$1, rawEvent.response);
+};
+const handleOutputItemAdded$1 = (rawEvent, state$1) => {
+	const events$1 = new Array();
+	const functionCallDetails = extractFunctionCallDetails(rawEvent);
+	if (!functionCallDetails) return events$1;
+	const { outputIndex, toolCallId, name, initialArguments } = functionCallDetails;
+	const blockIndex = openFunctionCallBlock(state$1, {
+		outputIndex,
+		toolCallId,
+		name,
+		events: events$1
+	});
+	if (initialArguments !== void 0 && initialArguments.length > 0) {
+		events$1.push({
+			type: "content_block_delta",
+			index: blockIndex,
+			delta: {
+				type: "input_json_delta",
+				partial_json: initialArguments
+			}
+		});
+		state$1.blockHasDelta.add(blockIndex);
+	}
+	return events$1;
+};
+const handleOutputItemDone$1 = (rawEvent, state$1) => {
+	const events$1 = new Array();
+	const item = rawEvent.item;
+	if (item.type !== "reasoning") return events$1;
+	const outputIndex = rawEvent.output_index;
+	const blockIndex = openThinkingBlockIfNeeded(state$1, outputIndex, events$1);
+	const signature = (item.encrypted_content ?? "") + "@" + item.id;
+	if (signature) {
+		if (!item.summary || item.summary.length === 0) events$1.push({
+			type: "content_block_delta",
+			index: blockIndex,
+			delta: {
+				type: "thinking_delta",
+				thinking: THINKING_TEXT$1
+			}
+		});
+		events$1.push({
+			type: "content_block_delta",
+			index: blockIndex,
+			delta: {
+				type: "signature_delta",
+				signature
+			}
+		});
+		state$1.blockHasDelta.add(blockIndex);
+	}
+	return events$1;
+};
+const handleFunctionCallArgumentsDelta = (rawEvent, state$1) => {
+	const events$1 = new Array();
+	const outputIndex = rawEvent.output_index;
+	const deltaText = rawEvent.delta;
+	if (!deltaText) return events$1;
+	const blockIndex = openFunctionCallBlock(state$1, {
+		outputIndex,
+		events: events$1
+	});
+	const functionCallState = state$1.functionCallStateByOutputIndex.get(outputIndex);
+	if (!functionCallState) return handleFunctionCallArgumentsValidationError(new FunctionCallArgumentsValidationError("Received function call arguments delta without an open tool call block."), state$1, events$1);
+	const { nextCount, exceeded } = updateWhitespaceRunState(functionCallState.consecutiveWhitespaceCount, deltaText);
+	if (exceeded) return handleFunctionCallArgumentsValidationError(new FunctionCallArgumentsValidationError("Received function call arguments delta containing more than 20 consecutive whitespace characters."), state$1, events$1);
+	functionCallState.consecutiveWhitespaceCount = nextCount;
+	events$1.push({
+		type: "content_block_delta",
+		index: blockIndex,
+		delta: {
+			type: "input_json_delta",
+			partial_json: deltaText
+		}
+	});
+	state$1.blockHasDelta.add(blockIndex);
+	return events$1;
+};
+const handleFunctionCallArgumentsDone = (rawEvent, state$1) => {
+	const events$1 = new Array();
+	const outputIndex = rawEvent.output_index;
+	const blockIndex = openFunctionCallBlock(state$1, {
+		outputIndex,
+		events: events$1
+	});
+	const finalArguments = typeof rawEvent.arguments === "string" ? rawEvent.arguments : void 0;
+	if (!state$1.blockHasDelta.has(blockIndex) && finalArguments) {
+		events$1.push({
+			type: "content_block_delta",
+			index: blockIndex,
+			delta: {
+				type: "input_json_delta",
+				partial_json: finalArguments
+			}
+		});
+		state$1.blockHasDelta.add(blockIndex);
+	}
+	state$1.functionCallStateByOutputIndex.delete(outputIndex);
+	return events$1;
+};
+const handleOutputTextDelta = (rawEvent, state$1) => {
+	const events$1 = new Array();
+	const outputIndex = rawEvent.output_index;
+	const contentIndex = rawEvent.content_index;
+	const deltaText = rawEvent.delta;
+	if (!deltaText) return events$1;
+	const blockIndex = openTextBlockIfNeeded(state$1, {
+		outputIndex,
+		contentIndex,
+		events: events$1
+	});
+	events$1.push({
+		type: "content_block_delta",
+		index: blockIndex,
+		delta: {
+			type: "text_delta",
+			text: deltaText
+		}
+	});
+	state$1.blockHasDelta.add(blockIndex);
+	return events$1;
+};
+const handleReasoningSummaryTextDelta = (rawEvent, state$1) => {
+	const outputIndex = rawEvent.output_index;
+	const deltaText = rawEvent.delta;
+	const events$1 = new Array();
+	const blockIndex = openThinkingBlockIfNeeded(state$1, outputIndex, events$1);
+	events$1.push({
+		type: "content_block_delta",
+		index: blockIndex,
+		delta: {
+			type: "thinking_delta",
+			thinking: deltaText
+		}
+	});
+	state$1.blockHasDelta.add(blockIndex);
+	return events$1;
+};
+const handleReasoningSummaryTextDone = (rawEvent, state$1) => {
+	const outputIndex = rawEvent.output_index;
+	const text = rawEvent.text;
+	const events$1 = new Array();
+	const blockIndex = openThinkingBlockIfNeeded(state$1, outputIndex, events$1);
+	if (text && !state$1.blockHasDelta.has(blockIndex)) events$1.push({
+		type: "content_block_delta",
+		index: blockIndex,
+		delta: {
+			type: "thinking_delta",
+			thinking: text
+		}
+	});
+	return events$1;
+};
+const handleOutputTextDone = (rawEvent, state$1) => {
+	const events$1 = new Array();
+	const outputIndex = rawEvent.output_index;
+	const contentIndex = rawEvent.content_index;
+	const text = rawEvent.text;
+	const blockIndex = openTextBlockIfNeeded(state$1, {
+		outputIndex,
+		contentIndex,
+		events: events$1
+	});
+	if (text && !state$1.blockHasDelta.has(blockIndex)) events$1.push({
+		type: "content_block_delta",
+		index: blockIndex,
+		delta: {
+			type: "text_delta",
+			text
+		}
+	});
+	return events$1;
+};
+const handleResponseCompleted = (rawEvent, state$1) => {
+	const response = rawEvent.response;
+	const events$1 = new Array();
+	closeAllOpenBlocks(state$1, events$1);
+	const anthropic = translateResponsesResultToAnthropic(response);
+	events$1.push({
+		type: "message_delta",
+		delta: {
+			stop_reason: anthropic.stop_reason,
+			stop_sequence: anthropic.stop_sequence
+		},
+		usage: anthropic.usage
+	}, { type: "message_stop" });
+	state$1.messageCompleted = true;
+	return events$1;
+};
+const handleResponseFailed = (rawEvent, state$1) => {
+	const response = rawEvent.response;
+	const events$1 = new Array();
+	closeAllOpenBlocks(state$1, events$1);
+	const message = response.error?.message ?? "The response failed due to an unknown error.";
+	events$1.push(buildErrorEvent(message));
+	state$1.messageCompleted = true;
+	return events$1;
+};
+const handleErrorEvent = (rawEvent, state$1) => {
+	const message = typeof rawEvent.message === "string" ? rawEvent.message : "An unexpected error occurred during streaming.";
+	state$1.messageCompleted = true;
+	return [buildErrorEvent(message)];
+};
+const handleFunctionCallArgumentsValidationError = (error, state$1, events$1 = []) => {
+	const reason = error.message;
+	closeAllOpenBlocks(state$1, events$1);
+	state$1.messageCompleted = true;
+	events$1.push(buildErrorEvent(reason));
+	return events$1;
+};
+const messageStart = (state$1, response) => {
+	state$1.messageStartSent = true;
+	const inputCachedTokens = response.usage?.input_tokens_details?.cached_tokens;
+	const inputTokens = (response.usage?.input_tokens ?? 0) - (inputCachedTokens ?? 0);
+	return [{
+		type: "message_start",
+		message: {
+			id: response.id,
+			type: "message",
+			role: "assistant",
+			content: [],
+			model: response.model,
+			stop_reason: null,
+			stop_sequence: null,
+			usage: {
+				input_tokens: inputTokens,
+				output_tokens: 0,
+				cache_read_input_tokens: inputCachedTokens ?? 0
+			}
+		}
+	}];
+};
+const openTextBlockIfNeeded = (state$1, params) => {
+	const { outputIndex, contentIndex, events: events$1 } = params;
+	const key = getBlockKey(outputIndex, contentIndex);
+	let blockIndex = state$1.blockIndexByKey.get(key);
+	if (blockIndex === void 0) {
+		blockIndex = state$1.nextContentBlockIndex;
+		state$1.nextContentBlockIndex += 1;
+		state$1.blockIndexByKey.set(key, blockIndex);
+	}
+	if (!state$1.openBlocks.has(blockIndex)) {
+		closeOpenBlocks(state$1, events$1);
+		events$1.push({
+			type: "content_block_start",
+			index: blockIndex,
+			content_block: {
+				type: "text",
+				text: ""
+			}
+		});
+		state$1.openBlocks.add(blockIndex);
+	}
+	return blockIndex;
+};
+const openThinkingBlockIfNeeded = (state$1, outputIndex, events$1) => {
+	const key = getBlockKey(outputIndex, 0);
+	let blockIndex = state$1.blockIndexByKey.get(key);
+	if (blockIndex === void 0) {
+		blockIndex = state$1.nextContentBlockIndex;
+		state$1.nextContentBlockIndex += 1;
+		state$1.blockIndexByKey.set(key, blockIndex);
+	}
+	if (!state$1.openBlocks.has(blockIndex)) {
+		closeOpenBlocks(state$1, events$1);
+		events$1.push({
+			type: "content_block_start",
+			index: blockIndex,
+			content_block: {
+				type: "thinking",
+				thinking: ""
+			}
+		});
+		state$1.openBlocks.add(blockIndex);
+	}
+	return blockIndex;
+};
+const closeBlockIfOpen = (state$1, blockIndex, events$1) => {
+	if (!state$1.openBlocks.has(blockIndex)) return;
+	events$1.push({
+		type: "content_block_stop",
+		index: blockIndex
+	});
+	state$1.openBlocks.delete(blockIndex);
+	state$1.blockHasDelta.delete(blockIndex);
+};
+const closeOpenBlocks = (state$1, events$1) => {
+	for (const blockIndex of state$1.openBlocks) closeBlockIfOpen(state$1, blockIndex, events$1);
+};
+const closeAllOpenBlocks = (state$1, events$1) => {
+	closeOpenBlocks(state$1, events$1);
+	state$1.functionCallStateByOutputIndex.clear();
+};
+const buildErrorEvent = (message) => ({
+	type: "error",
+	error: {
+		type: "api_error",
+		message
+	}
+});
+const getBlockKey = (outputIndex, contentIndex) => `${outputIndex}:${contentIndex}`;
+const openFunctionCallBlock = (state$1, params) => {
+	const { outputIndex, toolCallId, name, events: events$1 } = params;
+	let functionCallState = state$1.functionCallStateByOutputIndex.get(outputIndex);
+	if (!functionCallState) {
+		const blockIndex$1 = state$1.nextContentBlockIndex;
+		state$1.nextContentBlockIndex += 1;
+		const resolvedToolCallId = toolCallId ?? `tool_call_${blockIndex$1}`;
+		functionCallState = {
+			blockIndex: blockIndex$1,
+			toolCallId: resolvedToolCallId,
+			name: name ?? "function",
+			consecutiveWhitespaceCount: 0
+		};
+		state$1.functionCallStateByOutputIndex.set(outputIndex, functionCallState);
+	}
+	const { blockIndex } = functionCallState;
+	if (!state$1.openBlocks.has(blockIndex)) {
+		closeOpenBlocks(state$1, events$1);
+		events$1.push({
+			type: "content_block_start",
+			index: blockIndex,
+			content_block: {
+				type: "tool_use",
+				id: functionCallState.toolCallId,
+				name: functionCallState.name,
+				input: {}
+			}
+		});
+		state$1.openBlocks.add(blockIndex);
+	}
+	return blockIndex;
+};
+const extractFunctionCallDetails = (rawEvent) => {
+	const item = rawEvent.item;
+	if (item.type !== "function_call") return;
+	const outputIndex = rawEvent.output_index;
+	const toolCallId = item.call_id;
+	const name = item.name;
+	const initialArguments = item.arguments;
+	return {
+		outputIndex,
+		toolCallId,
+		name,
+		initialArguments
+	};
+};
+
+//#endregion
+//#region src/routes/responses/utils.ts
+const getResponsesRequestOptions = (payload) => {
+	const vision = hasVisionInput(payload);
+	const initiator = hasAgentInitiator(payload) ? "agent" : "user";
+	return {
+		vision,
+		initiator
+	};
+};
+const hasAgentInitiator = (payload) => {
+	const lastItem = getPayloadItems(payload).at(-1);
+	if (!lastItem) return false;
+	if (!("role" in lastItem) || !lastItem.role) return true;
+	return (typeof lastItem.role === "string" ? lastItem.role.toLowerCase() : "") === "assistant";
+};
+const hasVisionInput = (payload) => {
+	return getPayloadItems(payload).some((item) => containsVisionContent(item));
+};
+const getPayloadItems = (payload) => {
+	const result = [];
+	const { input } = payload;
+	if (Array.isArray(input)) result.push(...input);
+	return result;
+};
+const containsVisionContent = (value) => {
+	if (!value) return false;
+	if (Array.isArray(value)) return value.some((entry) => containsVisionContent(entry));
+	if (typeof value !== "object") return false;
+	const record = value;
+	if ((typeof record.type === "string" ? record.type.toLowerCase() : void 0) === "input_image") return true;
+	if (Array.isArray(record.content)) return record.content.some((entry) => containsVisionContent(entry));
+	return false;
+};
+
+//#endregion
+//#region src/services/copilot/create-messages.ts
+const createMessages = async (payload, anthropicBetaHeader) => {
+	if (!state.copilotToken) throw new Error("Copilot token not found");
+	const enableVision = payload.messages.some((message) => Array.isArray(message.content) && message.content.some((block) => block.type === "image"));
+	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 headers = {
+		...copilotHeaders(state, enableVision),
+		"X-Initiator": isInitiateRequest ? "user" : "agent"
+	};
+	if (anthropicBetaHeader) headers["anthropic-beta"] = anthropicBetaHeader;
+	else if (payload.thinking?.budget_tokens) headers["anthropic-beta"] = "interleaved-thinking-2025-05-14";
+	const response = await fetch(`${copilotBaseUrl(state)}/v1/messages`, {
+		method: "POST",
+		headers,
+		body: JSON.stringify(payload)
+	});
+	if (!response.ok) {
+		consola.error("Failed to create messages", response);
+		throw new HTTPError("Failed to create messages", response);
+	}
+	if (payload.stream) return events(response);
+	return await response.json();
+};
+
+//#endregion
+//#region src/routes/messages/stream-translation.ts
+function isToolBlockOpen(state$1) {
+	if (!state$1.contentBlockOpen) return false;
+	return Object.values(state$1.toolCalls).some((tc) => tc.anthropicBlockIndex === state$1.contentBlockIndex);
+}
+function translateChunkToAnthropicEvents(chunk, state$1) {
+	const events$1 = [];
+	if (chunk.choices.length === 0) return events$1;
+	const choice = chunk.choices[0];
+	const { delta } = choice;
+	handleMessageStart(state$1, events$1, chunk);
+	handleThinkingText(delta, state$1, events$1);
+	handleContent(delta, state$1, events$1);
+	handleToolCalls(delta, state$1, events$1);
+	handleFinish(choice, state$1, {
+		events: events$1,
+		chunk
+	});
+	return events$1;
+}
+function handleFinish(choice, state$1, context) {
+	const { events: events$1, chunk } = context;
+	if (choice.finish_reason && choice.finish_reason.length > 0) {
+		if (state$1.contentBlockOpen) {
+			const toolBlockOpen = isToolBlockOpen(state$1);
+			context.events.push({
+				type: "content_block_stop",
+				index: state$1.contentBlockIndex
+			});
+			state$1.contentBlockOpen = false;
+			state$1.contentBlockIndex++;
+			if (!toolBlockOpen) handleReasoningOpaque(choice.delta, events$1, state$1);
+		}
+		events$1.push({
+			type: "message_delta",
+			delta: {
+				stop_reason: mapOpenAIStopReasonToAnthropic(choice.finish_reason),
+				stop_sequence: null
+			},
+			usage: {
+				input_tokens: (chunk.usage?.prompt_tokens ?? 0) - (chunk.usage?.prompt_tokens_details?.cached_tokens ?? 0),
+				output_tokens: chunk.usage?.completion_tokens ?? 0,
+				...chunk.usage?.prompt_tokens_details?.cached_tokens !== void 0 && { cache_read_input_tokens: chunk.usage.prompt_tokens_details.cached_tokens }
+			}
+		}, { type: "message_stop" });
+	}
+}
+function handleToolCalls(delta, state$1, events$1) {
+	if (delta.tool_calls && delta.tool_calls.length > 0) {
+		closeThinkingBlockIfOpen(state$1, events$1);
+		handleReasoningOpaqueInToolCalls(state$1, events$1, delta);
+		for (const toolCall of delta.tool_calls) {
+			if (toolCall.id && toolCall.function?.name) {
+				if (state$1.contentBlockOpen) {
+					events$1.push({
+						type: "content_block_stop",
+						index: state$1.contentBlockIndex
+					});
+					state$1.contentBlockIndex++;
+					state$1.contentBlockOpen = false;
+				}
+				const anthropicBlockIndex = state$1.contentBlockIndex;
+				state$1.toolCalls[toolCall.index] = {
+					id: toolCall.id,
+					name: toolCall.function.name,
+					anthropicBlockIndex
+				};
+				events$1.push({
+					type: "content_block_start",
+					index: anthropicBlockIndex,
+					content_block: {
+						type: "tool_use",
+						id: toolCall.id,
+						name: toolCall.function.name,
+						input: {}
+					}
+				});
+				state$1.contentBlockOpen = true;
+			}
+			if (toolCall.function?.arguments) {
+				const toolCallInfo = state$1.toolCalls[toolCall.index];
+				if (toolCallInfo) events$1.push({
+					type: "content_block_delta",
+					index: toolCallInfo.anthropicBlockIndex,
+					delta: {
+						type: "input_json_delta",
+						partial_json: toolCall.function.arguments
+					}
+				});
+			}
+		}
+	}
+}
+function handleReasoningOpaqueInToolCalls(state$1, events$1, delta) {
+	if (state$1.contentBlockOpen && !isToolBlockOpen(state$1)) {
+		events$1.push({
+			type: "content_block_stop",
+			index: state$1.contentBlockIndex
+		});
+		state$1.contentBlockIndex++;
+		state$1.contentBlockOpen = false;
+	}
+	handleReasoningOpaque(delta, events$1, state$1);
+}
+function handleContent(delta, state$1, events$1) {
+	if (delta.content && delta.content.length > 0) {
+		closeThinkingBlockIfOpen(state$1, events$1);
+		if (isToolBlockOpen(state$1)) {
+			events$1.push({
+				type: "content_block_stop",
+				index: state$1.contentBlockIndex
+			});
+			state$1.contentBlockIndex++;
+			state$1.contentBlockOpen = false;
+		}
+		if (!state$1.contentBlockOpen) {
+			events$1.push({
+				type: "content_block_start",
+				index: state$1.contentBlockIndex,
+				content_block: {
+					type: "text",
+					text: ""
+				}
+			});
+			state$1.contentBlockOpen = true;
+		}
+		events$1.push({
+			type: "content_block_delta",
+			index: state$1.contentBlockIndex,
+			delta: {
+				type: "text_delta",
+				text: delta.content
+			}
+		});
+	}
+	if (delta.content === "" && delta.reasoning_opaque && delta.reasoning_opaque.length > 0 && state$1.thinkingBlockOpen) {
+		events$1.push({
+			type: "content_block_delta",
+			index: state$1.contentBlockIndex,
+			delta: {
+				type: "signature_delta",
+				signature: delta.reasoning_opaque
+			}
+		}, {
+			type: "content_block_stop",
+			index: state$1.contentBlockIndex
+		});
+		state$1.contentBlockIndex++;
+		state$1.thinkingBlockOpen = false;
+	}
+}
+function handleMessageStart(state$1, events$1, chunk) {
+	if (!state$1.messageStartSent) {
+		events$1.push({
+			type: "message_start",
+			message: {
+				id: chunk.id,
+				type: "message",
+				role: "assistant",
+				content: [],
+				model: chunk.model,
+				stop_reason: null,
+				stop_sequence: null,
+				usage: {
+					input_tokens: (chunk.usage?.prompt_tokens ?? 0) - (chunk.usage?.prompt_tokens_details?.cached_tokens ?? 0),
+					output_tokens: 0,
+					...chunk.usage?.prompt_tokens_details?.cached_tokens !== void 0 && { cache_read_input_tokens: chunk.usage.prompt_tokens_details.cached_tokens }
+				}
+			}
+		});
+		state$1.messageStartSent = true;
+	}
+}
+function handleReasoningOpaque(delta, events$1, state$1) {
+	if (delta.reasoning_opaque && delta.reasoning_opaque.length > 0) {
+		events$1.push({
+			type: "content_block_start",
+			index: state$1.contentBlockIndex,
+			content_block: {
+				type: "thinking",
+				thinking: ""
+			}
+		}, {
+			type: "content_block_delta",
+			index: state$1.contentBlockIndex,
+			delta: {
+				type: "thinking_delta",
+				thinking: THINKING_TEXT
+			}
+		}, {
+			type: "content_block_delta",
+			index: state$1.contentBlockIndex,
+			delta: {
+				type: "signature_delta",
+				signature: delta.reasoning_opaque
+			}
+		}, {
+			type: "content_block_stop",
+			index: state$1.contentBlockIndex
+		});
+		state$1.contentBlockIndex++;
+	}
+}
+function handleThinkingText(delta, state$1, events$1) {
+	if (delta.reasoning_text && delta.reasoning_text.length > 0) {
+		if (state$1.contentBlockOpen) {
+			delta.content = delta.reasoning_text;
+			delta.reasoning_text = void 0;
+			return;
+		}
+		if (!state$1.thinkingBlockOpen) {
+			events$1.push({
+				type: "content_block_start",
+				index: state$1.contentBlockIndex,
+				content_block: {
+					type: "thinking",
+					thinking: ""
+				}
+			});
+			state$1.thinkingBlockOpen = true;
+		}
+		events$1.push({
+			type: "content_block_delta",
+			index: state$1.contentBlockIndex,
+			delta: {
+				type: "thinking_delta",
+				thinking: delta.reasoning_text
+			}
+		});
+	}
+}
+function closeThinkingBlockIfOpen(state$1, events$1) {
+	if (state$1.thinkingBlockOpen) {
+		events$1.push({
+			type: "content_block_delta",
+			index: state$1.contentBlockIndex,
+			delta: {
+				type: "signature_delta",
+				signature: ""
+			}
+		}, {
+			type: "content_block_stop",
+			index: state$1.contentBlockIndex
+		});
+		state$1.contentBlockIndex++;
+		state$1.thinkingBlockOpen = false;
+	}
+}
+
+//#endregion
+//#region src/routes/messages/handler.ts
+const logger$2 = createHandlerLogger("messages-handler");
+const compactSystemPromptStart = "You are a helpful AI assistant tasked with summarizing conversations";
+async function handleCompletion(c) {
+	await checkRateLimit(state);
+	const anthropicPayload = await c.req.json();
+	logger$2.debug("Anthropic request payload:", JSON.stringify(anthropicPayload));
+	const isCompact = isCompactRequest(anthropicPayload);
+	const anthropicBeta = c.req.header("anthropic-beta");
+	logger$2.debug("Anthropic Beta header:", anthropicBeta);
+	const noTools = !anthropicPayload.tools || anthropicPayload.tools.length === 0;
+	if (anthropicBeta && noTools && !isCompact) anthropicPayload.model = getSmallModel();
+	if (isCompact) {
+		logger$2.debug("Is compact request:", isCompact);
+		if (shouldCompactUseSmallModel()) anthropicPayload.model = getSmallModel();
+	} else mergeToolResultForClaude(anthropicPayload);
+	if (state.manualApprove) await awaitApproval();
+	if (shouldUseMessagesApi(anthropicPayload.model)) return await handleWithMessagesApi(c, anthropicPayload, anthropicBeta);
+	if (shouldUseResponsesApi(anthropicPayload.model)) return await handleWithResponsesApi(c, anthropicPayload);
+	return await handleWithChatCompletions(c, anthropicPayload);
+}
+const RESPONSES_ENDPOINT$1 = "/responses";
+const MESSAGES_ENDPOINT = "/v1/messages";
+const handleWithChatCompletions = async (c, anthropicPayload) => {
+	const openAIPayload = translateToOpenAI(anthropicPayload);
+	logger$2.debug("Translated OpenAI request payload:", JSON.stringify(openAIPayload));
+	const response = await createChatCompletions(openAIPayload);
+	if (isNonStreaming(response)) {
+		logger$2.debug("Non-streaming response from Copilot:", JSON.stringify(response));
+		const anthropicResponse = translateToAnthropic(response);
+		logger$2.debug("Translated Anthropic response:", JSON.stringify(anthropicResponse));
+		return c.json(anthropicResponse);
+	}
+	logger$2.debug("Streaming response from Copilot");
+	return streamSSE(c, async (stream) => {
+		const streamState = {
+			messageStartSent: false,
+			contentBlockIndex: 0,
+			contentBlockOpen: false,
+			toolCalls: {},
+			thinkingBlockOpen: false
+		};
+		for await (const rawEvent of response) {
+			logger$2.debug("Copilot raw stream event:", JSON.stringify(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$2.debug("Translated Anthropic event:", JSON.stringify(event));
+				await stream.writeSSE({
+					event: event.type,
+					data: JSON.stringify(event)
+				});
+			}
+		}
+	});
+};
+const handleWithResponsesApi = async (c, anthropicPayload) => {
+	const responsesPayload = translateAnthropicMessagesToResponsesPayload(anthropicPayload);
+	logger$2.debug("Translated Responses payload:", JSON.stringify(responsesPayload));
+	const { vision, initiator } = getResponsesRequestOptions(responsesPayload);
+	const response = await createResponses(responsesPayload, {
+		vision,
+		initiator
+	});
+	if (responsesPayload.stream && isAsyncIterable$1(response)) {
+		logger$2.debug("Streaming response from Copilot (Responses API)");
+		return streamSSE(c, async (stream) => {
+			const streamState = createResponsesStreamState();
+			for await (const chunk of response) {
+				if (chunk.event === "ping") {
+					await stream.writeSSE({
+						event: "ping",
+						data: ""
+					});
+					continue;
+				}
+				const data = chunk.data;
+				if (!data) continue;
+				logger$2.debug("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$2.debug("Translated Anthropic event:", eventData);
+					await stream.writeSSE({
+						event: event.type,
+						data: eventData
+					});
+				}
+				if (streamState.messageCompleted) {
+					logger$2.debug("Message completed, ending stream");
+					break;
+				}
+			}
+			if (!streamState.messageCompleted) {
+				logger$2.warn("Responses stream ended without completion; sending error event");
+				const errorEvent = buildErrorEvent("Responses stream ended without completion");
+				await stream.writeSSE({
+					event: errorEvent.type,
+					data: JSON.stringify(errorEvent)
+				});
+			}
+		});
+	}
+	logger$2.debug("Non-streaming Responses result:", JSON.stringify(response).slice(-400));
+	const anthropicResponse = translateResponsesResultToAnthropic(response);
+	logger$2.debug("Translated Anthropic response:", JSON.stringify(anthropicResponse));
+	return c.json(anthropicResponse);
+};
+const handleWithMessagesApi = async (c, anthropicPayload, anthropicBetaHeader) => {
+	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 response = await createMessages(anthropicPayload, anthropicBetaHeader);
+	if (isAsyncIterable$1(response)) {
+		logger$2.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$2.debug("Messages raw stream event:", data);
+				await stream.writeSSE({
+					event: eventName,
+					data
+				});
+			}
+		});
+	}
+	logger$2.debug("Non-streaming Messages result:", JSON.stringify(response).slice(-400));
+	return c.json(response);
+};
+const shouldUseResponsesApi = (modelId) => {
+	return (state.models?.data.find((model) => model.id === modelId))?.supported_endpoints?.includes(RESPONSES_ENDPOINT$1) ?? false;
+};
+const shouldUseMessagesApi = (modelId) => {
+	return (state.models?.data.find((model) => model.id === modelId))?.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 isCompactRequest = (anthropicPayload) => {
+	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 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 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/route.ts
+const messageRoutes = new Hono();
+messageRoutes.post("/", async (c) => {
+	try {
+		return await handleCompletion(c);
+	} catch (error) {
+		return await forwardError(c, error);
+	}
+});
+messageRoutes.post("/count_tokens", async (c) => {
+	try {
+		return await handleCountTokens(c);
+	} catch (error) {
+		return await forwardError(c, error);
+	}
+});
+
+//#endregion
+//#region src/routes/models/route.ts
+const modelRoutes = new Hono();
+modelRoutes.get("/", async (c) => {
+	try {
+		if (!state.models) await cacheModels();
+		const models = state.models?.data.map((model) => ({
+			id: model.id,
+			object: "model",
+			type: "model",
+			created: 0,
+			created_at: (/* @__PURE__ */ new Date(0)).toISOString(),
+			owned_by: model.vendor,
+			display_name: model.name
+		}));
+		return c.json({
+			object: "list",
+			data: models,
+			has_more: false
+		});
+	} catch (error) {
+		return await forwardError(c, error);
+	}
+});
+
+//#endregion
+//#region src/routes/responses/stream-id-sync.ts
+const createStreamIdTracker = () => ({ outputItems: /* @__PURE__ */ new Map() });
+const fixStreamIds = (data, event, tracker) => {
+	if (!data) return data;
+	const parsed = JSON.parse(data);
+	switch (event) {
+		case "response.output_item.added": return handleOutputItemAdded(parsed, tracker);
+		case "response.output_item.done": return handleOutputItemDone(parsed, tracker);
+		default: return handleItemId(parsed, tracker);
+	}
+};
+const handleOutputItemAdded = (parsed, tracker) => {
+	if (!parsed.item.id) {
+		let randomSuffix = "";
+		while (randomSuffix.length < 16) randomSuffix += Math.random().toString(36).slice(2);
+		parsed.item.id = `oi_${parsed.output_index}_${randomSuffix.slice(0, 16)}`;
+	}
+	const outputIndex = parsed.output_index;
+	tracker.outputItems.set(outputIndex, parsed.item.id);
+	return JSON.stringify(parsed);
+};
+const handleOutputItemDone = (parsed, tracker) => {
+	const outputIndex = parsed.output_index;
+	const originalId = tracker.outputItems.get(outputIndex);
+	if (originalId) parsed.item.id = originalId;
+	return JSON.stringify(parsed);
+};
+const handleItemId = (parsed, tracker) => {
+	const outputIndex = parsed.output_index;
+	if (outputIndex !== void 0) {
+		const itemId = tracker.outputItems.get(outputIndex);
+		if (itemId) parsed.item_id = itemId;
+	}
+	return JSON.stringify(parsed);
+};
+
+//#endregion
+//#region src/routes/responses/handler.ts
+const logger$1 = createHandlerLogger("responses-handler");
+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));
+	useFunctionApplyPatch(payload);
+	removeWebSearchTool(payload);
+	if (!((state.models?.data.find((model) => model.id === payload.model))?.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);
+	const { vision, initiator } = getResponsesRequestOptions(payload);
+	if (state.manualApprove) await awaitApproval();
+	const response = await createResponses(payload, {
+		vision,
+		initiator
+	});
+	if (isStreamingRequested(payload) && isAsyncIterable(response)) {
+		logger$1.debug("Forwarding native Responses stream");
+		return streamSSE(c, async (stream) => {
+			const idTracker = createStreamIdTracker();
+			for await (const chunk of response) {
+				logger$1.debug("Responses stream chunk:", JSON.stringify(chunk));
+				const processedData = fixStreamIds(chunk.data ?? "", chunk.event, idTracker);
+				await stream.writeSSE({
+					id: chunk.id,
+					event: chunk.event,
+					data: processedData
+				});
+			}
+		});
+	}
+	logger$1.debug("Forwarding native Responses result:", JSON.stringify(response).slice(-400));
+	return c.json(response);
+};
+const isAsyncIterable = (value) => Boolean(value) && typeof value[Symbol.asyncIterator] === "function";
+const isStreamingRequested = (payload) => Boolean(payload.stream);
+const useFunctionApplyPatch = (payload) => {
+	if (getConfig().useFunctionApplyPatch ?? true) {
+		logger$1.debug("Using function tool apply_patch for responses");
+		if (Array.isArray(payload.tools)) {
+			const toolsArr = payload.tools;
+			for (let i = 0; i < toolsArr.length; i++) {
+				const t = toolsArr[i];
+				if (t.type === "custom" && t.name === "apply_patch") toolsArr[i] = {
+					type: "function",
+					name: t.name,
+					description: "Use the `apply_patch` tool to edit files",
+					parameters: {
+						type: "object",
+						properties: { input: {
+							type: "string",
+							description: "The entire contents of the apply_patch command"
+						} },
+						required: ["input"]
+					},
+					strict: false
+				};
+			}
+		}
+	}
+};
+const removeWebSearchTool = (payload) => {
+	if (!Array.isArray(payload.tools) || payload.tools.length === 0) return;
+	payload.tools = payload.tools.filter((t) => {
+		return t.type !== "web_search";
+	});
+};
+
+//#endregion
+//#region src/routes/responses/route.ts
+const responsesRoutes = new Hono();
+responsesRoutes.post("/", async (c) => {
+	try {
+		return await handleResponses(c);
+	} catch (error) {
+		return await forwardError(c, error);
+	}
+});
+
+//#endregion
+//#region src/routes/token/route.ts
+const tokenRoute = new Hono();
+tokenRoute.get("/", (c) => {
+	try {
+		return c.json({ token: state.copilotToken });
+	} catch (error) {
+		console.error("Error fetching token:", error);
+		return c.json({
+			error: "Failed to fetch token",
+			token: null
+		}, 500);
+	}
+});
+
+//#endregion
+//#region src/routes/usage/route.ts
+const usageRoute = new Hono();
+usageRoute.get("/", async (c) => {
+	try {
+		const usage = await getCopilotUsage();
+		return c.json(usage);
+	} catch (error) {
+		console.error("Error fetching Copilot usage:", error);
+		return c.json({ error: "Failed to fetch Copilot usage" }, 500);
+	}
+});
+
+//#endregion
+//#region src/server.ts
+const server = new Hono();
+server.use(logger());
+server.use(cors());
+server.get("/", (c) => c.text("Server running"));
+server.route("/chat/completions", completionRoutes);
+server.route("/models", modelRoutes);
+server.route("/embeddings", embeddingRoutes);
+server.route("/usage", usageRoute);
+server.route("/token", tokenRoute);
+server.route("/responses", responsesRoutes);
+server.route("/v1/chat/completions", completionRoutes);
+server.route("/v1/models", modelRoutes);
+server.route("/v1/embeddings", embeddingRoutes);
+server.route("/v1/responses", responsesRoutes);
+server.route("/v1/messages", messageRoutes);
+
+//#endregion
+export { server };
+//# sourceMappingURL=server-IY-mTdPh.js.map