heibaiapi 0.6.2 → 0.7.0

package/dist/main.js

@@ -5,11 +5,11 @@ import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { randomUUID } from "node:crypto";
-import { getProxyForUrl } from "proxy-from-env";
-import { Agent, ProxyAgent, setGlobalDispatcher } from "undici";
 import clipboard from "clipboardy";
 import { serve } from "srvx";
 import invariant from "tiny-invariant";
+import { getProxyForUrl } from "proxy-from-env";
+import { Agent, ProxyAgent, setGlobalDispatcher } from "undici";
 import { execSync } from "node:child_process";
 import process$1 from "node:process";
 import { Hono } from "hono";
@@ -17,21 +17,17 @@ import { cors } from "hono/cors";
 import { logger } from "hono/logger";
 import { streamSSE } from "hono/streaming";
 import { events } from "fetch-event-stream";
-import fs$1 from "node:fs";
 
 //#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 CONFIG_PATH = path.join(APP_DIR, "config.json");
 const PATHS = {
 	APP_DIR,
-	GITHUB_TOKEN_PATH,
-	CONFIG_PATH
+	GITHUB_TOKEN_PATH
 };
 async function ensurePaths() {
 	await fs.mkdir(PATHS.APP_DIR, { recursive: true });
 	await ensureFile(PATHS.GITHUB_TOKEN_PATH);
-	await ensureFile(PATHS.CONFIG_PATH);
 }
 async function ensureFile(filePath) {
 	try {
@@ -796,10 +792,8 @@ async function handleCompletion$1(c) {
 	consola.debug("Request payload:", JSON.stringify(payload).slice(-400));
 	const selectedModel = state.models?.data.find((model) => model.id === payload.model);
 	try {
-		if (selectedModel) {
-			const tokenCount = await getTokenCount(payload, selectedModel);
-			consola.info("Current token count:", tokenCount);
-		} else consola.warn("No model selected, skipping token count calculation");
+		if (selectedModel) consola.info(`[ModelTranslation_OpenAI] 客户端请求: ${payload.model} -> 服务端使用: ${selectedModel.id}`);
+		else consola.warn("No model selected, skipping token count calculation");
 	} catch (error) {
 		consola.warn("Failed to calculate token count:", error);
 	}
@@ -891,9 +885,14 @@ function translateToOpenAI(payload) {
 	};
 }
 function translateModelName(model) {
-	if (model.startsWith("claude-sonnet-4-")) return model.replace(/^claude-sonnet-4-.*/, "claude-sonnet-4");
-	else if (model.startsWith("claude-opus-")) return model.replace(/^claude-opus-4-.*/, "claude-opus-4");
-	return model;
+	let serverModel;
+	serverModel = model;
+	if (model.includes("claude-3-5")) serverModel = "claude-3.5-sonnet";
+	else if (model.includes("claude-opus")) serverModel = "claude-sonnet-4.5";
+	else if (model.includes("claude-sonnet-4.5")) serverModel = "claude-sonnet-4.5";
+	else if (model.includes("claude-sonnet-4")) serverModel = "claude-sonnet-4";
+	consola.info(`[ModelTranslation] 客户端请求: ${model} -> 服务端使用: ${serverModel}`);
+	return serverModel;
 }
 function translateAnthropicMessagesToOpenAI(anthropicMessages, system) {
 	const systemMessages = handleSystemPrompt(system);
@@ -1084,7 +1083,6 @@ async function handleCountTokens(c) {
 		let finalTokenCount = tokenCount.input + tokenCount.output;
 		if (anthropicPayload.model.startsWith("claude")) finalTokenCount = Math.round(finalTokenCount * 1.15);
 		else if (anthropicPayload.model.startsWith("grok")) finalTokenCount = Math.round(finalTokenCount * 1.03);
-		consola.info("Token count:", finalTokenCount);
 		return c.json({ input_tokens: finalTokenCount });
 	} catch (error) {
 		consola.error("Error counting tokens:", error);
@@ -1092,805 +1090,6 @@ async function handleCountTokens(c) {
 	}
 }
 
-//#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
-	};
-	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/lib/config.ts
-const defaultConfig = { extraPrompts: { "gpt-5-codex": `
-## Tool use
-- You have access to many tools. If a tool exists to perform a specific task, you MUST use that tool instead of running a terminal command to perform that task.
-### Bash tool
-When using the Bash tool, follow these rules:
-- always run_in_background set to false, unless you are running a long-running command (e.g., a server or a watch command).
-### BashOutput tool
-When using the BashOutput tool, follow these rules:
-- Only Bash Tool run_in_background set to true, Use BashOutput to read the output later
-### TodoWrite tool
-When using the TodoWrite tool, follow these rules:
-- Skip using the TodoWrite tool for tasks with three or fewer steps.
-- Do not make single-step todo lists.
-- When you made a todo, update it after having performed one of the sub-tasks that you shared on the todo list.
-## Special user requests
-- If the user makes a simple request (such as asking for the time) which you can fulfill by running a terminal command (such as 'date'), you should do so.
-` } };
-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.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 getConfig() {
-	if (!cachedConfig) cachedConfig = readConfigFromDisk();
-	return cachedConfig;
-}
-function getExtraPromptForModel(model) {
-	return getConfig().extraPrompts?.[model] ?? "";
-}
-
-//#endregion
-//#region src/routes/messages/responses-translation.ts
-const MESSAGE_TYPE = "message";
-const translateAnthropicMessagesToResponsesPayload = (payload) => {
-	const input = [];
-	for (const message of payload.messages) input.push(...translateMessage(message));
-	const translatedTools = convertAnthropicTools(payload.tools);
-	const toolChoice = convertAnthropicToolChoice(payload.tool_choice);
-	const { safetyIdentifier, promptCacheKey } = parseUserId(payload.metadata?.user_id);
-	return {
-		model: payload.model,
-		input,
-		instructions: translateSystemPrompt(payload.system, payload.model),
-		temperature: payload.temperature ?? null,
-		top_p: payload.top_p ?? null,
-		max_output_tokens: payload.max_tokens,
-		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: "high",
-			summary: "detailed"
-		},
-		include: ["reasoning.encrypted_content"]
-	};
-};
-const translateMessage = (message) => {
-	if (message.role === "user") return translateUserMessage(message);
-	return translateAssistantMessage(message);
-};
-const translateUserMessage = (message) => {
-	if (typeof message.content === "string") return [createMessage("user", message.content)];
-	if (!Array.isArray(message.content)) return [];
-	const items = [];
-	const pendingContent = [];
-	for (const block of message.content) {
-		if (block.type === "tool_result") {
-			flushPendingContent("user", pendingContent, items);
-			items.push(createFunctionCallOutput(block));
-			continue;
-		}
-		const converted = translateUserContentBlock(block);
-		if (converted) pendingContent.push(converted);
-	}
-	flushPendingContent("user", pendingContent, items);
-	return items;
-};
-const translateAssistantMessage = (message) => {
-	if (typeof message.content === "string") return [createMessage("assistant", message.content)];
-	if (!Array.isArray(message.content)) return [];
-	const items = [];
-	const pendingContent = [];
-	for (const block of message.content) {
-		if (block.type === "tool_use") {
-			flushPendingContent("assistant", pendingContent, items);
-			items.push(createFunctionToolCall(block));
-			continue;
-		}
-		if (block.type === "thinking" && block.signature && block.signature.includes("@")) {
-			flushPendingContent("assistant", pendingContent, items);
-			items.push(createReasoningContent(block));
-			continue;
-		}
-		const converted = translateAssistantContentBlock(block);
-		if (converted) pendingContent.push(converted);
-	}
-	flushPendingContent("assistant", pendingContent, items);
-	return items;
-};
-const translateUserContentBlock = (block) => {
-	switch (block.type) {
-		case "text": return createTextContent(block.text);
-		case "image": return createImageContent(block);
-		default: return;
-	}
-};
-const translateAssistantContentBlock = (block) => {
-	switch (block.type) {
-		case "text": return createOutPutTextContent(block.text);
-		default: return;
-	}
-};
-const flushPendingContent = (role, pendingContent, target) => {
-	if (pendingContent.length === 0) return;
-	const messageContent = [...pendingContent];
-	target.push(createMessage(role, messageContent));
-	pendingContent.length = 0;
-};
-const createMessage = (role, content) => ({
-	type: MESSAGE_TYPE,
-	role,
-	content
-});
-const createTextContent = (text) => ({
-	type: "input_text",
-	text
-});
-const createOutPutTextContent = (text) => ({
-	type: "output_text",
-	text
-});
-const createImageContent = (block) => ({
-	type: "input_image",
-	image_url: `data:${block.source.media_type};base64,${block.source.data}`,
-	detail: "auto"
-});
-const createReasoningContent = (block) => {
-	const array = block.signature.split("@");
-	const signature = array[0];
-	return {
-		id: array[1],
-		type: "reasoning",
-		summary: [{
-			type: "summary_text",
-			text: block.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;
-		}
-	};
-	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") return "end_turn";
-	if (status === "incomplete") {
-		if (incompleteDetails?.reason === "max_output_tokens") return "max_tokens";
-		if (incompleteDetails?.reason === "content_filter") return "end_turn";
-	}
-	return null;
-};
-const mapResponsesUsage = (response) => {
-	const inputTokens = response.usage?.input_tokens ?? 0;
-	const outputTokens = response.usage?.output_tokens ?? 0;
-	return {
-		input_tokens: inputTokens - (response.usage?.input_tokens_details?.cached_tokens ?? 0),
-		output_tokens: outputTokens,
-		...response.usage?.input_tokens_details?.cached_tokens !== void 0 && { cache_read_input_tokens: response.usage.input_tokens_details.cached_tokens }
-	};
-};
-const isRecord = (value) => typeof value === "object" && value !== null;
-const isResponseOutputText = (block) => isRecord(block) && "type" in block && block.type === "output_text";
-const isResponseOutputRefusal = (block) => isRecord(block) && "type" in block && block.type === "refusal";
-const parseUserId = (userId) => {
-	if (!userId || typeof userId !== "string") return {
-		safetyIdentifier: null,
-		promptCacheKey: null
-	};
-	const userMatch = userId.match(/user_([^_]+)_account/);
-	const safetyIdentifier = userMatch ? userMatch[1] : null;
-	const sessionMatch = userId.match(/_session_(.+)$/);
-	return {
-		safetyIdentifier,
-		promptCacheKey: sessionMatch ? sessionMatch[1] : null
-	};
-};
-const convertToolResultContent = (content) => {
-	if (typeof content === "string") return content;
-	if (Array.isArray(content)) {
-		const result = [];
-		for (const block of content) switch (block.type) {
-			case "text":
-				result.push(createTextContent(block.text));
-				break;
-			case "image":
-				result.push(createImageContent(block));
-				break;
-			default: break;
-		}
-		return result;
-	}
-	return "";
-};
-
-//#endregion
-//#region src/routes/messages/responses-stream-translation.ts
-const 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) => {
-	const eventType = rawEvent.type;
-	switch (eventType) {
-		case "response.created": return handleResponseCreated(rawEvent, state$1);
-		case "response.output_item.added": return handleOutputItemAdded(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(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:
-			consola.debug("Unknown Responses stream event type:", eventType);
-			return [];
-	}
-};
-const handleResponseCreated = (rawEvent, state$1) => {
-	return messageStart(state$1, rawEvent.response);
-};
-const handleOutputItemAdded = (rawEvent, state$1) => {
-	const events$1 = new Array();
-	const functionCallDetails = extractFunctionCallDetails(rawEvent);
-	if (!functionCallDetails) return events$1;
-	const { outputIndex, toolCallId, name, initialArguments } = functionCallDetails;
-	const blockIndex = openFunctionCallBlock(state$1, {
-		outputIndex,
-		toolCallId,
-		name,
-		events: events$1
-	});
-	if (initialArguments !== void 0 && initialArguments.length > 0) {
-		events$1.push({
-			type: "content_block_delta",
-			index: blockIndex,
-			delta: {
-				type: "input_json_delta",
-				partial_json: initialArguments
-			}
-		});
-		state$1.blockHasDelta.add(blockIndex);
-	}
-	return events$1;
-};
-const handleOutputItemDone = (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) {
-		events$1.push({
-			type: "content_block_delta",
-			index: blockIndex,
-			delta: {
-				type: "signature_delta",
-				signature
-			}
-		});
-		state$1.blockHasDelta.add(blockIndex);
-	}
-	closeBlockIfOpen(state$1, blockIndex, events$1);
-	return events$1;
-};
-const handleFunctionCallArgumentsDelta = (rawEvent, state$1) => {
-	const events$1 = new Array();
-	const outputIndex = rawEvent.output_index;
-	const deltaText = rawEvent.delta;
-	const blockIndex = openFunctionCallBlock(state$1, {
-		outputIndex,
-		events: events$1
-	});
-	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);
-	}
-	closeBlockIfOpen(state$1, blockIndex, events$1);
-	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
-		}
-	});
-	closeBlockIfOpen(state$1, blockIndex, events$1);
-	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 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,
-				...inputCachedTokens !== void 0 && { cache_creation_input_tokens: inputCachedTokens }
-			}
-		}
-	}];
-};
-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)) {
-		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)) {
-		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 closeAllOpenBlocks = (state$1, events$1) => {
-	for (const blockIndex of state$1.openBlocks) closeBlockIfOpen(state$1, blockIndex, events$1);
-	state$1.functionCallStateByOutputIndex.clear();
-};
-const buildErrorEvent = (message) => ({
-	type: "error",
-	error: {
-		type: "api_error",
-		message
-	}
-});
-const getBlockKey = (outputIndex, contentIndex) => `${outputIndex}:${contentIndex}`;
-const openFunctionCallBlock = (state$1, params) => {
-	const { outputIndex, toolCallId, name, events: events$1 } = params;
-	let functionCallState = state$1.functionCallStateByOutputIndex.get(outputIndex);
-	if (!functionCallState) {
-		const blockIndex$1 = state$1.nextContentBlockIndex;
-		state$1.nextContentBlockIndex += 1;
-		functionCallState = {
-			blockIndex: blockIndex$1,
-			toolCallId: toolCallId ?? `tool_call_${blockIndex$1}`,
-			name: name ?? "function"
-		};
-		state$1.functionCallStateByOutputIndex.set(outputIndex, functionCallState);
-	}
-	const { blockIndex } = functionCallState;
-	if (!state$1.openBlocks.has(blockIndex)) {
-		events$1.push({
-			type: "content_block_start",
-			index: blockIndex,
-			content_block: {
-				type: "tool_use",
-				id: functionCallState.toolCallId,
-				name: functionCallState.name,
-				input: {}
-			}
-		});
-		state$1.openBlocks.add(blockIndex);
-	}
-	return blockIndex;
-};
-const extractFunctionCallDetails = (rawEvent) => {
-	const item = rawEvent.item;
-	if (item.type !== "function_call") return;
-	return {
-		outputIndex: rawEvent.output_index,
-		toolCallId: item.call_id,
-		name: item.name,
-		initialArguments: item.arguments
-	};
-};
-
-//#endregion
-//#region src/routes/responses/utils.ts
-const getResponsesRequestOptions = (payload) => {
-	return {
-		vision: hasVisionInput(payload),
-		initiator: hasAgentInitiator(payload) ? "agent" : "user"
-	};
-};
-const hasAgentInitiator = (payload) => getPayloadItems(payload).some((item) => {
-	if (!("role" in item) || !item.role) return true;
-	return (typeof item.role === "string" ? item.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/routes/messages/stream-translation.ts
 function isToolBlockOpen(state$1) {
@@ -2021,15 +1220,9 @@ async function handleCompletion(c) {
 	await checkRateLimit(state);
 	const anthropicPayload = await c.req.json();
 	consola.debug("Anthropic request payload:", JSON.stringify(anthropicPayload));
-	const useResponsesApi = shouldUseResponsesApi(anthropicPayload.model);
-	if (state.manualApprove) await awaitApproval();
-	if (useResponsesApi) return await handleWithResponsesApi(c, anthropicPayload);
-	return await handleWithChatCompletions(c, anthropicPayload);
-}
-const RESPONSES_ENDPOINT$1 = "/responses";
-const handleWithChatCompletions = async (c, anthropicPayload) => {
 	const openAIPayload = translateToOpenAI(anthropicPayload);
 	consola.debug("Translated OpenAI request payload:", JSON.stringify(openAIPayload));
+	if (state.manualApprove) await awaitApproval();
 	const response = await createChatCompletions(openAIPayload);
 	if (isNonStreaming(response)) {
 		consola.debug("Non-streaming response from Copilot:", JSON.stringify(response).slice(-400));
@@ -2059,60 +1252,8 @@ const handleWithChatCompletions = async (c, anthropicPayload) => {
 			}
 		}
 	});
-};
-const handleWithResponsesApi = async (c, anthropicPayload) => {
-	const responsesPayload = translateAnthropicMessagesToResponsesPayload(anthropicPayload);
-	consola.debug("Translated Responses payload:", JSON.stringify(responsesPayload));
-	const { vision, initiator } = getResponsesRequestOptions(responsesPayload);
-	const response = await createResponses(responsesPayload, {
-		vision,
-		initiator
-	});
-	if (responsesPayload.stream && isAsyncIterable$1(response)) {
-		consola.debug("Streaming response from Copilot (Responses API)");
-		return streamSSE(c, async (stream) => {
-			const streamState = createResponsesStreamState();
-			for await (const chunk of response) {
-				if (chunk.event === "ping") {
-					await stream.writeSSE({
-						event: "ping",
-						data: ""
-					});
-					continue;
-				}
-				const data = chunk.data;
-				if (!data) continue;
-				consola.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);
-					consola.debug("Translated Anthropic event:", eventData);
-					await stream.writeSSE({
-						event: event.type,
-						data: eventData
-					});
-				}
-			}
-			if (!streamState.messageCompleted) {
-				consola.warn("Responses stream ended without completion; sending fallback message_stop");
-				const fallback = { type: "message_stop" };
-				await stream.writeSSE({
-					event: fallback.type,
-					data: JSON.stringify(fallback)
-				});
-			}
-		});
-	}
-	consola.debug("Non-streaming Responses result:", JSON.stringify(response).slice(-400));
-	const anthropicResponse = translateResponsesResultToAnthropic(response);
-	consola.debug("Translated Anthropic response:", JSON.stringify(anthropicResponse));
-	return c.json(anthropicResponse);
-};
-const shouldUseResponsesApi = (modelId) => {
-	return (state.models?.data.find((model) => model.id === modelId))?.supported_endpoints?.includes(RESPONSES_ENDPOINT$1) ?? false;
-};
+}
 const isNonStreaming = (response) => Object.hasOwn(response, "choices");
-const isAsyncIterable$1 = (value) => Boolean(value) && typeof value[Symbol.asyncIterator] === "function";
 
 //#endregion
 //#region src/routes/messages/route.ts
@@ -2157,68 +1298,6 @@ modelRoutes.get("/", async (c) => {
 	}
 });
 
-//#endregion
-//#region src/routes/responses/handler.ts
-const RESPONSES_ENDPOINT = "/responses";
-const handleResponses = async (c) => {
-	await checkRateLimit(state);
-	const payload = await c.req.json();
-	consola.debug("Responses request payload:", JSON.stringify(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)) {
-		consola.debug("Forwarding native Responses stream");
-		return streamSSE(c, async (stream) => {
-			const pingInterval = setInterval(async () => {
-				try {
-					await stream.writeSSE({
-						event: "ping",
-						data: JSON.stringify({ timestamp: Date.now() })
-					});
-				} catch (error) {
-					consola.warn("Failed to send ping:", error);
-					clearInterval(pingInterval);
-				}
-			}, 3e3);
-			try {
-				for await (const chunk of response) {
-					consola.debug("Responses stream chunk:", JSON.stringify(chunk));
-					await stream.writeSSE({
-						id: chunk.id,
-						event: chunk.event,
-						data: chunk.data ?? ""
-					});
-				}
-			} finally {
-				clearInterval(pingInterval);
-			}
-		});
-	}
-	consola.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);
-
-//#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();
@@ -2258,16 +1337,15 @@ server.route("/models", modelRoutes);
 server.route("/embeddings", embeddingRoutes);
 server.route("/usage", usageRoute);
 server.route("/token", tokenRoute);
-server.route("/responses", responsesRoutes);
 server.route("/v1/chat/completions", completionRoutes);
 server.route("/v1/models", modelRoutes);
 server.route("/v1/embeddings", embeddingRoutes);
-server.route("/v1/responses", responsesRoutes);
 server.route("/v1/messages", messageRoutes);
 
 //#endregion
 //#region src/start.ts
 async function runServer(options) {
+	if (options.proxyEnv) initProxyFromEnv();
 	if (options.verbose) {
 		consola.level = 5;
 		consola.info("Verbose logging enabled");
@@ -2377,6 +1455,11 @@ const start = defineCommand({
 			type: "boolean",
 			default: false,
 			description: "Show GitHub and Copilot tokens on fetch and refresh"
+		},
+		"proxy-env": {
+			type: "boolean",
+			default: false,
+			description: "Initialize proxy from environment variables"
 		}
 	},
 	run({ args }) {
@@ -2391,14 +1474,15 @@ const start = defineCommand({
 			rateLimitWait: args.wait,
 			githubToken: args["github-token"],
 			claudeCode: args["claude-code"],
-			showToken: args["show-token"]
+			showToken: args["show-token"],
+			proxyEnv: args["proxy-env"]
 		});
 	}
 });
 
 //#endregion
 //#region src/main.ts
-const main = defineCommand({
+await runMain(defineCommand({
 	meta: {
 		name: "copilot-api",
 		description: "A wrapper around GitHub Copilot API to make it OpenAI compatible, making it usable for other tools."
@@ -2409,9 +1493,7 @@ const main = defineCommand({
 		"check-usage": checkUsage,
 		debug
 	}
-});
-initProxyFromEnv();
-await runMain(main);
+}));
 
 //#endregion
 export {  };