@ashsec/copilot-api 0.11.2 → 0.11.5

package/dist/main.js

@@ -21,7 +21,7 @@ import util from "node:util";
 
 //#region package.json
 var name = "@ashsec/copilot-api";
-var version = "0.11.2";
+var version = "0.11.5";
 var description = "Turn GitHub Copilot into OpenAI/Anthropic API compatible server. Usable with Claude Code!";
 var keywords = [
 	"proxy",
@@ -100,7 +100,7 @@ var package_default = {
 
 //#endregion
 //#region src/lib/paths.ts
-const APP_DIR = path.join(os.homedir(), ".local", "share", "copilot-api");
+const APP_DIR = process.env.DATA_DIR || path.join(os.homedir(), ".local", "share", "copilot-api");
 const GITHUB_TOKEN_PATH = path.join(APP_DIR, "github_token");
 const REPLACEMENTS_CONFIG_PATH = path.join(APP_DIR, "replacements.json");
 const PATHS = {
@@ -1538,6 +1538,59 @@ function generateEnvScript(envVars, commandToRun = "") {
 	return commandBlock || commandToRun;
 }
 
+//#endregion
+//#region src/lib/ip-blocker.ts
+const ipTracker = /* @__PURE__ */ new Map();
+/**
+* Extracts the client IP from the x-forwarded-for header.
+* Returns the first IP in the comma-separated list, or null if header is absent.
+*/
+function extractClientIp(c) {
+	const xForwardedFor = c.req.header("x-forwarded-for");
+	if (!xForwardedFor) return null;
+	return xForwardedFor.split(",")[0]?.trim() || null;
+}
+/**
+* Gets the current UTC date as YYYY-MM-DD string.
+*/
+function getUtcDateString() {
+	return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+}
+/**
+* Checks if an IP is blocked due to 3+ failed attempts today (UTC).
+* Cleans up stale entries (entries from previous days).
+*/
+function isIpBlocked(ip) {
+	const today = getUtcDateString();
+	const entry = ipTracker.get(ip);
+	if (!entry) return false;
+	if (entry.date !== today) {
+		ipTracker.delete(ip);
+		return false;
+	}
+	return entry.count >= 3;
+}
+/**
+* Records a failed authentication attempt for an IP.
+* Increments count if entry exists for today, otherwise creates new entry.
+*/
+function recordFailedAttempt(ip) {
+	const today = getUtcDateString();
+	const entry = ipTracker.get(ip);
+	if (!entry) {
+		ipTracker.set(ip, {
+			count: 1,
+			date: today
+		});
+		return;
+	}
+	if (entry.date === today) entry.count += 1;
+	else ipTracker.set(ip, {
+		count: 1,
+		date: today
+	});
+}
+
 //#endregion
 //#region src/lib/request-auth.ts
 function normalizeApiKeys(apiKeys) {
@@ -1556,6 +1609,8 @@ function getConfiguredApiKeys() {
 function extractRequestApiKey(c) {
 	const xApiKey = c.req.header("x-api-key")?.trim();
 	if (xApiKey) return xApiKey;
+	const googleApiKey = c.req.header("x-goog-api-key")?.trim();
+	if (googleApiKey) return googleApiKey;
 	const authorization = c.req.header("authorization");
 	if (!authorization) return null;
 	const [scheme, ...rest] = authorization.trim().split(/\s+/);
@@ -1597,10 +1652,16 @@ async function apiKeyGuard(c, next) {
 		await next();
 		return;
 	}
+	const clientIp = extractClientIp(c);
+	if (clientIp !== null && isIpBlocked(clientIp)) {
+		await new Promise(() => {});
+		return;
+	}
 	if (extractRequestApiKey(c) === state.apiKeyAuth) {
 		await next();
 		return;
 	}
+	if (clientIp !== null) recordFailedAttempt(clientIp);
 	await new Promise(() => {});
 }
 
@@ -1658,7 +1719,7 @@ async function logRawRequest(c) {
 	const lines = [];
 	lines.push(`${colors.magenta}${colors.bold}[DEBUG] Incoming Request${colors.reset}`, `${colors.cyan}${method}${colors.reset} ${url}`, `${colors.dim}Headers:${colors.reset}`);
 	for (const [key, value] of Object.entries(headers)) {
-		const displayValue = key.toLowerCase().includes("authorization") ? `${value.slice(0, 20)}...` : value;
+		const displayValue = key.toLowerCase().includes("authorization") || key.toLowerCase().includes("api-key") ? `${value.slice(0, 20)}...` : value;
 		lines.push(`  ${colors.gray}${key}:${colors.reset} ${displayValue}`);
 	}
 	if (method !== "GET" && method !== "HEAD") try {
@@ -1764,6 +1825,7 @@ const awaitApproval = async () => {
 */
 function normalizeModelName(model) {
 	let normalized = model.replace("[1m]", "-1m");
+	normalized = normalized.replace(/-\d{8}$/, "");
 	normalized = normalized.replaceAll(/(\d)-(\d)/g, (_, p1, p2) => `${p1}.${p2}`);
 	return normalized;
 }
@@ -2005,13 +2067,19 @@ const createChatCompletions = async (payload, options) => {
 		...copilotHeaders(state, enableVision),
 		"X-Initiator": options?.initiator ?? (isAgentCall ? "agent" : "user")
 	};
+	if (payload.tools) for (const tool of payload.tools) {
+		const params = tool.function.parameters;
+		if (!params.type) params.type = "object";
+		if (!params.properties) params.properties = {};
+	}
 	const response = await fetchWithRetry(`${copilotBaseUrl(state)}/chat/completions`, {
 		method: "POST",
 		headers,
 		body: JSON.stringify(payload)
 	});
 	if (!response.ok) {
-		consola.error("Failed to create chat completions", response);
+		const errorBody = await response.clone().text();
+		consola.error("Failed to create chat completions", `Status: ${response.status}`, errorBody);
 		throw new HTTPError("Failed to create chat completions", response);
 	}
 	if (payload.stream) return events(response);
@@ -2033,87 +2101,867 @@ async function handleCompletion$1(c) {
 	};
 	consola.debug("Request payload:", JSON.stringify(payload).slice(-400));
 	setRequestContext(c, {
-		requestedModel,
-		provider: "ChatCompletions",
-		model: payload.model,
-		replacements: appliedRules,
-		reasoningEffort
+		requestedModel,
+		provider: "ChatCompletions",
+		model: payload.model,
+		replacements: appliedRules,
+		reasoningEffort
+	});
+	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 });
+		}
+	} catch (error) {
+		consola.warn("Failed to calculate token count:", error);
+	}
+	if (state.manualApprove) await awaitApproval();
+	if (isNullish(payload.max_tokens)) {
+		payload = {
+			...payload,
+			max_tokens: selectedModel?.capabilities.limits.max_output_tokens
+		};
+		consola.debug("Set max_tokens to:", JSON.stringify(payload.max_tokens));
+	}
+	const response = await createChatCompletions(payload);
+	if (isNonStreaming$1(response)) {
+		consola.debug("Non-streaming response:", JSON.stringify(response));
+		if (response.usage) setRequestContext(c, {
+			inputTokens: response.usage.prompt_tokens,
+			outputTokens: response.usage.completion_tokens
+		});
+		return c.json(response);
+	}
+	consola.debug("Streaming response");
+	return streamSSE(c, async (stream) => {
+		for await (const chunk of response) {
+			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);
+		}
+	});
+}
+const isNonStreaming$1 = (response) => Object.hasOwn(response, "choices");
+
+//#endregion
+//#region src/routes/chat-completions/route.ts
+const completionRoutes = new Hono();
+completionRoutes.post("/", async (c) => {
+	try {
+		return await handleCompletion$1(c);
+	} catch (error) {
+		return await forwardError(c, error);
+	}
+});
+
+//#endregion
+//#region src/services/copilot/create-embeddings.ts
+const createEmbeddings = async (payload) => {
+	if (!state.copilotToken) throw new Error("Copilot token not found");
+	const response = await fetchWithRetry(`${copilotBaseUrl(state)}/embeddings`, {
+		method: "POST",
+		headers: copilotHeaders(state),
+		body: JSON.stringify(payload)
+	});
+	if (!response.ok) throw new HTTPError("Failed to create embeddings", response);
+	return await response.json();
+};
+
+//#endregion
+//#region src/routes/embeddings/route.ts
+const embeddingRoutes = new Hono();
+embeddingRoutes.post("/", async (c) => {
+	try {
+		const paylod = await c.req.json();
+		const response = await createEmbeddings(paylod);
+		return c.json(response);
+	} catch (error) {
+		return await forwardError(c, error);
+	}
+});
+
+//#endregion
+//#region src/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$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);
+		});
+	}
+	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/google-ai/request-translation.ts
+let toolCallCounter = 0;
+function nextToolCallId() {
+	return `call_${Date.now()}_${toolCallCounter++}`;
+}
+function isTextPart(part) {
+	return "text" in part;
+}
+function isFunctionCallPart(part) {
+	return "functionCall" in part;
+}
+function isFunctionResponsePart(part) {
+	return "functionResponse" in part;
+}
+/**
+* Convert Google contents array → OpenAI messages array.
+*/
+function translateContents(contents) {
+	const messages = [];
+	for (const content of contents) if (content.role === "user") {
+		const functionResponses = content.parts.filter((p) => isFunctionResponsePart(p));
+		const otherParts = content.parts.filter((p) => !isFunctionResponsePart(p));
+		for (const part of functionResponses) messages.push({
+			role: "tool",
+			tool_call_id: findToolCallId(messages, part.functionResponse.name),
+			content: JSON.stringify(part.functionResponse.response)
+		});
+		if (otherParts.length > 0) {
+			const textContent = otherParts.filter((p) => isTextPart(p)).map((p) => p.text).join("");
+			if (textContent) messages.push({
+				role: "user",
+				content: textContent
+			});
+		}
+	} else {
+		const textParts = content.parts.filter((p) => isTextPart(p));
+		const functionCalls = content.parts.filter((p) => isFunctionCallPart(p));
+		const textContent = textParts.filter((p) => !p.thought).map((p) => p.text).join("");
+		const toolCalls = functionCalls.length > 0 ? functionCalls.map((part) => ({
+			id: nextToolCallId(),
+			type: "function",
+			function: {
+				name: part.functionCall.name,
+				arguments: JSON.stringify(part.functionCall.args)
+			}
+		})) : void 0;
+		messages.push({
+			role: "assistant",
+			content: textContent || null,
+			tool_calls: toolCalls
+		});
+	}
+	return messages;
+}
+/**
+* Find the tool_call_id for a function response by walking back through messages
+* to find the matching assistant tool_call by function name.
+*/
+function findToolCallId(messages, functionName) {
+	for (let i = messages.length - 1; i >= 0; i--) {
+		const msg = messages[i];
+		if (msg.role === "assistant" && msg.tool_calls) {
+			const match = msg.tool_calls.find((tc) => tc.function.name === functionName);
+			if (match) return match.id;
+		}
+	}
+	return nextToolCallId();
+}
+/**
+* Convert Google tools → OpenAI tools format.
+*/
+function translateTools(tools) {
+	if (!tools || tools.length === 0) return void 0;
+	const openAITools = [];
+	for (const tool of tools) if (tool.functionDeclarations) for (const decl of tool.functionDeclarations) openAITools.push({
+		type: "function",
+		function: {
+			name: decl.name,
+			description: decl.description,
+			parameters: normalizeToolParameters(decl.parameters ?? {})
+		}
+	});
+	return openAITools.length > 0 ? openAITools : void 0;
+}
+/**
+* Remove $schema from tool parameters and ensure valid structure.
+* Copilot requires parameters to have at least { type: "object", properties: {} }.
+*/
+function normalizeToolParameters(params) {
+	const cleaned = { ...params };
+	delete cleaned.$schema;
+	if (!cleaned.type) cleaned.type = "object";
+	if (!cleaned.properties) cleaned.properties = {};
+	return cleaned;
+}
+/**
+* Convert Google toolConfig → OpenAI tool_choice.
+*/
+function translateToolChoice(toolConfig) {
+	if (!toolConfig?.functionCallingConfig) return void 0;
+	switch (toolConfig.functionCallingConfig.mode) {
+		case "AUTO": return "auto";
+		case "NONE": return "none";
+		case "ANY": {
+			const allowed = toolConfig.functionCallingConfig.allowedFunctionNames;
+			if (allowed && allowed.length === 1) return {
+				type: "function",
+				function: { name: allowed[0] }
+			};
+			return "required";
+		}
+		default: return;
+	}
+}
+/**
+* Extract system instruction from Google payload as an OpenAI system message.
+*/
+function translateSystemInstruction(systemInstruction) {
+	if (!systemInstruction?.parts) return void 0;
+	const systemText = systemInstruction.parts.map((p) => p.text).join("\n");
+	if (!systemText) return void 0;
+	return {
+		role: "system",
+		content: systemText
+	};
+}
+/**
+* Map Google generationConfig fields to OpenAI-compatible fields.
+*/
+function mapGenerationConfigFields(config$1) {
+	if (!config$1) return {};
+	return {
+		max_tokens: config$1.maxOutputTokens,
+		temperature: config$1.temperature,
+		top_p: config$1.topP,
+		stop: config$1.stopSequences,
+		seed: config$1.seed,
+		frequency_penalty: config$1.frequencyPenalty,
+		presence_penalty: config$1.presencePenalty,
+		response_format: config$1.responseMimeType === "application/json" ? { type: "json_object" } : void 0
+	};
+}
+/**
+* Convert Google generationConfig → OpenAI-compatible config fields.
+*/
+function translateGenerationConfig(config$1, stream) {
+	return {
+		stream,
+		stream_options: stream ? { include_usage: true } : void 0,
+		...mapGenerationConfigFields(config$1)
+	};
+}
+/**
+* Main translation: Google Generative AI request → OpenAI ChatCompletions payload.
+*/
+function translateGoogleToOpenAI(googlePayload, model, stream) {
+	const messages = [];
+	const systemMessage = translateSystemInstruction(googlePayload.systemInstruction);
+	if (systemMessage) messages.push(systemMessage);
+	messages.push(...translateContents(googlePayload.contents));
+	return {
+		model,
+		messages,
+		...translateGenerationConfig(googlePayload.generationConfig, stream),
+		tools: translateTools(googlePayload.tools),
+		tool_choice: translateToolChoice(googlePayload.toolConfig)
+	};
+}
+
+//#endregion
+//#region src/routes/google-ai/response-translation.ts
+function mapFinishReason(reason) {
+	switch (reason) {
+		case "stop": return "STOP";
+		case "length": return "MAX_TOKENS";
+		case "content_filter": return "SAFETY";
+		case "tool_calls": return "STOP";
+		default: return null;
+	}
+}
+function translateUsage(usage) {
+	if (!usage) return void 0;
+	return {
+		promptTokenCount: usage.prompt_tokens,
+		candidatesTokenCount: usage.completion_tokens,
+		totalTokenCount: usage.total_tokens,
+		cachedContentTokenCount: usage.prompt_tokens_details?.cached_tokens ?? void 0
+	};
+}
+/**
+* Parse tool call arguments from JSON string, with fallback to raw string.
+*/
+function parseToolCallArgs(argsString) {
+	try {
+		return JSON.parse(argsString);
+	} catch {
+		return { raw: argsString };
+	}
+}
+/**
+* Convert OpenAI ChatCompletion response → Google Generative AI response.
+*/
+function translateOpenAIToGoogle(response) {
+	return {
+		candidates: response.choices.map((choice) => {
+			const parts = [];
+			if (choice.message.content) parts.push({ text: choice.message.content });
+			if (choice.message.tool_calls) for (const toolCall of choice.message.tool_calls) parts.push({ functionCall: {
+				name: toolCall.function.name,
+				args: parseToolCallArgs(toolCall.function.arguments)
+			} });
+			if (parts.length === 0) parts.push({ text: "" });
+			return {
+				content: {
+					role: "model",
+					parts
+				},
+				finishReason: mapFinishReason(choice.finish_reason),
+				index: choice.index
+			};
+		}),
+		usageMetadata: translateUsage(response.usage)
+	};
+}
+function createGoogleStreamState() {
+	return {
+		toolCalls: /* @__PURE__ */ new Map(),
+		hasContent: false
+	};
+}
+/**
+* Accumulate incremental tool call deltas into the stream state.
+*/
+function accumulateToolCallDeltas(toolCallDeltas, streamState) {
+	for (const tc of toolCallDeltas) {
+		const existing = streamState.toolCalls.get(tc.index);
+		if (existing) {
+			if (tc.function?.arguments) existing.arguments += tc.function.arguments;
+		} else streamState.toolCalls.set(tc.index, {
+			name: tc.function?.name ?? "",
+			arguments: tc.function?.arguments ?? ""
+		});
+	}
+}
+/**
+* Emit accumulated tool calls as Google functionCall parts and clear state.
+*/
+function emitAccumulatedToolCalls(streamState) {
+	const parts = [];
+	for (const [, tc] of streamState.toolCalls) parts.push({ functionCall: {
+		name: tc.name,
+		args: parseToolCallArgs(tc.arguments)
+	} });
+	streamState.toolCalls.clear();
+	return parts;
+}
+/**
+* Build a Google streaming chunk from parts and optional finish/usage info.
+*/
+function buildStreamChunk(options) {
+	const { parts, finishReason, index, usage } = options;
+	if (parts.length === 0 && finishReason) parts.push({ text: "" });
+	return {
+		candidates: [{
+			content: {
+				role: "model",
+				parts
+			},
+			finishReason: finishReason ? mapFinishReason(finishReason) : null,
+			index
+		}],
+		usageMetadata: usage ? translateUsage(usage) : void 0
+	};
+}
+/**
+* Translate a single OpenAI streaming chunk → Google streaming chunk.
+* Returns null if the chunk doesn't produce a Google event.
+*/
+function translateChunkToGoogle(chunk, streamState) {
+	if (chunk.choices.length === 0) {
+		if (chunk.usage) return {
+			candidates: [],
+			usageMetadata: translateUsage(chunk.usage)
+		};
+		return null;
+	}
+	const choice = chunk.choices[0];
+	const parts = [];
+	if (choice.delta.content !== null && choice.delta.content !== void 0) {
+		parts.push({ text: choice.delta.content });
+		streamState.hasContent = true;
+	}
+	if (choice.delta.tool_calls) accumulateToolCallDeltas(choice.delta.tool_calls, streamState);
+	if (choice.finish_reason === "tool_calls") parts.push(...emitAccumulatedToolCalls(streamState));
+	if (parts.length === 0 && !choice.finish_reason) return null;
+	return buildStreamChunk({
+		parts,
+		finishReason: choice.finish_reason,
+		index: choice.index,
+		usage: chunk.usage
+	});
+}
+/**
+* Map Responses API status → Google finish reason.
+*/
+function mapResponsesFinishReason(status, incompleteDetails) {
+	if (status === "completed") return "STOP";
+	if (status === "incomplete") {
+		if (incompleteDetails?.reason === "max_output_tokens") return "MAX_TOKENS";
+		if (incompleteDetails?.reason === "content_filter") return "SAFETY";
+		return "MAX_TOKENS";
+	}
+	if (status === "failed") return "OTHER";
+	return null;
+}
+/**
+* Translate Responses API usage → Google usage metadata.
+*/
+function translateResponsesUsage(usage) {
+	if (!usage) return void 0;
+	return {
+		promptTokenCount: usage.input_tokens,
+		candidatesTokenCount: usage.output_tokens,
+		totalTokenCount: usage.total_tokens,
+		cachedContentTokenCount: usage.input_tokens_details?.cached_tokens ?? void 0
+	};
+}
+/**
+* Type guard for ResponseOutputText blocks.
+*/
+function isOutputTextBlock(block) {
+	return typeof block === "object" && block !== null && "type" in block && block.type === "output_text";
+}
+/**
+* Convert Responses API result → Google Generative AI response (non-streaming).
+*/
+function translateResponsesResultToGoogle(result) {
+	const parts = [];
+	for (const item of result.output) if (item.type === "message" && item.content) {
+		for (const block of item.content) if (isOutputTextBlock(block)) parts.push({ text: block.text });
+	} else if (item.type === "function_call") {
+		const funcCall = item;
+		parts.push({ functionCall: {
+			name: funcCall.name,
+			args: parseToolCallArgs(funcCall.arguments)
+		} });
+	}
+	if (parts.length === 0) parts.push({ text: result.output_text || "" });
+	const finishReason = mapResponsesFinishReason(result.status, result.incomplete_details);
+	return {
+		candidates: [{
+			content: {
+				role: "model",
+				parts
+			},
+			finishReason,
+			index: 0
+		}],
+		usageMetadata: translateResponsesUsage(result.usage)
+	};
+}
+/**
+* Translate a single Responses API stream event → Google streaming chunk.
+* Returns null if the event doesn't produce a Google event.
+*/
+function translateResponsesStreamEventToGoogle(event, _streamState) {
+	switch (event.type) {
+		case "response.output_text.delta": return { candidates: [{
+			content: {
+				role: "model",
+				parts: [{ text: event.delta }]
+			},
+			finishReason: null,
+			index: 0
+		}] };
+		case "response.function_call_arguments.done": return { candidates: [{
+			content: {
+				role: "model",
+				parts: [{ functionCall: {
+					name: event.name,
+					args: parseToolCallArgs(event.arguments)
+				} }]
+			},
+			finishReason: null,
+			index: 0
+		}] };
+		case "response.completed":
+		case "response.incomplete": return {
+			candidates: [{
+				content: {
+					role: "model",
+					parts: [{ text: "" }]
+				},
+				finishReason: mapResponsesFinishReason(event.response.status, event.response.incomplete_details),
+				index: 0
+			}],
+			usageMetadata: translateResponsesUsage(event.response.usage)
+		};
+		default: return null;
+	}
+}
+
+//#endregion
+//#region src/routes/google-ai/handler.ts
+const logger$2 = createHandlerLogger("google-ai-handler");
+const RESPONSES_ENDPOINT$2 = "/responses";
+/**
+* Parse model name and action from the URL path segment.
+* e.g. "gemini-3-flash-preview:streamGenerateContent" → { model: "gemini-3-flash-preview", action: "streamGenerateContent" }
+*/
+function parseModelAction(modelAction) {
+	const colonIdx = modelAction.lastIndexOf(":");
+	if (colonIdx === -1) return {
+		model: modelAction,
+		action: "generateContent"
+	};
+	return {
+		model: modelAction.slice(0, colonIdx),
+		action: modelAction.slice(colonIdx + 1)
+	};
+}
+/**
+* Cap max_tokens at the model's advertised limit to prevent 400 errors.
+*/
+function capMaxTokens(payload, selectedModel) {
+	const maxAllowed = selectedModel?.capabilities.limits.max_output_tokens;
+	if (!maxAllowed) return;
+	if (isNullish(payload.max_tokens)) payload.max_tokens = maxAllowed;
+	else if (payload.max_tokens > maxAllowed) {
+		consola.debug(`Capping max_tokens from ${payload.max_tokens} to ${maxAllowed} for ${payload.model}`);
+		payload.max_tokens = maxAllowed;
+	}
+}
+async function handleGoogleAI(c) {
+	await checkRateLimit(state);
+	const modelAction = c.req.param("modelAction");
+	if (!modelAction) return c.json({ error: {
+		code: 400,
+		message: "Missing model and action in URL path",
+		status: "INVALID_ARGUMENT"
+	} }, 400);
+	const { model: rawModel, action } = parseModelAction(modelAction);
+	const isStream = action === "streamGenerateContent";
+	const model = normalizeModelName(rawModel);
+	logger$2.debug(`Google AI request: model=${model}, action=${action}`);
+	const googlePayload = await c.req.json();
+	logger$2.debug("Google AI request payload:", JSON.stringify(googlePayload));
+	const openAIPayload = translateGoogleToOpenAI(googlePayload, model, isStream);
+	const { payload: replacedPayload, appliedRules } = await applyReplacementsToPayload(openAIPayload);
+	const finalPayload = {
+		...replacedPayload,
+		model: normalizeModelName(replacedPayload.model)
+	};
+	const selectedModel = state.models?.data.find((m) => m.id === finalPayload.model);
+	const useResponsesApi = selectedModel?.supported_endpoints?.includes(RESPONSES_ENDPOINT$2) ?? false;
+	setRequestContext(c, {
+		requestedModel: rawModel,
+		model: finalPayload.model,
+		provider: useResponsesApi ? "GoogleAI→Responses" : "GoogleAI→ChatCompletions",
+		replacements: appliedRules
 	});
-	const selectedModel = state.models?.data.find((model) => model.id === payload.model);
 	try {
 		if (selectedModel) {
-			const tokenCount = await getTokenCount(payload, selectedModel);
+			const tokenCount = await getTokenCount(finalPayload, selectedModel);
 			setRequestContext(c, { inputTokens: tokenCount.input });
 		}
-	} catch (error) {
-		consola.warn("Failed to calculate token count:", error);
-	}
+	} catch {}
 	if (state.manualApprove) await awaitApproval();
-	if (isNullish(payload.max_tokens)) {
-		payload = {
-			...payload,
-			max_tokens: selectedModel?.capabilities.limits.max_output_tokens
-		};
-		consola.debug("Set max_tokens to:", JSON.stringify(payload.max_tokens));
-	}
-	const response = await createChatCompletions(payload);
-	if (isNonStreaming$1(response)) {
-		consola.debug("Non-streaming response:", JSON.stringify(response));
+	capMaxTokens(finalPayload, selectedModel);
+	consola.debug(`[google-ai] Translated payload: model=${finalPayload.model}, max_tokens=${finalPayload.max_tokens}, stream=${finalPayload.stream}, tools=${finalPayload.tools?.length ?? 0}, messages=${finalPayload.messages.length}`);
+	logger$2.debug("Translated OpenAI payload:", JSON.stringify(finalPayload));
+	if (useResponsesApi) {
+		consola.debug(`[google-ai] Using Responses API for ${finalPayload.model}`);
+		return handleWithResponsesApi$1(c, finalPayload, isStream);
+	}
+	consola.debug(`[google-ai] Using ChatCompletions API for ${finalPayload.model}`);
+	return handleWithChatCompletions$1(c, finalPayload);
+}
+async function handleWithChatCompletions$1(c, finalPayload) {
+	const response = await createChatCompletions(finalPayload);
+	if (isNonStreamingCC(response)) {
+		logger$2.debug("Non-streaming response from Copilot:", JSON.stringify(response));
 		if (response.usage) setRequestContext(c, {
 			inputTokens: response.usage.prompt_tokens,
 			outputTokens: response.usage.completion_tokens
 		});
-		return c.json(response);
+		const googleResponse = translateOpenAIToGoogle(response);
+		return c.json(googleResponse);
 	}
-	consola.debug("Streaming response");
+	logger$2.debug("Streaming response from Copilot");
 	return streamSSE(c, async (stream) => {
-		for await (const chunk of response) {
-			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);
+		const streamState = createGoogleStreamState();
+		for await (const rawEvent of response) {
+			logger$2.debug("Copilot raw stream event:", JSON.stringify(rawEvent));
+			if (rawEvent.data === "[DONE]") break;
+			if (!rawEvent.data) continue;
+			const chunk = JSON.parse(rawEvent.data);
+			if (chunk.usage) setRequestContext(c, {
+				inputTokens: chunk.usage.prompt_tokens,
+				outputTokens: chunk.usage.completion_tokens
+			});
+			const googleChunk = translateChunkToGoogle(chunk, streamState);
+			if (googleChunk) await stream.writeSSE({ data: JSON.stringify(googleChunk) });
 		}
 	});
 }
-const isNonStreaming$1 = (response) => Object.hasOwn(response, "choices");
-
-//#endregion
-//#region src/routes/chat-completions/route.ts
-const completionRoutes = new Hono();
-completionRoutes.post("/", async (c) => {
-	try {
-		return await handleCompletion$1(c);
-	} catch (error) {
-		return await forwardError(c, error);
+/**
+* Convert an OpenAI ChatCompletions payload to a Responses API payload.
+*/
+function openAIPayloadToResponses(payload) {
+	const instructions = payload.messages.filter((m) => m.role === "system").map((m) => typeof m.content === "string" ? m.content : "").join("\n") || null;
+	const input = convertMessagesToInput(payload.messages);
+	const tools = convertToolsToResponses(payload.tools);
+	const toolChoice = convertToolChoiceToResponses(payload.tool_choice);
+	return {
+		model: payload.model,
+		input,
+		instructions,
+		temperature: payload.temperature ?? null,
+		top_p: payload.top_p ?? null,
+		max_output_tokens: payload.max_tokens ?? null,
+		tools,
+		tool_choice: toolChoice,
+		stream: payload.stream ?? null,
+		store: false,
+		parallel_tool_calls: true
+	};
+}
+/**
+* Convert OpenAI messages to Responses API input items.
+*/
+function convertMessagesToInput(messages) {
+	const input = [];
+	for (const msg of messages) {
+		if (msg.role === "system") continue;
+		switch (msg.role) {
+			case "user":
+				input.push(createResponseMessage("user", typeof msg.content === "string" ? msg.content : ""));
+				break;
+			case "assistant":
+				if (msg.content) input.push(createResponseMessage("assistant", typeof msg.content === "string" ? msg.content : ""));
+				if (msg.tool_calls) for (const tc of msg.tool_calls) input.push({
+					type: "function_call",
+					call_id: tc.id,
+					name: tc.function.name,
+					arguments: tc.function.arguments,
+					status: "completed"
+				});
+				break;
+			case "tool":
+				input.push({
+					type: "function_call_output",
+					call_id: msg.tool_call_id ?? "",
+					output: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content)
+				});
+				break;
+		}
 	}
-});
-
-//#endregion
-//#region src/services/copilot/create-embeddings.ts
-const createEmbeddings = async (payload) => {
-	if (!state.copilotToken) throw new Error("Copilot token not found");
-	const response = await fetchWithRetry(`${copilotBaseUrl(state)}/embeddings`, {
-		method: "POST",
-		headers: copilotHeaders(state),
-		body: JSON.stringify(payload)
+	return input;
+}
+/**
+* Convert OpenAI tools to Responses API tools.
+*/
+function convertToolsToResponses(tools) {
+	return tools?.map((t) => ({
+		type: "function",
+		name: t.function.name,
+		description: t.function.description ?? null,
+		parameters: t.function.parameters,
+		strict: false
+	})) ?? null;
+}
+/**
+* Convert OpenAI tool_choice to Responses API tool_choice.
+*/
+function convertToolChoiceToResponses(toolChoice) {
+	if (typeof toolChoice === "string") return toolChoice;
+	if (toolChoice && typeof toolChoice === "object" && "function" in toolChoice) return {
+		type: "function",
+		name: toolChoice.function.name
+	};
+	return "auto";
+}
+function createResponseMessage(role, content) {
+	return {
+		type: "message",
+		role,
+		content
+	};
+}
+async function handleWithResponsesApi$1(c, payload, isStream) {
+	const responsesPayload = openAIPayloadToResponses(payload);
+	logger$2.debug("Translated Responses payload:", JSON.stringify(responsesPayload));
+	const response = await createResponses(responsesPayload, {
+		vision: false,
+		initiator: "user"
 	});
-	if (!response.ok) throw new HTTPError("Failed to create embeddings", response);
-	return await response.json();
-};
+	if (!isStream || !isAsyncIterable$2(response)) {
+		const result = response;
+		logger$2.debug("Non-streaming Responses result:", JSON.stringify(result).slice(-400));
+		if (result.usage) setRequestContext(c, {
+			inputTokens: result.usage.input_tokens,
+			outputTokens: result.usage.output_tokens
+		});
+		const googleResponse = translateResponsesResultToGoogle(result);
+		return c.json(googleResponse);
+	}
+	logger$2.debug("Streaming response from Copilot (Responses API)");
+	return streamSSE(c, async (stream) => {
+		const streamState = createGoogleStreamState();
+		for await (const chunk of response) {
+			if (chunk.event === "ping") continue;
+			const data = chunk.data;
+			if (!data) continue;
+			logger$2.debug("Responses raw stream event:", data);
+			const parsed = JSON.parse(data);
+			const googleChunk = translateResponsesStreamEventToGoogle(parsed, streamState);
+			if (googleChunk) {
+				if (parsed.type === "response.completed" || parsed.type === "response.incomplete") {
+					const usage = parsed.response.usage;
+					if (usage) setRequestContext(c, {
+						inputTokens: usage.input_tokens,
+						outputTokens: usage.output_tokens
+					});
+				}
+				await stream.writeSSE({ data: JSON.stringify(googleChunk) });
+			}
+		}
+	});
+}
+const isNonStreamingCC = (response) => Object.hasOwn(response, "choices");
+const isAsyncIterable$2 = (value) => Boolean(value) && typeof value[Symbol.asyncIterator] === "function";
 
 //#endregion
-//#region src/routes/embeddings/route.ts
-const embeddingRoutes = new Hono();
-embeddingRoutes.post("/", async (c) => {
+//#region src/routes/google-ai/route.ts
+const googleAIRoutes = new Hono();
+googleAIRoutes.post("/:modelAction", async (c) => {
 	try {
-		const paylod = await c.req.json();
-		const response = await createEmbeddings(paylod);
-		return c.json(response);
+		return await handleGoogleAI(c);
 	} catch (error) {
 		return await forwardError(c, error);
 	}
@@ -2363,141 +3211,6 @@ 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$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);
-		});
-	}
-	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";
@@ -4046,21 +4759,6 @@ responsesRoutes.post("/", async (c) => {
 	}
 });
 
-//#endregion
-//#region src/routes/token/route.ts
-const tokenRoute = new Hono();
-tokenRoute.get("/", (c) => {
-	try {
-		return c.json({ token: state.copilotToken });
-	} catch (error) {
-		console.error("Error fetching token:", error);
-		return c.json({
-			error: "Failed to fetch token",
-			token: null
-		}, 500);
-	}
-});
-
 //#endregion
 //#region src/routes/usage/route.ts
 const usageRoute = new Hono();
@@ -4086,7 +4784,6 @@ server.route("/chat/completions", completionRoutes);
 server.route("/models", modelRoutes);
 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);
@@ -4094,6 +4791,8 @@ server.route("/v1/models", modelRoutes);
 server.route("/v1/embeddings", embeddingRoutes);
 server.route("/v1/responses", responsesRoutes);
 server.route("/v1/messages", messageRoutes);
+server.route("/v1/models", googleAIRoutes);
+server.route("/models", googleAIRoutes);
 
 //#endregion
 //#region src/start.ts