heibaiapi 0.6.1 → 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";
@@ -19,7 +19,7 @@ import { streamSSE } from "hono/streaming";
 import { events } from "fetch-event-stream";
 
 //#region src/lib/paths.ts
-const APP_DIR = path.join(os.homedir(), ".local", "share", "heibaiapi");
+const APP_DIR = path.join(os.homedir(), ".local", "share", "copilot-api");
 const GITHUB_TOKEN_PATH = path.join(APP_DIR, "github_token");
 const PATHS = {
 	APP_DIR,
@@ -401,7 +401,7 @@ async function getDebugInfo() {
 	};
 }
 function printDebugInfoPlain(info) {
-	consola.info(`heibaiapi debug
+	consola.info(`copilot-api debug
 
 Version: ${info.version}
 Runtime: ${info.runtime.name} ${info.runtime.version} (${info.runtime.platform} ${info.runtime.arch})
@@ -487,8 +487,7 @@ function getShell() {
 	const { platform, ppid, env } = process$1;
 	if (platform === "win32") {
 		try {
-			const command = `wmic process get ParentProcessId,Name | findstr "${ppid}"`;
-			if (execSync(command, { stdio: "pipe" }).toString().toLowerCase().includes("powershell.exe")) return "powershell";
+			if (execSync(`wmic process get ParentProcessId,Name | findstr "${ppid}"`, { stdio: "pipe" }).toString().toLowerCase().includes("powershell.exe")) return "powershell";
 		} catch {
 			return "cmd";
 		}
@@ -748,8 +747,7 @@ const numTokensForTools = (tools, encoder, constants) => {
 * Calculate the token count of messages, supporting multiple GPT encoders
 */
 const getTokenCount = async (payload, model) => {
-	const tokenizer = getTokenizerFromModel(model);
-	const encoder = await getEncodeChatFunction(tokenizer);
+	const encoder = await getEncodeChatFunction(getTokenizerFromModel(model));
 	const simplifiedMessages = payload.messages;
 	const inputMessages = simplifiedMessages.filter((msg) => msg.role !== "assistant");
 	const outputMessages = simplifiedMessages.filter((msg) => msg.role === "assistant");
@@ -794,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);
 	}
@@ -853,8 +849,7 @@ const createEmbeddings = async (payload) => {
 const embeddingRoutes = new Hono();
 embeddingRoutes.post("/", async (c) => {
 	try {
-		const paylod = await c.req.json();
-		const response = await createEmbeddings(paylod);
+		const response = await createEmbeddings(await c.req.json());
 		return c.json(response);
 	} catch (error) {
 		return await forwardError(c, error);
@@ -890,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);
@@ -1083,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);
@@ -1091,850 +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/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),
-		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: "auto"
-		},
-		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") {
-			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.length === 1 && isPlainText(pendingContent[0]) ? pendingContent[0].text : [...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}`
-});
-const createReasoningContent = (block) => ({
-	type: "reasoning",
-	summary: [{
-		type: "summary_text",
-		text: block.thinking
-	}],
-	encrypted_content: block.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) => {
-	if (!system) return null;
-	const toolUsePrompt = `
-## 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 simple or straightforward tasks (roughly the easiest 25%).
-- 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.`;
-	if (typeof system === "string") return system + toolUsePrompt;
-	const text = system.map((block, index) => {
-		if (index === 0) return block.text + toolUsePrompt;
-		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;
-	switch (choice.type) {
-		case "auto": return "auto";
-		case "any": return "required";
-		case "tool": return choice.name ? {
-			type: "function",
-			name: choice.name
-		} : void 0;
-		case "none": return "none";
-		default: return;
-	}
-};
-const isPlainText = (content) => {
-	if (typeof content !== "object") return false;
-	return "text" in content && typeof content.text === "string" && !("image_url" in content);
-};
-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 ?? ""
-			});
-			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 ?? 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";
-		if (incompleteDetails?.reason === "tool_use") return "tool_use";
-	}
-	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$1 = (value) => typeof value === "object" && value !== null;
-const isResponseOutputText = (block) => isRecord$1(block) && "type" in block && block.type === "output_text";
-const isResponseOutputRefusal = (block) => isRecord$1(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 createResponsesStreamState = () => ({
-	messageStartSent: false,
-	messageCompleted: false,
-	nextContentBlockIndex: 0,
-	blockIndexByKey: /* @__PURE__ */ new Map(),
-	openBlocks: /* @__PURE__ */ new Set(),
-	blockHasDelta: /* @__PURE__ */ new Set(),
-	functionCallStateByOutputIndex: /* @__PURE__ */ new Map(),
-	functionCallOutputIndexByItemId: /* @__PURE__ */ new Map()
-});
-const translateResponsesStreamEvent = (rawEvent, state$1) => {
-	const eventType = typeof rawEvent.type === "string" ? rawEvent.type : void 0;
-	if (!eventType) return [];
-	switch (eventType) {
-		case "response.created": return handleResponseCreated(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_part.done": return handleReasoningSummaryPartDone(rawEvent, state$1);
-		case "response.output_text.done": return handleOutputTextDone(rawEvent, state$1);
-		case "response.output_item.added": return handleOutputItemAdded(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: return [];
-	}
-};
-const handleResponseCreated = (rawEvent, state$1) => {
-	const response = toResponsesResult(rawEvent.response);
-	if (response) cacheResponseMetadata(state$1, response);
-	return ensureMessageStart(state$1, response);
-};
-const handleOutputItemAdded = (rawEvent, state$1) => {
-	const response = toResponsesResult(rawEvent.response);
-	const events$1 = ensureMessageStart(state$1, response);
-	const functionCallDetails = extractFunctionCallDetails(rawEvent, state$1);
-	if (!functionCallDetails) return events$1;
-	const { outputIndex, toolCallId, name, initialArguments, itemId } = functionCallDetails;
-	if (itemId) state$1.functionCallOutputIndexByItemId.set(itemId, outputIndex);
-	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 = ensureMessageStart(state$1);
-	const item = isRecord(rawEvent.item) ? rawEvent.item : void 0;
-	if (!item) return events$1;
-	if ((typeof item.type === "string" ? item.type : void 0) !== "reasoning") return events$1;
-	const outputIndex = toNumber(rawEvent.output_index);
-	const blockIndex = openThinkingBlockIfNeeded(state$1, outputIndex, events$1);
-	const signature = typeof item.encrypted_content === "string" ? item.encrypted_content : "";
-	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 = ensureMessageStart(state$1);
-	const outputIndex = resolveFunctionCallOutputIndex(state$1, rawEvent);
-	if (outputIndex === void 0) return events$1;
-	const deltaText = typeof rawEvent.delta === "string" ? rawEvent.delta : "";
-	if (!deltaText) return events$1;
-	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 = ensureMessageStart(state$1);
-	const outputIndex = resolveFunctionCallOutputIndex(state$1, rawEvent);
-	if (outputIndex === void 0) return events$1;
-	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);
-	const existingState = state$1.functionCallStateByOutputIndex.get(outputIndex);
-	if (existingState) state$1.functionCallOutputIndexByItemId.delete(existingState.toolCallId);
-	state$1.functionCallStateByOutputIndex.delete(outputIndex);
-	const itemId = toNonEmptyString(rawEvent.item_id);
-	if (itemId) state$1.functionCallOutputIndexByItemId.delete(itemId);
-	return events$1;
-};
-const handleOutputTextDelta = (rawEvent, state$1) => {
-	const events$1 = ensureMessageStart(state$1);
-	const outputIndex = toNumber(rawEvent.output_index);
-	const contentIndex = toNumber(rawEvent.content_index);
-	const deltaText = typeof rawEvent.delta === "string" ? 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 events$1 = ensureMessageStart(state$1);
-	const outputIndex = toNumber(rawEvent.output_index);
-	const deltaText = typeof rawEvent.delta === "string" ? rawEvent.delta : "";
-	if (!deltaText) return events$1;
-	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 handleReasoningSummaryPartDone = (rawEvent, state$1) => {
-	const events$1 = ensureMessageStart(state$1);
-	const outputIndex = toNumber(rawEvent.output_index);
-	const part = isRecord(rawEvent.part) ? rawEvent.part : void 0;
-	const text = part && typeof part.text === "string" ? part.text : "";
-	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 = ensureMessageStart(state$1);
-	const outputIndex = toNumber(rawEvent.output_index);
-	const contentIndex = toNumber(rawEvent.content_index);
-	const text = typeof rawEvent.text === "string" ? 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 = toResponsesResult(rawEvent.response);
-	const events$1 = ensureMessageStart(state$1, response);
-	closeAllOpenBlocks(state$1, events$1);
-	if (response) {
-		const anthropic = translateResponsesResultToAnthropic(response);
-		events$1.push({
-			type: "message_delta",
-			delta: {
-				stop_reason: anthropic.stop_reason,
-				stop_sequence: anthropic.stop_sequence
-			},
-			usage: anthropic.usage
-		});
-	} else events$1.push({
-		type: "message_delta",
-		delta: {
-			stop_reason: null,
-			stop_sequence: null
-		}
-	});
-	events$1.push({ type: "message_stop" });
-	state$1.messageCompleted = true;
-	return events$1;
-};
-const handleResponseFailed = (rawEvent, state$1) => {
-	const response = toResponsesResult(rawEvent.response);
-	const events$1 = ensureMessageStart(state$1, response);
-	closeAllOpenBlocks(state$1, events$1);
-	const message = typeof rawEvent.error === "string" ? rawEvent.error : "Response generation failed.";
-	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 ensureMessageStart = (state$1, response) => {
-	if (state$1.messageStartSent) return [];
-	if (response) cacheResponseMetadata(state$1, response);
-	const id = response?.id ?? state$1.currentResponseId ?? "response";
-	const model = response?.model ?? state$1.currentModel ?? "";
-	state$1.messageStartSent = true;
-	const inputTokens = (state$1.initialInputTokens ?? 0) - (state$1.initialInputCachedTokens ?? 0);
-	return [{
-		type: "message_start",
-		message: {
-			id,
-			type: "message",
-			role: "assistant",
-			content: [],
-			model,
-			stop_reason: null,
-			stop_sequence: null,
-			usage: {
-				input_tokens: inputTokens,
-				output_tokens: 0,
-				...state$1.initialInputCachedTokens !== void 0 && { cache_creation_input_tokens: state$1.initialInputCachedTokens }
-			}
-		}
-	}];
-};
-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();
-	state$1.functionCallOutputIndexByItemId.clear();
-};
-const cacheResponseMetadata = (state$1, response) => {
-	state$1.currentResponseId = response.id;
-	state$1.currentModel = response.model;
-	state$1.initialInputTokens = response.usage?.input_tokens ?? 0;
-	state$1.initialInputCachedTokens = response.usage?.input_tokens_details?.cached_tokens;
-};
-const buildErrorEvent = (message) => ({
-	type: "error",
-	error: {
-		type: "api_error",
-		message
-	}
-});
-const getBlockKey = (outputIndex, contentIndex) => `${outputIndex}:${contentIndex}`;
-const resolveFunctionCallOutputIndex = (state$1, rawEvent) => {
-	if (typeof rawEvent.output_index === "number" || typeof rawEvent.output_index === "string" && rawEvent.output_index.length > 0) {
-		const parsed = toOptionalNumber(rawEvent.output_index);
-		if (parsed !== void 0) return parsed;
-	}
-	const itemId = toNonEmptyString(rawEvent.item_id);
-	if (itemId) {
-		const mapped = state$1.functionCallOutputIndexByItemId.get(itemId);
-		if (mapped !== void 0) return mapped;
-	}
-};
-const openFunctionCallBlock = (state$1, params) => {
-	const { outputIndex, toolCallId, name, events: events$1 } = params;
-	let functionCallState = state$1.functionCallStateByOutputIndex.get(outputIndex);
-	if (!functionCallState) {
-		const blockIndex$1 = state$1.nextContentBlockIndex;
-		state$1.nextContentBlockIndex += 1;
-		const resolvedToolCallId = toolCallId ?? `tool_call_${blockIndex$1}`;
-		functionCallState = {
-			blockIndex: blockIndex$1,
-			toolCallId: resolvedToolCallId,
-			name: name ?? "function"
-		};
-		state$1.functionCallStateByOutputIndex.set(outputIndex, functionCallState);
-		state$1.functionCallOutputIndexByItemId.set(resolvedToolCallId, outputIndex);
-	}
-	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, state$1) => {
-	const item = isRecord(rawEvent.item) ? rawEvent.item : void 0;
-	if (!item) return;
-	if ((typeof item.type === "string" ? item.type : void 0) !== "function_call") return;
-	const outputIndex = resolveFunctionCallOutputIndex(state$1, rawEvent);
-	if (outputIndex === void 0) return;
-	const callId = toNonEmptyString(item.call_id);
-	const itemId = toNonEmptyString(item.id);
-	const name = toNonEmptyString(item.name) ?? "function";
-	const toolCallId = callId ?? itemId ?? `tool_call_${outputIndex}`;
-	const initialArguments = typeof item.arguments === "string" ? item.arguments : void 0;
-	return {
-		outputIndex,
-		toolCallId,
-		name,
-		initialArguments,
-		itemId
-	};
-};
-const toResponsesResult = (value) => isResponsesResult(value) ? value : void 0;
-const toOptionalNumber = (value) => {
-	if (typeof value === "number" && Number.isFinite(value)) return value;
-	if (typeof value === "string" && value.length > 0) {
-		const parsed = Number(value);
-		if (Number.isFinite(parsed)) return parsed;
-	}
-};
-const toNonEmptyString = (value) => {
-	if (typeof value === "string" && value.length > 0) return value;
-};
-const toNumber = (value) => {
-	if (typeof value === "number" && Number.isFinite(value)) return value;
-	if (typeof value === "string") {
-		const parsed = Number(value);
-		if (Number.isFinite(parsed)) return parsed;
-	}
-	return 0;
-};
-const isResponsesResult = (value) => {
-	if (!isRecord(value)) return false;
-	if (typeof value.id !== "string") return false;
-	if (typeof value.model !== "string") return false;
-	if (!Array.isArray(value.output)) return false;
-	if (typeof value.object !== "string") return false;
-	return true;
-};
-const isRecord = (value) => typeof value === "object" && value !== null;
-
-//#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) => 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) {
@@ -2065,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));
@@ -2093,8 +1242,7 @@ const handleWithChatCompletions = async (c, anthropicPayload) => {
 			consola.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);
+			const events$1 = translateChunkToAnthropicEvents(JSON.parse(rawEvent.data), streamState);
 			for (const event of events$1) {
 				consola.debug("Translated Anthropic event:", JSON.stringify(event));
 				await stream.writeSSE({
@@ -2104,70 +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) {
-				consola.debug("Responses raw stream event:", JSON.stringify(chunk));
-				if (chunk.event === "ping") {
-					await stream.writeSSE({
-						event: "ping",
-						data: ""
-					});
-					continue;
-				}
-				const data = chunk.data;
-				if (!data) continue;
-				if (data === "[DONE]") break;
-				const parsed = safeJsonParse(data);
-				if (!parsed) continue;
-				const events$1 = translateResponsesStreamEvent(parsed, streamState);
-				for (const event of events$1) {
-					consola.debug("Translated Anthropic event:", JSON.stringify(event));
-					await stream.writeSSE({
-						event: event.type,
-						data: JSON.stringify(event)
-					});
-				}
-			}
-			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";
-const safeJsonParse = (value) => {
-	try {
-		return JSON.parse(value);
-	} catch (error) {
-		consola.warn("Failed to parse Responses stream chunk:", value, error);
-		return;
-	}
-};
 
 //#endregion
 //#region src/routes/messages/route.ts
@@ -2212,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();
@@ -2313,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");
@@ -2432,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 }) {
@@ -2446,16 +1474,17 @@ 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: "heibaiapi",
+		name: "copilot-api",
 		description: "A wrapper around GitHub Copilot API to make it OpenAI compatible, making it usable for other tools."
 	},
 	subCommands: {
@@ -2464,9 +1493,7 @@ const main = defineCommand({
 		"check-usage": checkUsage,
 		debug
 	}
-});
-initProxyFromEnv();
-await runMain(main);
+}));
 
 //#endregion
 export {  };