@ashsec/copilot-api 0.7.13 → 0.9.0

package/dist/main.js

@@ -5,10 +5,10 @@ import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { randomUUID } from "node:crypto";
-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,10 +16,12 @@ import process$1 from "node:process";
 import { Hono } from "hono";
 import { cors } from "hono/cors";
 import { streamSSE } from "hono/streaming";
+import { events } from "fetch-event-stream";
+import util from "node:util";
 
 //#region package.json
 var name = "@ashsec/copilot-api";
-var version = "0.7.13";
+var version = "0.9.0";
 var description = "Turn GitHub Copilot into OpenAI/Anthropic API compatible server. Usable with Claude Code!";
 var keywords = [
 	"proxy",
@@ -57,6 +59,7 @@ var dependencies = {
 	"fetch-event-stream": "^0.1.5",
 	"gpt-tokenizer": "^3.0.1",
 	"hono": "^4.9.9",
+	"ms": "^2.1.3",
 	"proxy-from-env": "^1.1.0",
 	"srvx": "^0.8.9",
 	"tiny-invariant": "^1.3.3",
@@ -99,18 +102,16 @@ var package_default = {
 //#region src/lib/paths.ts
 const APP_DIR = path.join(os.homedir(), ".local", "share", "copilot-api");
 const GITHUB_TOKEN_PATH = path.join(APP_DIR, "github_token");
-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
 };
 async function ensurePaths() {
 	await fs.mkdir(PATHS.APP_DIR, { recursive: true });
 	await ensureFile(PATHS.GITHUB_TOKEN_PATH);
-	await ensureFile(PATHS.AZURE_OPENAI_CONFIG_PATH);
 }
 async function ensureFile(filePath) {
 	try {
@@ -128,7 +129,8 @@ const state = {
 	manualApprove: false,
 	rateLimitWait: false,
 	showToken: false,
-	debug: false
+	debug: false,
+	verbose: false
 };
 
 //#endregion
@@ -137,10 +139,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 +152,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"
@@ -251,56 +253,6 @@ async function getGitHubUser() {
 	return await response.json();
 }
 
-//#endregion
-//#region src/services/azure-openai/config.ts
-const AZURE_OPENAI_MODEL_PREFIX = "azure_openai_";
-async function loadAzureOpenAIConfig() {
-	try {
-		const content = await fs.readFile(PATHS.AZURE_OPENAI_CONFIG_PATH, "utf8");
-		if (!content.trim()) return null;
-		const decoded = Buffer.from(content.trim(), "base64").toString("utf8");
-		const config$1 = JSON.parse(decoded);
-		if (!config$1.endpoint || !config$1.apiKey) return null;
-		return config$1;
-	} catch {
-		return null;
-	}
-}
-async function saveAzureOpenAIConfig(config$1) {
-	const encoded = Buffer.from(JSON.stringify(config$1)).toString("base64");
-	await fs.writeFile(PATHS.AZURE_OPENAI_CONFIG_PATH, encoded, "utf8");
-	await fs.chmod(PATHS.AZURE_OPENAI_CONFIG_PATH, 384);
-	consola.success("Azure OpenAI configuration saved");
-}
-async function promptAzureOpenAISetup() {
-	if (!await consola.prompt("Would you like to add a custom Azure OpenAI endpoint?", {
-		type: "confirm",
-		initial: false
-	})) return null;
-	const endpoint = await consola.prompt("Enter your Azure OpenAI endpoint URL (e.g., https://your-resource.openai.azure.com):", { type: "text" });
-	if (!endpoint || typeof endpoint !== "string" || !endpoint.trim()) {
-		consola.warn("No endpoint provided, skipping Azure OpenAI setup");
-		return null;
-	}
-	const apiKey = await consola.prompt("Enter your Azure OpenAI API key:", { type: "text" });
-	if (!apiKey || typeof apiKey !== "string" || !apiKey.trim()) {
-		consola.warn("No API key provided, skipping Azure OpenAI setup");
-		return null;
-	}
-	const config$1 = {
-		endpoint: endpoint.trim().replace(/\/$/, ""),
-		apiKey: apiKey.trim()
-	};
-	await saveAzureOpenAIConfig(config$1);
-	return config$1;
-}
-function isAzureOpenAIModel(modelId) {
-	return modelId.startsWith(AZURE_OPENAI_MODEL_PREFIX);
-}
-function getAzureDeploymentName(modelId) {
-	return modelId.slice(13);
-}
-
 //#endregion
 //#region src/lib/retry-fetch.ts
 const RETRY_DELAYS_MS = [
@@ -370,62 +322,6 @@ async function fetchWithRetry(input, init) {
 	throw lastError;
 }
 
-//#endregion
-//#region src/services/azure-openai/create-chat-completions.ts
-const AZURE_API_VERSION = "2024-10-21";
-async function createAzureOpenAIChatCompletions(config$1, payload) {
-	const deploymentName = getAzureDeploymentName(payload.model);
-	const { max_tokens,...restPayload } = payload;
-	const azurePayload = {
-		...restPayload,
-		model: deploymentName,
-		...max_tokens != null && { max_completion_tokens: max_tokens }
-	};
-	const response = await fetchWithRetry(`${config$1.endpoint}/openai/deployments/${deploymentName}/chat/completions?api-version=${AZURE_API_VERSION}`, {
-		method: "POST",
-		headers: {
-			"api-key": config$1.apiKey,
-			"Content-Type": "application/json"
-		},
-		body: JSON.stringify(azurePayload)
-	});
-	if (!response.ok) {
-		consola.error("Failed to create Azure OpenAI chat completions:", response);
-		throw new HTTPError("Failed to create Azure OpenAI chat completions", response, payload);
-	}
-	if (payload.stream) return events(response);
-	return await response.json();
-}
-
-//#endregion
-//#region src/services/azure-openai/get-models.ts
-const AZURE_DEPLOYMENTS_API_VERSION = "2022-12-01";
-async function getAzureOpenAIDeployments(config$1) {
-	try {
-		const response = await fetchWithRetry(`${config$1.endpoint}/openai/deployments?api-version=${AZURE_DEPLOYMENTS_API_VERSION}`, { headers: {
-			"api-key": config$1.apiKey,
-			"Content-Type": "application/json"
-		} });
-		if (!response.ok) {
-			const errorText = await response.text().catch(() => "");
-			consola.error(`Failed to fetch Azure OpenAI deployments: ${response.status}`, errorText);
-			throw new HTTPError("Failed to fetch Azure OpenAI deployments", response);
-		}
-		return (await response.json()).data.filter((deployment) => deployment.status === "succeeded").map((deployment) => ({
-			id: `${AZURE_OPENAI_MODEL_PREFIX}${deployment.id}`,
-			deploymentName: deployment.id,
-			model: deployment.model,
-			created: deployment.created_at,
-			object: "deployment",
-			owned_by: deployment.owner || "azure-openai"
-		}));
-	} catch (error) {
-		if (error instanceof HTTPError) throw error;
-		consola.error("Failed to fetch Azure OpenAI deployments:", error);
-		return [];
-	}
-}
-
 //#endregion
 //#region src/services/copilot/get-models.ts
 const getModels = async () => {
@@ -489,24 +385,6 @@ const cacheVSCodeVersion = async () => {
 	state.vsCodeVersion = response;
 	consola.info(`Using VSCode version: ${response}`);
 };
-async function setupAzureOpenAI() {
-	let config$1 = await loadAzureOpenAIConfig();
-	if (!config$1) config$1 = await promptAzureOpenAISetup();
-	if (!config$1) {
-		consola.info("Azure OpenAI not configured");
-		return;
-	}
-	state.azureOpenAIConfig = config$1;
-	consola.info("Azure OpenAI configuration loaded");
-	try {
-		const deployments = await getAzureOpenAIDeployments(config$1);
-		state.azureOpenAIDeployments = deployments;
-		if (deployments.length > 0) consola.info(`Loaded ${deployments.length} Azure OpenAI deployment(s):\n${deployments.map((d) => `- ${d.id} (${d.model})`).join("\n")}`);
-		else consola.warn("No Azure OpenAI deployments found");
-	} catch (error) {
-		consola.warn("Failed to fetch Azure OpenAI deployments:", error);
-	}
-}
 
 //#endregion
 //#region src/services/github/poll-access-token.ts
@@ -1254,6 +1132,119 @@ 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 config$1 = readConfigFromDisk();
+	const { mergedConfig, changed } = mergeDefaultExtraPrompts(config$1);
+	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() {
@@ -1353,6 +1344,52 @@ 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() {
+	const config$1 = getConfig();
+	return normalizeApiKeys(config$1.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";
@@ -1455,7 +1492,7 @@ async function requestLogger(c, next) {
 	const durationStr = `${colors.cyan}${duration}s${colors.reset}`;
 	lines.push(`${colors.bold}${method}${colors.reset} ${path$1} ${statusBadge} ${durationStr}`);
 	if (ctx?.provider && ctx.model) {
-		const providerColor = ctx.provider === "Azure OpenAI" ? colors.blue : colors.magenta;
+		const providerColor = colors.magenta;
 		lines.push(`  ${colors.gray}Provider:${colors.reset} ${providerColor}${ctx.provider}${colors.reset} ${colors.gray}->${colors.reset} ${colors.white}${ctx.model}${colors.reset}`);
 	}
 	if (ctx?.inputTokens !== void 0 || ctx?.outputTokens !== void 0) {
@@ -1467,14 +1504,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
@@ -1719,13 +1748,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",
@@ -1751,37 +1784,6 @@ async function handleCompletion$1(c) {
 		model: normalizeModelName(payload.model)
 	};
 	consola.debug("Request payload:", JSON.stringify(payload).slice(-400));
-	if (isAzureOpenAIModel(payload.model)) {
-		if (!state.azureOpenAIConfig) return c.json({ error: "Azure OpenAI not configured" }, 500);
-		setRequestContext(c, {
-			provider: "Azure OpenAI",
-			model: payload.model
-		});
-		if (state.manualApprove) await awaitApproval();
-		const response$1 = await createAzureOpenAIChatCompletions(state.azureOpenAIConfig, payload);
-		if (isNonStreaming(response$1)) {
-			consola.debug("Non-streaming response:", JSON.stringify(response$1));
-			if (response$1.usage) setRequestContext(c, {
-				inputTokens: response$1.usage.prompt_tokens,
-				outputTokens: response$1.usage.completion_tokens
-			});
-			return c.json(response$1);
-		}
-		consola.debug("Streaming response");
-		return streamSSE(c, async (stream) => {
-			for await (const chunk of response$1) {
-				consola.debug("Streaming chunk:", JSON.stringify(chunk));
-				if (chunk.data && chunk.data !== "[DONE]") {
-					const parsed = JSON.parse(chunk.data);
-					if (parsed.usage) setRequestContext(c, {
-						inputTokens: parsed.usage.prompt_tokens,
-						outputTokens: parsed.usage.completion_tokens
-					});
-				}
-				await stream.writeSSE(chunk);
-			}
-		});
-	}
 	setRequestContext(c, {
 		provider: "Copilot",
 		model: payload.model
@@ -1804,7 +1806,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 +1829,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
@@ -2111,126 +2113,1088 @@ async function handleCountTokens(c) {
 }
 
 //#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 createMessageDeltaEvents(finishReason, usage) {
-	const stopReason = mapOpenAIStopReasonToAnthropic(finishReason);
-	const inputTokens = usage.prompt_tokens - usage.cached_tokens;
-	return [{
-		type: "message_delta",
-		delta: {
-			stop_reason: stopReason,
-			stop_sequence: null
-		},
-		usage: {
-			input_tokens: inputTokens,
-			output_tokens: usage.completion_tokens,
-			cache_creation_input_tokens: 0,
-			cache_read_input_tokens: usage.cached_tokens
+//#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;
 		}
-	}, { 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) {
-		state$1.pendingUsage = {
-			prompt_tokens: chunk.usage.prompt_tokens,
-			completion_tokens: chunk.usage.completion_tokens,
-			cached_tokens: chunk.usage.prompt_tokens_details?.cached_tokens ?? 0
-		};
-		if (state$1.pendingFinishReason && !state$1.messageDeltaSent) {
-			events$1.push(...createMessageDeltaEvents(state$1.pendingFinishReason, state$1.pendingUsage));
-			state$1.messageDeltaSent = true;
+		if (!stats.isFile()) continue;
+		if (now - stats.mtimeMs > LOG_RETENTION_MS) try {
+			fs$1.rmSync(filePath);
+		} catch {
+			continue;
 		}
 	}
-	if (chunk.choices.length === 0) return events$1;
-	const choice = chunk.choices[0];
-	const { delta } = choice;
-	if (!state$1.messageStartSent) {
-		const usage = state$1.pendingUsage ?? {
-			prompt_tokens: 0,
-			completion_tokens: 0,
-			cached_tokens: 0
-		};
-		const inputTokens = usage.prompt_tokens - usage.cached_tokens;
-		events$1.push({
-			type: "message_start",
-			message: {
-				id: chunk.id,
-				type: "message",
-				role: "assistant",
-				content: [],
-				model: originalModel ?? chunk.model,
-				stop_reason: null,
-				stop_sequence: null,
-				usage: {
-					input_tokens: inputTokens,
-					output_tokens: 0,
-					cache_creation_input_tokens: 0,
-					cache_read_input_tokens: usage.cached_tokens
-				}
-			}
+};
+const formatArgs = (args) => args.map((arg) => typeof arg === "string" ? arg : util.inspect(arg, {
+	depth: null,
+	colors: false
+})).join(" ");
+const sanitizeName = (name$1) => {
+	const normalized = name$1.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);
 		});
-		state$1.messageStartSent = true;
 	}
-	if (delta.content) {
-		if (isToolBlockOpen(state$1)) {
-			events$1.push({
-				type: "content_block_stop",
-				index: state$1.contentBlockIndex
+	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$1) => {
+	ensureLogDirectory();
+	const sanitizedName = sanitizeName(name$1);
+	const instance = consola.withTag(name$1);
+	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$1}]${message ? ` ${message}` : ""}`;
+		appendLine(filePath, line);
+	} });
+	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
 			});
-			state$1.contentBlockIndex++;
-			state$1.contentBlockOpen = false;
+			items.push(createFunctionToolCall(block));
+			continue;
 		}
-		if (!state$1.contentBlockOpen) {
-			events$1.push({
-				type: "content_block_start",
-				index: state$1.contentBlockIndex,
-				content_block: {
-					type: "text",
-					text: ""
-				}
+		if (block.type === "thinking" && block.signature && block.signature.includes("@")) {
+			flushPendingContent(pendingContent, items, {
+				role: "assistant",
+				phase: assistantPhase
 			});
-			state$1.contentBlockOpen = true;
+			items.push(createReasoningContent(block));
+			continue;
 		}
-		events$1.push({
-			type: "content_block_delta",
-			index: state$1.contentBlockIndex,
-			delta: {
-				type: "text_delta",
-				text: delta.content
-			}
-		});
+		const converted = translateAssistantContentBlock(block);
+		if (converted) pendingContent.push(converted);
 	}
-	if (delta.tool_calls) 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,
+	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;
+	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: name$1, initialArguments } = functionCallDetails;
+	const blockIndex = openFunctionCallBlock(state$1, {
+		outputIndex,
+		toolCallId,
+		name: name$1,
+		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: name$1, 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$1 ?? "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$1 = item.name;
+	const initialArguments = item.arguments;
+	return {
+		outputIndex,
+		toolCallId,
+		name: name$1,
+		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, 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) {
+	if (!state$1.contentBlockOpen) return false;
+	return Object.values(state$1.toolCalls).some((tc) => tc.anthropicBlockIndex === state$1.contentBlockIndex);
+}
+function createMessageDeltaEvents(finishReason, usage) {
+	const stopReason = mapOpenAIStopReasonToAnthropic(finishReason);
+	const inputTokens = usage.prompt_tokens - usage.cached_tokens;
+	return [{
+		type: "message_delta",
+		delta: {
+			stop_reason: stopReason,
+			stop_sequence: null
+		},
+		usage: {
+			input_tokens: inputTokens,
+			output_tokens: usage.completion_tokens,
+			cache_creation_input_tokens: 0,
+			cache_read_input_tokens: usage.cached_tokens
+		}
+	}, { type: "message_stop" }];
+}
+function translateChunkToAnthropicEvents(chunk, state$1, originalModel) {
+	const events$1 = [];
+	if (chunk.usage) {
+		state$1.pendingUsage = {
+			prompt_tokens: chunk.usage.prompt_tokens,
+			completion_tokens: chunk.usage.completion_tokens,
+			cached_tokens: chunk.usage.prompt_tokens_details?.cached_tokens ?? 0
+		};
+		if (state$1.pendingFinishReason && !state$1.messageDeltaSent) {
+			events$1.push(...createMessageDeltaEvents(state$1.pendingFinishReason, state$1.pendingUsage));
+			state$1.messageDeltaSent = true;
+		}
+	}
+	if (chunk.choices.length === 0) return events$1;
+	const choice = chunk.choices[0];
+	const { delta } = choice;
+	if (!state$1.messageStartSent) {
+		const usage = state$1.pendingUsage ?? {
+			prompt_tokens: 0,
+			completion_tokens: 0,
+			cached_tokens: 0
+		};
+		const inputTokens = usage.prompt_tokens - usage.cached_tokens;
+		events$1.push({
+			type: "message_start",
+			message: {
+				id: chunk.id,
+				type: "message",
+				role: "assistant",
+				content: [],
+				model: originalModel ?? chunk.model,
+				stop_reason: null,
+				stop_sequence: null,
+				usage: {
+					input_tokens: inputTokens,
+					output_tokens: 0,
+					cache_creation_input_tokens: 0,
+					cache_read_input_tokens: usage.cached_tokens
+				}
+			}
+		});
+		state$1.messageStartSent = true;
+	}
+	if (delta.content) {
+		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.tool_calls) 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({
@@ -2279,111 +3243,266 @@ 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) => {
+	const openAIPayload = translateToOpenAI(anthropicPayload);
+	let finalPayload = await applyReplacementsToPayload(openAIPayload);
+	finalPayload = {
+		...finalPayload,
+		model: normalizeModelName(finalPayload.model)
+	};
+	logger$1.debug("Translated OpenAI request payload:", JSON.stringify(finalPayload));
+	const response = 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 chunk = JSON.parse(rawEvent.data);
+			const events$1 = translateChunkToAnthropicEvents(chunk, 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
@@ -2418,19 +3537,9 @@ modelRoutes.get("/", async (c) => {
 			owned_by: model.vendor,
 			display_name: model.name
 		})) ?? [];
-		const azureModels = state.azureOpenAIDeployments?.map((deployment) => ({
-			id: deployment.id,
-			object: "model",
-			type: "model",
-			created: deployment.created,
-			created_at: (/* @__PURE__ */ new Date(deployment.created * 1e3)).toISOString(),
-			owned_by: deployment.owned_by,
-			display_name: `${deployment.deploymentName} (${deployment.model})`
-		})) ?? [];
-		const allModels = [...copilotModels, ...azureModels];
 		return c.json({
 			object: "list",
-			data: allModels,
+			data: copilotModels,
 			has_more: false
 		});
 	} catch (error) {
@@ -2476,6 +3585,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 +3742,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,9 +3750,11 @@ 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
@@ -2541,8 +3777,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;
@@ -2550,10 +3788,7 @@ async function runServer(options) {
 	} else await setupGitHubToken();
 	await setupCopilotToken();
 	await cacheModels();
-	await setupAzureOpenAI();
-	const copilotModelIds = state.models?.data.map((model) => model.id) ?? [];
-	const azureModelIds = state.azureOpenAIDeployments?.map((deployment) => deployment.id) ?? [];
-	const allModelIds = [...copilotModelIds, ...azureModelIds];
+	const allModelIds = state.models?.data.map((model) => model.id) ?? [];
 	consola.info(`Available models: \n${allModelIds.map((id) => `- ${id}`).join("\n")}`);
 	const serverUrl = `http://localhost:${options.port}`;
 	if (options.claudeCode) {