@ashsec/copilot-api 0.7.13 → 0.8.0

package/dist/main.js

@@ -9,6 +9,7 @@ import { events } from "fetch-event-stream";
 import clipboard from "clipboardy";
 import { serve } from "srvx";
 import invariant from "tiny-invariant";
+import fs$1 from "node:fs";
 import { getProxyForUrl } from "proxy-from-env";
 import { Agent, ProxyAgent, setGlobalDispatcher } from "undici";
 import { execSync } from "node:child_process";
@@ -16,84 +17,10 @@ import process$1 from "node:process";
 import { Hono } from "hono";
 import { cors } from "hono/cors";
 import { streamSSE } from "hono/streaming";
+import util from "node:util";
 
 //#region package.json
-var name = "@ashsec/copilot-api";
-var version = "0.7.13";
-var description = "Turn GitHub Copilot into OpenAI/Anthropic API compatible server. Usable with Claude Code!";
-var keywords = [
-	"proxy",
-	"github-copilot",
-	"openai-compatible"
-];
-var homepage = "https://github.com/ericc-ch/copilot-api";
-var bugs = "https://github.com/ericc-ch/copilot-api/issues";
-var repository = {
-	"type": "git",
-	"url": "git+https://github.com/ericc-ch/copilot-api.git"
-};
-var author = "Erick Christian <erickchristian48@gmail.com>";
-var type = "module";
-var bin = { "copilot-api": "./dist/main.js" };
-var files = ["dist"];
-var scripts = {
-	"build": "tsdown",
-	"dev": "bun run --watch ./src/main.ts",
-	"knip": "knip-bun",
-	"lint": "eslint --cache",
-	"lint:all": "eslint --cache .",
-	"prepack": "bun run build",
-	"prepare": "simple-git-hooks",
-	"release": "bumpp && bun publish --access public",
-	"start": "NODE_ENV=production bun run ./src/main.ts",
-	"typecheck": "tsc"
-};
-var simple_git_hooks = { "pre-commit": "bunx lint-staged" };
-var lint_staged = { "*": "bun run lint --fix" };
-var dependencies = {
-	"citty": "^0.1.6",
-	"clipboardy": "^5.0.0",
-	"consola": "^3.4.2",
-	"fetch-event-stream": "^0.1.5",
-	"gpt-tokenizer": "^3.0.1",
-	"hono": "^4.9.9",
-	"proxy-from-env": "^1.1.0",
-	"srvx": "^0.8.9",
-	"tiny-invariant": "^1.3.3",
-	"undici": "^7.16.0",
-	"zod": "^4.1.11"
-};
-var devDependencies = {
-	"@echristian/eslint-config": "^0.0.54",
-	"@types/bun": "^1.2.23",
-	"@types/proxy-from-env": "^1.0.4",
-	"bumpp": "^10.2.3",
-	"eslint": "^9.37.0",
-	"knip": "^5.64.1",
-	"lint-staged": "^16.2.3",
-	"prettier-plugin-packagejson": "^2.5.19",
-	"simple-git-hooks": "^2.13.1",
-	"tsdown": "^0.15.6",
-	"typescript": "^5.9.3"
-};
-var package_default = {
-	name,
-	version,
-	description,
-	keywords,
-	homepage,
-	bugs,
-	repository,
-	author,
-	type,
-	bin,
-	files,
-	scripts,
-	"simple-git-hooks": simple_git_hooks,
-	"lint-staged": lint_staged,
-	dependencies,
-	devDependencies
-};
+var version = "0.8.0";
 
 //#endregion
 //#region src/lib/paths.ts
@@ -103,6 +30,7 @@ const AZURE_OPENAI_CONFIG_PATH = path.join(APP_DIR, "azure_openai_config");
 const REPLACEMENTS_CONFIG_PATH = path.join(APP_DIR, "replacements.json");
 const PATHS = {
 	APP_DIR,
+	CONFIG_PATH: path.join(APP_DIR, "config.json"),
 	GITHUB_TOKEN_PATH,
 	AZURE_OPENAI_CONFIG_PATH,
 	REPLACEMENTS_CONFIG_PATH
@@ -128,7 +56,8 @@ const state = {
 	manualApprove: false,
 	rateLimitWait: false,
 	showToken: false,
-	debug: false
+	debug: false,
+	verbose: false
 };
 
 //#endregion
@@ -137,10 +66,10 @@ const standardHeaders = () => ({
 	"content-type": "application/json",
 	accept: "application/json"
 });
-const COPILOT_VERSION = "0.26.7";
+const COPILOT_VERSION = "0.37.6";
 const EDITOR_PLUGIN_VERSION = `copilot-chat/${COPILOT_VERSION}`;
 const USER_AGENT = `GitHubCopilotChat/${COPILOT_VERSION}`;
-const API_VERSION = "2025-04-01";
+const API_VERSION = "2025-10-01";
 const copilotBaseUrl = (state$1) => state$1.accountType === "individual" ? "https://api.githubcopilot.com" : `https://api.${state$1.accountType}.githubcopilot.com`;
 const copilotHeaders = (state$1, vision = false) => {
 	const headers = {
@@ -150,7 +79,7 @@ const copilotHeaders = (state$1, vision = false) => {
 		"editor-version": `vscode/${state$1.vsCodeVersion}`,
 		"editor-plugin-version": EDITOR_PLUGIN_VERSION,
 		"user-agent": USER_AGENT,
-		"openai-intent": "conversation-panel",
+		"openai-intent": "conversation-agent",
 		"x-github-api-version": API_VERSION,
 		"x-request-id": randomUUID(),
 		"x-vscode-user-agent-library-version": "electron-fetch"
@@ -654,13 +583,13 @@ const checkUsage = defineCommand({
 			const premiumUsed = premiumTotal - premium.remaining;
 			const premiumPercentUsed = premiumTotal > 0 ? premiumUsed / premiumTotal * 100 : 0;
 			const premiumPercentRemaining = premium.percent_remaining;
-			function summarizeQuota(name$1, snap) {
-				if (!snap) return `${name$1}: N/A`;
+			function summarizeQuota(name, snap) {
+				if (!snap) return `${name}: N/A`;
 				const total = snap.entitlement;
 				const used = total - snap.remaining;
 				const percentUsed = total > 0 ? used / total * 100 : 0;
 				const percentRemaining = snap.percent_remaining;
-				return `${name$1}: ${used}/${total} used (${percentUsed.toFixed(1)}% used, ${percentRemaining.toFixed(1)}% remaining)`;
+				return `${name}: ${used}/${total} used (${percentUsed.toFixed(1)}% used, ${percentRemaining.toFixed(1)}% remaining)`;
 			}
 			const premiumLine = `Premium: ${premiumUsed}/${premiumTotal} used (${premiumPercentUsed.toFixed(1)}% used, ${premiumPercentRemaining.toFixed(1)}% remaining)`;
 			const chatLine = summarizeQuota("Chat", usage.quota_snapshots.chat);
@@ -736,11 +665,11 @@ async function getUserReplacements() {
 * Add a new user replacement rule
 */
 async function addReplacement(pattern, replacement, options) {
-	const { isRegex = false, name: name$1 } = options ?? {};
+	const { isRegex = false, name } = options ?? {};
 	await ensureLoaded();
 	const rule = {
 		id: `user-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`,
-		name: name$1,
+		name,
 		pattern,
 		replacement,
 		isRegex,
@@ -891,11 +820,11 @@ async function applyReplacementsToPayload(payload) {
 //#region src/config.ts
 function formatRule(rule, index) {
 	const status = rule.enabled ? "✓" : "✗";
-	const type$1 = rule.isRegex ? "regex" : "string";
+	const type = rule.isRegex ? "regex" : "string";
 	const system = rule.isSystem ? " [system]" : "";
-	const name$1 = rule.name ? ` "${rule.name}"` : "";
+	const name = rule.name ? ` "${rule.name}"` : "";
 	const replacement = rule.replacement || "(empty)";
-	return `${index + 1}. [${status}] (${type$1})${system}${name$1} "${rule.pattern}" → "${replacement}"`;
+	return `${index + 1}. [${status}] (${type})${system}${name} "${rule.pattern}" → "${replacement}"`;
 }
 async function listReplacements() {
 	const all = await getAllReplacements();
@@ -908,11 +837,11 @@ async function listReplacements() {
 	console.log();
 }
 async function addNewReplacement() {
-	const name$1 = await consola.prompt("Name (optional, short description):", {
+	const name = await consola.prompt("Name (optional, short description):", {
 		type: "text",
 		default: ""
 	});
-	if (typeof name$1 === "symbol") {
+	if (typeof name === "symbol") {
 		consola.info("Cancelled.");
 		return;
 	}
@@ -949,7 +878,7 @@ async function addNewReplacement() {
 		consola.info("Cancelled.");
 		return;
 	}
-	const rule = await addReplacement(pattern, replacement, matchType === "regex", name$1 || void 0);
+	const rule = await addReplacement(pattern, replacement, matchType === "regex", name || void 0);
 	consola.success(`Added rule: ${rule.name || rule.id}`);
 }
 async function editExistingReplacement() {
@@ -977,11 +906,11 @@ async function editExistingReplacement() {
 	}
 	consola.info(`\nEditing rule: ${rule.name || rule.id}`);
 	consola.info("Press Enter to keep current value.\n");
-	const name$1 = await consola.prompt("Name:", {
+	const name = await consola.prompt("Name:", {
 		type: "text",
 		default: rule.name || ""
 	});
-	if (typeof name$1 === "symbol") {
+	if (typeof name === "symbol") {
 		consola.info("Cancelled.");
 		return;
 	}
@@ -1023,7 +952,7 @@ async function editExistingReplacement() {
 		return;
 	}
 	const updated = await updateReplacement(selected, {
-		name: name$1 || void 0,
+		name: name || void 0,
 		pattern,
 		replacement,
 		isRegex: matchType === "regex"
@@ -1254,6 +1183,118 @@ const debug = defineCommand({
 	}
 });
 
+//#endregion
+//#region src/lib/config.ts
+const gpt5ExplorationPrompt = `## Exploration and reading files
+- **Think first.** Before any tool call, decide ALL files/resources you will need.
+- **Batch everything.** If you need multiple files (even from different places), read them together.
+- **multi_tool_use.parallel** Use multi_tool_use.parallel to parallelize tool calls and only this.
+- **Only make sequential calls if you truly cannot know the next file without seeing a result first.**
+- **Workflow:** (a) plan all needed reads → (b) issue one parallel batch → (c) analyze results → (d) repeat if new, unpredictable reads arise.`;
+const gpt5CommentaryPrompt = `# Working with the user
+
+You interact with the user through a terminal. You have 2 ways of communicating with the users:
+- Share intermediary updates in \`commentary\` channel.
+- After you have completed all your work, send a message to the \`final\` channel.
+
+## Intermediary updates
+
+- Intermediary updates go to the \`commentary\` channel.
+- User updates are short updates while you are working, they are NOT final answers.
+- You use 1-2 sentence user updates to communicate progress and new information to the user as you are doing work.
+- Do not begin responses with conversational interjections or meta commentary. Avoid openers such as acknowledgements ("Done —", "Got it", "Great question, ") or framing phrases.
+- You provide user updates frequently, every 20s.
+- Before exploring or doing substantial work, you start with a user update acknowledging the request and explaining your first step. You should include your understanding of the user request and explain what you will do. Avoid commenting on the request or using starters such as "Got it -" or "Understood -" etc.
+- When exploring, e.g. searching, reading files, you provide user updates as you go, every 20s, explaining what context you are gathering and what you've learned. Vary your sentence structure when providing these updates to avoid sounding repetitive - in particular, don't start each sentence the same way.
+- After you have sufficient context, and the work is substantial, you provide a longer plan (this is the only user update that may be longer than 2 sentences and can contain formatting).
+- Before performing file edits of any kind, you provide updates explaining what edits you are making.
+- As you are thinking, you very frequently provide updates even if not taking any actions, informing the user of your progress. You interrupt your thinking and send multiple updates in a row if thinking for more than 100 words.
+- Tone of your updates MUST match your personality.`;
+const defaultConfig = {
+	auth: { apiKeys: [] },
+	extraPrompts: {
+		"gpt-5-mini": gpt5ExplorationPrompt,
+		"gpt-5.1-codex-max": gpt5ExplorationPrompt,
+		"gpt-5.3-codex": gpt5CommentaryPrompt
+	},
+	smallModel: "gpt-5-mini",
+	modelReasoningEfforts: { "gpt-5-mini": "low" },
+	useFunctionApplyPatch: true,
+	compactUseSmallModel: true
+};
+let cachedConfig = null;
+function ensureConfigFile() {
+	try {
+		fs$1.accessSync(PATHS.CONFIG_PATH, fs$1.constants.R_OK | fs$1.constants.W_OK);
+	} catch {
+		fs$1.mkdirSync(PATHS.APP_DIR, { recursive: true });
+		fs$1.writeFileSync(PATHS.CONFIG_PATH, `${JSON.stringify(defaultConfig, null, 2)}\n`, "utf8");
+		try {
+			fs$1.chmodSync(PATHS.CONFIG_PATH, 384);
+		} catch {
+			return;
+		}
+	}
+}
+function readConfigFromDisk() {
+	ensureConfigFile();
+	try {
+		const raw = fs$1.readFileSync(PATHS.CONFIG_PATH, "utf8");
+		if (!raw.trim()) {
+			fs$1.writeFileSync(PATHS.CONFIG_PATH, `${JSON.stringify(defaultConfig, null, 2)}\n`, "utf8");
+			return defaultConfig;
+		}
+		return JSON.parse(raw);
+	} catch (error) {
+		consola.error("Failed to read config file, using default config", error);
+		return defaultConfig;
+	}
+}
+function mergeDefaultExtraPrompts(config$1) {
+	const extraPrompts = config$1.extraPrompts ?? {};
+	const defaultExtraPrompts = defaultConfig.extraPrompts ?? {};
+	if (Object.keys(defaultExtraPrompts).filter((model) => !Object.hasOwn(extraPrompts, model)).length === 0) return {
+		mergedConfig: config$1,
+		changed: false
+	};
+	return {
+		mergedConfig: {
+			...config$1,
+			extraPrompts: {
+				...defaultExtraPrompts,
+				...extraPrompts
+			}
+		},
+		changed: true
+	};
+}
+function mergeConfigWithDefaults() {
+	const { mergedConfig, changed } = mergeDefaultExtraPrompts(readConfigFromDisk());
+	if (changed) try {
+		fs$1.writeFileSync(PATHS.CONFIG_PATH, `${JSON.stringify(mergedConfig, null, 2)}\n`, "utf8");
+	} catch (writeError) {
+		consola.warn("Failed to write merged extraPrompts to config file", writeError);
+	}
+	cachedConfig = mergedConfig;
+	return mergedConfig;
+}
+function getConfig() {
+	cachedConfig ??= readConfigFromDisk();
+	return cachedConfig;
+}
+function getExtraPromptForModel(model) {
+	return getConfig().extraPrompts?.[model] ?? "";
+}
+function getSmallModel() {
+	return getConfig().smallModel ?? "gpt-5-mini";
+}
+function getReasoningEffortForModel(model) {
+	return getConfig().modelReasoningEfforts?.[model] ?? "high";
+}
+function shouldCompactUseSmallModel() {
+	return getConfig().compactUseSmallModel ?? true;
+}
+
 //#endregion
 //#region src/lib/proxy.ts
 function initProxyFromEnv() {
@@ -1306,8 +1347,7 @@ function getShell() {
 	const { platform, ppid, env } = process$1;
 	if (platform === "win32") {
 		try {
-			const command = `wmic process get ParentProcessId,Name | findstr "${ppid}"`;
-			if (execSync(command, { stdio: "pipe" }).toString().toLowerCase().includes("powershell.exe")) return "powershell";
+			if (execSync(`wmic process get ParentProcessId,Name | findstr "${ppid}"`, { stdio: "pipe" }).toString().toLowerCase().includes("powershell.exe")) return "powershell";
 		} catch {
 			return "cmd";
 		}
@@ -1353,6 +1393,51 @@ function generateEnvScript(envVars, commandToRun = "") {
 	return commandBlock || commandToRun;
 }
 
+//#endregion
+//#region src/lib/request-auth.ts
+function normalizeApiKeys(apiKeys) {
+	if (!Array.isArray(apiKeys)) {
+		if (apiKeys !== void 0) consola.warn("Invalid auth.apiKeys config. Expected an array of strings.");
+		return [];
+	}
+	const normalizedKeys = apiKeys.filter((key) => typeof key === "string").map((key) => key.trim()).filter((key) => key.length > 0);
+	if (normalizedKeys.length !== apiKeys.length) consola.warn("Invalid auth.apiKeys entries found. Only non-empty strings are allowed.");
+	return [...new Set(normalizedKeys)];
+}
+function getConfiguredApiKeys() {
+	return normalizeApiKeys(getConfig().auth?.apiKeys);
+}
+function extractRequestApiKey(c) {
+	const xApiKey = c.req.header("x-api-key")?.trim();
+	if (xApiKey) return xApiKey;
+	const authorization = c.req.header("authorization");
+	if (!authorization) return null;
+	const [scheme, ...rest] = authorization.trim().split(/\s+/);
+	if (scheme.toLowerCase() !== "bearer") return null;
+	return rest.join(" ").trim() || null;
+}
+function createUnauthorizedResponse(c) {
+	c.header("WWW-Authenticate", "Bearer realm=\"copilot-api\"");
+	return c.json({ error: {
+		message: "Unauthorized",
+		type: "authentication_error"
+	} }, 401);
+}
+function createAuthMiddleware(options = {}) {
+	const getApiKeys = options.getApiKeys ?? getConfiguredApiKeys;
+	const allowUnauthenticatedPaths = options.allowUnauthenticatedPaths ?? ["/"];
+	const allowOptionsBypass = options.allowOptionsBypass ?? true;
+	return async (c, next) => {
+		if (allowOptionsBypass && c.req.method === "OPTIONS") return next();
+		if (allowUnauthenticatedPaths.includes(c.req.path)) return next();
+		const apiKeys = getApiKeys();
+		if (apiKeys.length === 0) return next();
+		const requestApiKey = extractRequestApiKey(c);
+		if (!requestApiKey || !apiKeys.includes(requestApiKey)) return createUnauthorizedResponse(c);
+		return next();
+	};
+}
+
 //#endregion
 //#region src/lib/request-logger.ts
 const REQUEST_CONTEXT_KEY = "requestContext";
@@ -1413,8 +1498,7 @@ async function logRawRequest(c) {
 	if (method !== "GET" && method !== "HEAD") try {
 		const body = await c.req.raw.clone().text();
 		if (body) try {
-			const parsed = JSON.parse(body);
-			const sanitized = sanitizeRequestBody(parsed);
+			const sanitized = sanitizeRequestBody(JSON.parse(body));
 			lines.push(`${colors.dim}Body (sanitized):${colors.reset}`, `  ${JSON.stringify(sanitized, null, 2).split("\n").join("\n  ")}`);
 		} catch {
 			lines.push(`${colors.dim}Body:${colors.reset} [${body.length} bytes]`);
@@ -1467,14 +1551,6 @@ async function requestLogger(c, next) {
 	lines.push(`  ${colors.dim}${getTimeString()}${colors.reset}`);
 	console.log(lines.join("\n"));
 }
-/**
-* Log token usage (for streaming responses where tokens are known after stream completes)
-*/
-function logTokenUsage(inputTokens, outputTokens) {
-	const parts = [];
-	parts.push(`  ${colors.gray}Tokens:${colors.reset} ${colors.yellow}${inputTokens.toLocaleString()} in${colors.reset} ${colors.gray}/${colors.reset} ${colors.green}${outputTokens.toLocaleString()} out${colors.reset}`);
-	console.log(parts.join(""));
-}
 
 //#endregion
 //#region src/lib/approval.ts
@@ -1702,8 +1778,7 @@ const numTokensForTools = (tools, encoder, constants) => {
 * 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 encoder = await getEncodeChatFunction(getTokenizerFromModel(model));
 	const simplifiedMessages = payload.messages;
 	const inputMessages = simplifiedMessages.filter((msg) => msg.role !== "assistant");
 	const outputMessages = simplifiedMessages.filter((msg) => msg.role === "assistant");
@@ -1719,13 +1794,17 @@ const getTokenCount = async (payload, model) => {
 
 //#endregion
 //#region src/services/copilot/create-chat-completions.ts
-const createChatCompletions = async (payload) => {
+const createChatCompletions = async (payload, options) => {
 	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"));
-	const isAgentCall = payload.messages.some((msg) => ["assistant", "tool"].includes(msg.role));
+	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"
+		"X-Initiator": options?.initiator ?? (isAgentCall ? "agent" : "user")
 	};
 	const response = await fetchWithRetry(`${copilotBaseUrl(state)}/chat/completions`, {
 		method: "POST",
@@ -1744,8 +1823,7 @@ const createChatCompletions = async (payload) => {
 //#region src/routes/chat-completions/handler.ts
 async function handleCompletion$1(c) {
 	await checkRateLimit(state);
-	const rawPayload = await c.req.json();
-	let payload = await applyReplacementsToPayload(rawPayload);
+	let payload = await applyReplacementsToPayload(await c.req.json());
 	payload = {
 		...payload,
 		model: normalizeModelName(payload.model)
@@ -1759,7 +1837,7 @@ async function handleCompletion$1(c) {
 		});
 		if (state.manualApprove) await awaitApproval();
 		const response$1 = await createAzureOpenAIChatCompletions(state.azureOpenAIConfig, payload);
-		if (isNonStreaming(response$1)) {
+		if (isNonStreaming$1(response$1)) {
 			consola.debug("Non-streaming response:", JSON.stringify(response$1));
 			if (response$1.usage) setRequestContext(c, {
 				inputTokens: response$1.usage.prompt_tokens,
@@ -1788,10 +1866,7 @@ async function handleCompletion$1(c) {
 	});
 	const selectedModel = state.models?.data.find((model) => model.id === payload.model);
 	try {
-		if (selectedModel) {
-			const tokenCount = await getTokenCount(payload, selectedModel);
-			setRequestContext(c, { inputTokens: tokenCount.input });
-		}
+		if (selectedModel) setRequestContext(c, { inputTokens: (await getTokenCount(payload, selectedModel)).input });
 	} catch (error) {
 		consola.warn("Failed to calculate token count:", error);
 	}
@@ -1804,7 +1879,7 @@ async function handleCompletion$1(c) {
 		consola.debug("Set max_tokens to:", JSON.stringify(payload.max_tokens));
 	}
 	const response = await createChatCompletions(payload);
-	if (isNonStreaming(response)) {
+	if (isNonStreaming$1(response)) {
 		consola.debug("Non-streaming response:", JSON.stringify(response));
 		if (response.usage) setRequestContext(c, {
 			inputTokens: response.usage.prompt_tokens,
@@ -1827,7 +1902,7 @@ async function handleCompletion$1(c) {
 		}
 	});
 }
-const isNonStreaming = (response) => Object.hasOwn(response, "choices");
+const isNonStreaming$1 = (response) => Object.hasOwn(response, "choices");
 
 //#endregion
 //#region src/routes/chat-completions/route.ts
@@ -1858,8 +1933,7 @@ const createEmbeddings = async (payload) => {
 const embeddingRoutes = new Hono();
 embeddingRoutes.post("/", async (c) => {
 	try {
-		const paylod = await c.req.json();
-		const response = await createEmbeddings(paylod);
+		const response = await createEmbeddings(await c.req.json());
 		return c.json(response);
 	} catch (error) {
 		return await forwardError(c, error);
@@ -2110,6 +2184,970 @@ async function handleCountTokens(c) {
 	}
 }
 
+//#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$1.existsSync(LOG_DIR)) fs$1.mkdirSync(LOG_DIR, { recursive: true });
+};
+const cleanupOldLogs = () => {
+	if (!fs$1.existsSync(LOG_DIR)) return;
+	const now = Date.now();
+	for (const entry of fs$1.readdirSync(LOG_DIR)) {
+		const filePath = path.join(LOG_DIR, entry);
+		let stats;
+		try {
+			stats = fs$1.statSync(filePath);
+		} catch {
+			continue;
+		}
+		if (!stats.isFile()) continue;
+		if (now - stats.mtimeMs > LOG_RETENTION_MS) try {
+			fs$1.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$1.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);
+		appendLine(filePath, `[${timestamp}] [${logObj.type}] [${logObj.tag || name}]${message ? ` ${message}` : ""}`);
+	} });
+	return instance;
+};
+
+//#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 CODEX_PHASE_MODEL = "gpt-5.3-codex";
+const THINKING_TEXT = "Thinking...";
+const translateAnthropicMessagesToResponsesPayload = (payload) => {
+	const input = [];
+	for (const message of payload.messages) input.push(...translateMessage(message, payload.model));
+	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, model) => {
+	if (message.role === "user") return translateUserMessage(message);
+	return translateAssistantMessage(message, model);
+};
+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(pendingContent, items, { role: "user" });
+			items.push(createFunctionCallOutput(block));
+			continue;
+		}
+		const converted = translateUserContentBlock(block);
+		if (converted) pendingContent.push(converted);
+	}
+	flushPendingContent(pendingContent, items, { role: "user" });
+	return items;
+};
+const translateAssistantMessage = (message, model) => {
+	const assistantPhase = resolveAssistantPhase(model, message.content);
+	if (typeof message.content === "string") return [createMessage("assistant", message.content, assistantPhase)];
+	if (!Array.isArray(message.content)) return [];
+	const items = [];
+	const pendingContent = [];
+	for (const block of message.content) {
+		if (block.type === "tool_use") {
+			flushPendingContent(pendingContent, items, {
+				role: "assistant",
+				phase: assistantPhase
+			});
+			items.push(createFunctionToolCall(block));
+			continue;
+		}
+		if (block.type === "thinking" && block.signature && block.signature.includes("@")) {
+			flushPendingContent(pendingContent, items, {
+				role: "assistant",
+				phase: assistantPhase
+			});
+			items.push(createReasoningContent(block));
+			continue;
+		}
+		const converted = translateAssistantContentBlock(block);
+		if (converted) pendingContent.push(converted);
+	}
+	flushPendingContent(pendingContent, items, {
+		role: "assistant",
+		phase: assistantPhase
+	});
+	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 = (pendingContent, target, message) => {
+	if (pendingContent.length === 0) return;
+	const messageContent = [...pendingContent];
+	target.push(createMessage(message.role, messageContent, message.phase));
+	pendingContent.length = 0;
+};
+const createMessage = (role, content, phase) => ({
+	type: MESSAGE_TYPE,
+	role,
+	content,
+	...role === "assistant" && phase ? { phase } : {}
+});
+const resolveAssistantPhase = (model, content) => {
+	if (!shouldApplyCodexPhase(model)) return;
+	if (typeof content === "string") return "final_answer";
+	if (!Array.isArray(content)) return;
+	if (!content.some((block) => block.type === "text")) return;
+	return content.some((block) => block.type === "tool_use") ? "commentary" : "final_answer";
+};
+const shouldApplyCodexPhase = (model) => model === CODEX_PHASE_MODEL;
+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 ? "" : 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;
+	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;
+	return {
+		input_tokens: inputTokens - (response.usage?.input_tokens_details?.cached_tokens ?? 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_(.+)$/);
+	return {
+		safetyIdentifier,
+		promptCacheKey: sessionMatch ? sessionMatch[1] : null
+	};
+};
+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
+			}
+		});
+		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;
+		functionCallState = {
+			blockIndex: blockIndex$1,
+			toolCallId: toolCallId ?? `tool_call_${blockIndex$1}`,
+			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;
+	return {
+		outputIndex: rawEvent.output_index,
+		toolCallId: item.call_id,
+		name: item.name,
+		initialArguments: item.arguments
+	};
+};
+
+//#endregion
+//#region src/routes/responses/utils.ts
+const getResponsesRequestOptions = (payload) => {
+	return {
+		vision: hasVisionInput(payload),
+		initiator: hasAgentInitiator(payload) ? "agent" : "user"
+	};
+};
+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, options) => {
+	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 initiator = options?.initiator ?? (isInitiateRequest ? "user" : "agent");
+	const headers = {
+		...copilotHeaders(state, enableVision),
+		"X-Initiator": initiator
+	};
+	if (anthropicBetaHeader) {
+		const filteredBeta = anthropicBetaHeader.split(",").map((item) => item.trim()).filter((item) => item !== "claude-code-20250219").join(",");
+		if (filteredBeta) headers["anthropic-beta"] = filteredBeta;
+	} 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) {
@@ -2133,18 +3171,6 @@ function createMessageDeltaEvents(finishReason, usage) {
 		}
 	}, { type: "message_stop" }];
 }
-function createFallbackMessageDeltaEvents(state$1) {
-	if (state$1.messageDeltaSent) return [];
-	if (state$1.pendingFinishReason) {
-		const usage = state$1.pendingUsage ?? {
-			prompt_tokens: 0,
-			completion_tokens: 0,
-			cached_tokens: 0
-		};
-		return createMessageDeltaEvents(state$1.pendingFinishReason, usage);
-	}
-	return [];
-}
 function translateChunkToAnthropicEvents(chunk, state$1, originalModel) {
 	const events$1 = [];
 	if (chunk.usage) {
@@ -2279,111 +3305,264 @@ function translateChunkToAnthropicEvents(chunk, state$1, originalModel) {
 }
 
 //#endregion
-//#region src/routes/messages/handler.ts
-/** Collect all chunks and extract usage data */
-async function collectChunksWithUsage(eventStream) {
-	const chunks = [];
-	let usage = null;
-	for await (const event of eventStream) {
-		if (!event.data || event.data === "[DONE]") continue;
+//#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 chunk = JSON.parse(event.data);
-			chunks.push(chunk);
-			if (chunk.usage) usage = {
-				prompt_tokens: chunk.usage.prompt_tokens,
-				completion_tokens: chunk.usage.completion_tokens,
-				cached_tokens: chunk.usage.prompt_tokens_details?.cached_tokens ?? 0
-			};
-		} catch (error) {
-			consola.error("Failed to parse chunk:", error, event.data);
+			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 {
-		chunks,
-		usage
-	};
-}
+	return null;
+};
+
+//#endregion
+//#region src/routes/messages/handler.ts
+const logger$1 = 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();
-	consola.debug("Anthropic request payload:", JSON.stringify(anthropicPayload));
-	const translatedPayload = translateToOpenAI(anthropicPayload);
-	let openAIPayload = await applyReplacementsToPayload(translatedPayload);
-	openAIPayload = {
-		...openAIPayload,
-		model: normalizeModelName(openAIPayload.model)
-	};
+	logger$1.debug("Anthropic request payload:", JSON.stringify(anthropicPayload));
+	const subagentMarker = parseSubagentMarkerFromFirstUser(anthropicPayload);
+	const initiatorOverride = subagentMarker ? "agent" : void 0;
+	if (subagentMarker) logger$1.debug("Detected Subagent marker:", JSON.stringify(subagentMarker));
+	const isCompact = isCompactRequest(anthropicPayload);
+	const anthropicBeta = c.req.header("anthropic-beta");
+	logger$1.debug("Anthropic Beta header:", anthropicBeta);
+	const noTools = !anthropicPayload.tools || anthropicPayload.tools.length === 0;
+	if (anthropicBeta && noTools && !isCompact) anthropicPayload.model = getSmallModel();
+	if (isCompact) {
+		logger$1.debug("Is compact request:", isCompact);
+		if (shouldCompactUseSmallModel()) anthropicPayload.model = getSmallModel();
+	} else mergeToolResultForClaude(anthropicPayload);
 	if (state.manualApprove) await awaitApproval();
-	const isAzureModel = isAzureOpenAIModel(openAIPayload.model);
-	if (isAzureModel) {
-		if (!state.azureOpenAIConfig) return c.json({ error: "Azure OpenAI not configured" }, 500);
-		setRequestContext(c, {
-			provider: "Azure OpenAI",
-			model: openAIPayload.model
-		});
-	} else setRequestContext(c, {
-		provider: "Copilot",
-		model: openAIPayload.model
+	const selectedModel = state.models?.data.find((m) => m.id === anthropicPayload.model);
+	if (shouldUseMessagesApi(selectedModel)) return await handleWithMessagesApi(c, anthropicPayload, {
+		anthropicBetaHeader: anthropicBeta,
+		initiatorOverride,
+		selectedModel
 	});
-	if (anthropicPayload.stream) {
-		const streamPayload = {
-			...openAIPayload,
-			stream: true,
-			stream_options: { include_usage: true }
+	if (shouldUseResponsesApi(selectedModel)) return await handleWithResponsesApi(c, anthropicPayload, initiatorOverride);
+	return await handleWithChatCompletions(c, anthropicPayload, initiatorOverride);
+}
+const RESPONSES_ENDPOINT$1 = "/responses";
+const MESSAGES_ENDPOINT = "/v1/messages";
+const handleWithChatCompletions = async (c, anthropicPayload, initiatorOverride) => {
+	let finalPayload = await applyReplacementsToPayload(translateToOpenAI(anthropicPayload));
+	finalPayload = {
+		...finalPayload,
+		model: normalizeModelName(finalPayload.model)
+	};
+	logger$1.debug("Translated OpenAI request payload:", JSON.stringify(finalPayload));
+	const response = isAzureOpenAIModel(finalPayload.model) && state.azureOpenAIConfig ? await createAzureOpenAIChatCompletions(state.azureOpenAIConfig, finalPayload) : await createChatCompletions(finalPayload, { initiator: initiatorOverride });
+	if (isNonStreaming(response)) {
+		logger$1.debug("Non-streaming response from Copilot:", JSON.stringify(response).slice(-400));
+		const anthropicResponse = translateToAnthropic(response);
+		logger$1.debug("Translated Anthropic response:", JSON.stringify(anthropicResponse));
+		return c.json(anthropicResponse);
+	}
+	logger$1.debug("Streaming response from Copilot");
+	return streamSSE(c, async (stream) => {
+		const streamState = {
+			messageStartSent: false,
+			contentBlockIndex: 0,
+			contentBlockOpen: false,
+			toolCalls: {}
 		};
-		const azureConfig = state.azureOpenAIConfig;
-		const eventStream = isAzureModel && azureConfig ? await createAzureOpenAIChatCompletions(azureConfig, streamPayload) : await createChatCompletions(streamPayload);
-		return streamSSE(c, async (stream) => {
-			const { chunks, usage } = await collectChunksWithUsage(eventStream);
-			consola.debug(`[stream] Collected ${chunks.length} chunks, usage:`, usage);
-			if (usage) {
-				setRequestContext(c, {
-					inputTokens: usage.prompt_tokens,
-					outputTokens: usage.completion_tokens
+		for await (const rawEvent of response) {
+			logger$1.debug("Copilot raw stream event:", JSON.stringify(rawEvent));
+			if (rawEvent.data === "[DONE]") break;
+			if (!rawEvent.data) continue;
+			const events$1 = translateChunkToAnthropicEvents(JSON.parse(rawEvent.data), streamState);
+			for (const event of events$1) {
+				logger$1.debug("Translated Anthropic event:", JSON.stringify(event));
+				await stream.writeSSE({
+					event: event.type,
+					data: JSON.stringify(event)
 				});
-				logTokenUsage(usage.prompt_tokens, usage.completion_tokens);
 			}
-			const streamState = {
-				messageStartSent: false,
-				contentBlockOpen: false,
-				contentBlockIndex: 0,
-				toolCalls: {},
-				pendingUsage: usage ?? void 0
-			};
-			for (const chunk of chunks) {
-				const events$1 = translateChunkToAnthropicEvents(chunk, streamState, anthropicPayload.model);
-				for (const evt of events$1) {
-					consola.debug(`[stream] Emitting event: ${evt.type}`);
+		}
+	});
+};
+const handleWithResponsesApi = async (c, anthropicPayload, initiatorOverride) => {
+	const responsesPayload = translateAnthropicMessagesToResponsesPayload(anthropicPayload);
+	logger$1.debug("Translated Responses payload:", JSON.stringify(responsesPayload));
+	const { vision, initiator } = getResponsesRequestOptions(responsesPayload);
+	const response = await createResponses(responsesPayload, {
+		vision,
+		initiator: initiatorOverride ?? initiator
+	});
+	if (responsesPayload.stream && isAsyncIterable$1(response)) {
+		logger$1.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: evt.type,
-						data: JSON.stringify(evt)
+						event: "ping",
+						data: "{\"type\":\"ping\"}"
 					});
+					continue;
+				}
+				const data = chunk.data;
+				if (!data) continue;
+				logger$1.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$1.debug("Translated Anthropic event:", eventData);
+					await stream.writeSSE({
+						event: event.type,
+						data: eventData
+					});
+				}
+				if (streamState.messageCompleted) {
+					logger$1.debug("Message completed, ending stream");
+					break;
 				}
 			}
-			const fallbackEvents = createFallbackMessageDeltaEvents(streamState);
-			consola.debug(`[stream] Fallback events: ${fallbackEvents.length}, messageDeltaSent: ${streamState.messageDeltaSent}`);
-			for (const evt of fallbackEvents) {
-				consola.debug(`[stream] Emitting fallback event: ${evt.type}`);
+			if (!streamState.messageCompleted) {
+				logger$1.warn("Responses stream ended without completion; sending error event");
+				const errorEvent = buildErrorEvent("Responses stream ended without completion");
 				await stream.writeSSE({
-					event: evt.type,
-					data: JSON.stringify(evt)
+					event: errorEvent.type,
+					data: JSON.stringify(errorEvent)
 				});
 			}
 		});
 	}
-	const nonStreamPayload = {
-		...openAIPayload,
-		stream: false
-	};
-	const azureConfigNonStream = state.azureOpenAIConfig;
-	const response = isAzureModel && azureConfigNonStream ? await createAzureOpenAIChatCompletions(azureConfigNonStream, nonStreamPayload) : await createChatCompletions(nonStreamPayload);
-	if (response.usage) setRequestContext(c, {
-		inputTokens: response.usage.prompt_tokens,
-		outputTokens: response.usage.completion_tokens
-	});
-	const anthropicResponse = translateToAnthropic(response, anthropicPayload.model);
+	logger$1.debug("Non-streaming Responses result:", JSON.stringify(response).slice(-400));
+	const anthropicResponse = translateResponsesResultToAnthropic(response);
+	logger$1.debug("Translated Anthropic response:", JSON.stringify(anthropicResponse));
 	return c.json(anthropicResponse);
-}
+};
+const handleWithMessagesApi = async (c, anthropicPayload, options) => {
+	const { anthropicBetaHeader, initiatorOverride, selectedModel } = options ?? {};
+	for (const msg of anthropicPayload.messages) if (msg.role === "assistant" && Array.isArray(msg.content)) msg.content = msg.content.filter((block) => {
+		if (block.type !== "thinking") return true;
+		return block.thinking && block.thinking !== "Thinking..." && block.signature && !block.signature.includes("@");
+	});
+	if (selectedModel?.capabilities.supports.adaptive_thinking) {
+		anthropicPayload.thinking = { type: "adaptive" };
+		anthropicPayload.output_config = { effort: getAnthropicEffortForModel(anthropicPayload.model) };
+	}
+	logger$1.debug("Translated Messages payload:", JSON.stringify(anthropicPayload));
+	const response = await createMessages(anthropicPayload, anthropicBetaHeader, { initiator: initiatorOverride });
+	if (isAsyncIterable$1(response)) {
+		logger$1.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$1.debug("Messages raw stream event:", data);
+				await stream.writeSSE({
+					event: eventName,
+					data
+				});
+			}
+		});
+	}
+	logger$1.debug("Non-streaming Messages result:", JSON.stringify(response).slice(-400));
+	return c.json(response);
+};
+const shouldUseResponsesApi = (selectedModel) => {
+	return selectedModel?.supported_endpoints?.includes(RESPONSES_ENDPOINT$1) ?? false;
+};
+const shouldUseMessagesApi = (selectedModel) => {
+	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 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
@@ -2454,20 +3633,16 @@ replacementsRoute.post("/", async (c) => {
 	return c.json(rule, 201);
 });
 replacementsRoute.delete("/:id", async (c) => {
-	const id = c.req.param("id");
-	if (!await removeReplacement(id)) return c.json({ error: "Replacement not found or is a system rule" }, 404);
+	if (!await removeReplacement(c.req.param("id"))) return c.json({ error: "Replacement not found or is a system rule" }, 404);
 	return c.json({ success: true });
 });
 replacementsRoute.patch("/:id", async (c) => {
-	const id = c.req.param("id");
-	const body = await c.req.json();
-	const rule = await updateReplacement(id, body);
+	const rule = await updateReplacement(c.req.param("id"), await c.req.json());
 	if (!rule) return c.json({ error: "Replacement not found or is a system rule" }, 404);
 	return c.json(rule);
 });
 replacementsRoute.patch("/:id/toggle", async (c) => {
-	const id = c.req.param("id");
-	const rule = await toggleReplacement(id);
+	const rule = await toggleReplacement(c.req.param("id"));
 	if (!rule) return c.json({ error: "Replacement not found or is a system rule" }, 404);
 	return c.json(rule);
 });
@@ -2476,6 +3651,130 @@ replacementsRoute.delete("/", async (c) => {
 	return c.json({ success: true });
 });
 
+//#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 = createHandlerLogger("responses-handler");
+const RESPONSES_ENDPOINT = "/responses";
+const handleResponses = async (c) => {
+	await checkRateLimit(state);
+	const payload = await c.req.json();
+	setRequestContext(c, {
+		provider: "Copilot (Responses)",
+		model: payload.model
+	});
+	logger.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.debug("Forwarding native Responses stream");
+		return streamSSE(c, async (stream) => {
+			const idTracker = createStreamIdTracker();
+			for await (const chunk of response) {
+				logger.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.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.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();
@@ -2509,6 +3808,7 @@ usageRoute.get("/", async (c) => {
 const server = new Hono();
 server.use(requestLogger);
 server.use(cors());
+server.use("*", createAuthMiddleware());
 server.get("/", (c) => c.text("Server running"));
 server.route("/chat/completions", completionRoutes);
 server.route("/models", modelRoutes);
@@ -2516,15 +3816,17 @@ server.route("/embeddings", embeddingRoutes);
 server.route("/usage", usageRoute);
 server.route("/token", tokenRoute);
 server.route("/replacements", replacementsRoute);
+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
 //#region src/start.ts
 async function runServer(options) {
-	consola.info(`copilot-api v${package_default.version}`);
+	consola.info(`copilot-api v${version}`);
 	if (options.insecure) {
 		process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
 		consola.warn("SSL certificate verification disabled (insecure mode)");
@@ -2541,8 +3843,10 @@ async function runServer(options) {
 	state.rateLimitWait = options.rateLimitWait;
 	state.showToken = options.showToken;
 	state.debug = options.debug;
+	state.verbose = options.verbose;
 	if (options.debug) consola.info("Debug mode enabled - raw HTTP requests will be logged");
 	await ensurePaths();
+	mergeConfigWithDefaults();
 	await cacheVSCodeVersion();
 	if (options.githubToken) {
 		state.githubToken = options.githubToken;
@@ -2686,10 +3990,10 @@ const start = defineCommand({
 
 //#endregion
 //#region src/main.ts
-const main = defineCommand({
+await runMain(defineCommand({
 	meta: {
 		name: "copilot-api",
-		version: package_default.version,
+		version,
 		description: "A wrapper around GitHub Copilot API to make it OpenAI compatible, making it usable for other tools."
 	},
 	subCommands: {
@@ -2699,8 +4003,7 @@ const main = defineCommand({
 		debug,
 		config
 	}
-});
-await runMain(main);
+}));
 
 //#endregion
 export {  };