@daomar/copilot-api 0.7.2 → 0.8.1

package/dist/main.js

@@ -5,13 +5,14 @@ import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { randomUUID } from "node:crypto";
+import fs$1 from "node:fs";
+import process$1 from "node:process";
+import { execFileSync, execSync } from "node:child_process";
 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";
 import { cors } from "hono/cors";
 import { logger } from "hono/logger";
@@ -363,6 +364,267 @@ const checkUsage = defineCommand({
 	}
 });
 
+//#endregion
+//#region src/lib/agent-config.ts
+const CODEX_CONFIG_PATH = path.join(os.homedir(), ".codex", "config.toml");
+const CLAUDE_SETTINGS_PATH = path.join(os.homedir(), ".claude", "settings.json");
+const DEFAULT_CODEX_MODEL = "gpt-5.5";
+const DEFAULT_CLAUDE_MODEL = "";
+const DEFAULT_CLAUDE_SMALL_MODEL = "";
+const proxyBaseUrl = (host, port) => `http://${host}:${port}`;
+function buildCodexProviderBlock(baseUrl) {
+	return [
+		`[model_providers.copilot]`,
+		`name = "GitHub Copilot"`,
+		`base_url = "${baseUrl}/v1"`,
+		`wire_api = "responses"`,
+		`requires_openai_auth = false`,
+		`http_headers = { "Openai-Intent" = "conversation-edits", "x-initiator" = "user" }`
+	].join("\n");
+}
+const tableHeaderKey = (line) => {
+	const match = /^\s*\[([^[\]]+)\]\s*$/.exec(line);
+	return match ? match[1].trim() : null;
+};
+const isCopilotProviderTable = (key) => key === "model_providers.copilot" || key.startsWith("model_providers.copilot.");
+const firstTableIndex = (lines) => {
+	const index = lines.findIndex((line) => tableHeaderKey(line) !== null);
+	return index === -1 ? lines.length : index;
+};
+function upsertTopLevelKey(content, update) {
+	const { key, value, override } = update;
+	const lines = content.split("\n");
+	const limit = firstTableIndex(lines);
+	const keyRegex = /* @__PURE__ */ new RegExp(`^\\s*${key}\\s*=`);
+	for (let i = 0; i < limit; i++) if (keyRegex.test(lines[i])) {
+		if (override) lines[i] = `${key} = ${value}`;
+		return lines.join("\n");
+	}
+	lines.splice(0, 0, `${key} = ${value}`);
+	return lines.join("\n");
+}
+function upsertCodexProvider(content, block) {
+	const lines = content.split("\n");
+	let start$1 = -1;
+	for (const [i, line] of lines.entries()) if (tableHeaderKey(line) === "model_providers.copilot") {
+		start$1 = i;
+		break;
+	}
+	if (start$1 === -1) {
+		const trimmed = content.replace(/\n*$/, "");
+		return (trimmed.length > 0 ? `${trimmed}\n\n` : "") + `${block}\n`;
+	}
+	let end = lines.length;
+	for (let j = start$1 + 1; j < lines.length; j++) {
+		const key = tableHeaderKey(lines[j]);
+		if (key !== null && !isCopilotProviderTable(key)) {
+			end = j;
+			break;
+		}
+	}
+	let realEnd = end;
+	if (end < lines.length) while (realEnd - 1 > start$1) {
+		const prev = lines[realEnd - 1].trim();
+		if (prev === "" || prev.startsWith("#")) realEnd--;
+		else break;
+	}
+	const beforeText = lines.slice(0, start$1).join("\n").replace(/\n*$/, "");
+	const afterText = lines.slice(realEnd).join("\n").replace(/^\n*/, "");
+	const parts = [];
+	if (beforeText.length > 0) parts.push(beforeText);
+	parts.push(block);
+	if (afterText.length > 0) parts.push(afterText);
+	return `${parts.join("\n\n")}\n`;
+}
+function buildCodexConfig(existing, options) {
+	let next = existing;
+	next = upsertTopLevelKey(next, {
+		key: "model",
+		value: `"${options.codexModel}"`,
+		override: false
+	});
+	next = upsertTopLevelKey(next, {
+		key: "model_provider",
+		value: `"copilot"`,
+		override: true
+	});
+	next = upsertCodexProvider(next, buildCodexProviderBlock(options.baseUrl));
+	return next;
+}
+function buildClaudeSettings(existing, options) {
+	const env = { ...existing.env };
+	env.ANTHROPIC_BASE_URL = options.baseUrl;
+	env.ANTHROPIC_AUTH_TOKEN = "dummy";
+	const defaults = {
+		DISABLE_NON_ESSENTIAL_MODEL_CALLS: "1",
+		CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: "1"
+	};
+	if (options.claudeModel) {
+		defaults.ANTHROPIC_MODEL = options.claudeModel;
+		defaults.ANTHROPIC_DEFAULT_OPUS_MODEL = options.claudeModel;
+		defaults.ANTHROPIC_DEFAULT_SONNET_MODEL = options.claudeModel;
+	}
+	if (options.claudeSmallModel) {
+		defaults.ANTHROPIC_SMALL_FAST_MODEL = options.claudeSmallModel;
+		defaults.ANTHROPIC_DEFAULT_HAIKU_MODEL = options.claudeSmallModel;
+	}
+	for (const [key, value] of Object.entries(defaults)) if (!Object.hasOwn(env, key)) env[key] = value;
+	return {
+		...existing,
+		env
+	};
+}
+const readFileOr = async (filePath, fallback) => {
+	try {
+		return await fs.readFile(filePath, "utf8");
+	} catch {
+		return fallback;
+	}
+};
+const backupFile = async (filePath) => {
+	try {
+		await fs.access(filePath);
+	} catch {
+		return;
+	}
+	const backupPath = `${filePath}.bak`;
+	await fs.copyFile(filePath, backupPath);
+	consola.info(`Backed up existing config to ${backupPath}`);
+};
+async function writeCodexConfig(options) {
+	await fs.mkdir(path.dirname(CODEX_CONFIG_PATH), { recursive: true });
+	const existing = await readFileOr(CODEX_CONFIG_PATH, "");
+	const next = buildCodexConfig(existing, options);
+	if (next !== existing) await backupFile(CODEX_CONFIG_PATH);
+	await fs.writeFile(CODEX_CONFIG_PATH, next);
+	return CODEX_CONFIG_PATH;
+}
+async function writeClaudeSettings(options) {
+	await fs.mkdir(path.dirname(CLAUDE_SETTINGS_PATH), { recursive: true });
+	const raw = await readFileOr(CLAUDE_SETTINGS_PATH, "");
+	let existing = {};
+	if (raw.trim().length > 0) try {
+		existing = JSON.parse(raw);
+	} catch {
+		consola.warn(`Could not parse ${CLAUDE_SETTINGS_PATH}; it will be recreated.`);
+	}
+	const next = buildClaudeSettings(existing, options);
+	if (raw.trim().length > 0) await backupFile(CLAUDE_SETTINGS_PATH);
+	await fs.writeFile(CLAUDE_SETTINGS_PATH, `${JSON.stringify(next, null, 2)}\n`);
+	return CLAUDE_SETTINGS_PATH;
+}
+
+//#endregion
+//#region src/config.ts
+async function pickModel$1(message, fallback) {
+	const ids = state.models?.data.map((model) => model.id) ?? [];
+	if (ids.length === 0) return fallback;
+	return await consola.prompt(message, {
+		type: "select",
+		options: ids,
+		initial: ids.includes(fallback) ? fallback : ids[0]
+	});
+}
+async function runConfig(options) {
+	const doClaude = options.claude || !options.codex;
+	const doCodex = options.codex || !options.claude;
+	let { codexModel } = options;
+	const { claudeModel, claudeSmallModel } = options;
+	if (options.interactive && doCodex) {
+		await ensurePaths();
+		await cacheVSCodeVersion();
+		await setupGitHubToken();
+		await setupCopilotToken();
+		await cacheModels();
+		codexModel = await pickModel$1("Select a model for Codex CLI", codexModel);
+	}
+	const baseUrl = proxyBaseUrl(options.host, options.port);
+	const configOptions = {
+		baseUrl,
+		codexModel,
+		claudeModel,
+		claudeSmallModel
+	};
+	if (doCodex) {
+		const written = await writeCodexConfig(configOptions);
+		consola.success(`Configured Codex CLI (model "${codexModel}") at ${written}`);
+	}
+	if (doClaude) {
+		const written = await writeClaudeSettings(configOptions);
+		consola.success(`Configured Claude Code at ${written}`);
+	}
+	consola.box([
+		`Both tools now route through ${baseUrl}.`,
+		``,
+		`Next steps:`,
+		`  1. Log in once on this machine:  copilot-api auth`,
+		`  2. Start the proxy:              copilot-api start --port ${options.port}`,
+		`  3. Run codex or claude as usual.`
+	].join("\n"));
+}
+const config = defineCommand({
+	meta: {
+		name: "config",
+		description: "Write Codex CLI and Claude Code config files so they use this proxy"
+	},
+	args: {
+		port: {
+			alias: "p",
+			type: "string",
+			default: "4141",
+			description: "Port the proxy listens on"
+		},
+		host: {
+			type: "string",
+			default: "localhost",
+			description: "Host the proxy listens on"
+		},
+		claude: {
+			type: "boolean",
+			default: false,
+			description: "Only configure Claude Code (default: configure both)"
+		},
+		codex: {
+			type: "boolean",
+			default: false,
+			description: "Only configure Codex CLI (default: configure both)"
+		},
+		interactive: {
+			alias: "i",
+			type: "boolean",
+			default: false,
+			description: "Pick models from the live model list (requires GitHub login)"
+		},
+		"codex-model": {
+			type: "string",
+			default: DEFAULT_CODEX_MODEL,
+			description: "Model to use for Codex CLI"
+		},
+		"claude-model": {
+			type: "string",
+			default: DEFAULT_CLAUDE_MODEL,
+			description: "Pin a Claude Code model (optional; default: let the proxy auto-map)"
+		},
+		"claude-small-model": {
+			type: "string",
+			default: DEFAULT_CLAUDE_SMALL_MODEL,
+			description: "Pin a Claude Code small/fast model (optional)"
+		}
+	},
+	run({ args }) {
+		return runConfig({
+			host: args.host,
+			port: Number.parseInt(args.port, 10),
+			codexModel: args["codex-model"],
+			claudeModel: args["claude-model"],
+			claudeSmallModel: args["claude-small-model"],
+			claude: args.claude,
+			codex: args.codex,
+			interactive: args.interactive
+		});
+	}
+});
+
 //#endregion
 //#region src/debug.ts
 async function getPackageVersion() {
@@ -437,6 +699,400 @@ const debug = defineCommand({
 	}
 });
 
+//#endregion
+//#region src/lib/service.ts
+const SERVICE_NAME = "copilot-api";
+const WINDOWS_TASK_NAME = "CopilotAPI";
+const quote = (value) => `"${value.replaceAll("\"", String.raw`\"`)}"`;
+const startCommandArgs = (target) => [
+	"start",
+	"--port",
+	String(target.port),
+	"--account-type",
+	target.accountType
+];
+function buildSystemdUnit(target) {
+	return `[Unit]
+Description=GitHub Copilot API proxy (copilot-api)
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+ExecStart=${[
+		quote(target.runtimePath),
+		quote(target.scriptPath),
+		...startCommandArgs(target)
+	].join(" ")}
+Restart=always
+RestartSec=5
+Environment=NODE_ENV=production
+
+[Install]
+WantedBy=default.target
+`;
+}
+const systemdUnitPath = () => path.join(os.homedir(), ".config", "systemd", "user", `${SERVICE_NAME}.service`);
+const runQuietly = (command, args) => {
+	try {
+		return {
+			ok: true,
+			output: execFileSync(command, args, {
+				stdio: "pipe",
+				encoding: "utf8"
+			})
+		};
+	} catch (error) {
+		const err = error;
+		return {
+			ok: false,
+			output: err.stderr ? err.stderr.toString() : err.message ?? "unknown error"
+		};
+	}
+};
+async function installSystemdService(target) {
+	const unitPath = systemdUnitPath();
+	await fs.mkdir(path.dirname(unitPath), { recursive: true });
+	await fs.writeFile(unitPath, buildSystemdUnit(target));
+	consola.info(`Wrote systemd unit to ${unitPath}`);
+	const reload = runQuietly("systemctl", ["--user", "daemon-reload"]);
+	if (!reload.ok) return {
+		installed: false,
+		manager: "systemd",
+		message: `Failed to reload systemd: ${reload.output.trim()}. Unit written to ${unitPath}.`
+	};
+	const enable = runQuietly("systemctl", [
+		"--user",
+		"enable",
+		"--now",
+		`${SERVICE_NAME}.service`
+	]);
+	if (!enable.ok) return {
+		installed: false,
+		manager: "systemd",
+		message: `Failed to enable service: ${enable.output.trim()}. Try: systemctl --user enable --now ${SERVICE_NAME}.service`
+	};
+	if (!runQuietly("loginctl", ["enable-linger", os.userInfo().username]).ok) consola.warn(`Could not enable lingering (service may stop on logout). Run manually: sudo loginctl enable-linger ${os.userInfo().username}`);
+	return {
+		installed: true,
+		manager: "systemd",
+		message: `Service enabled. Manage with: systemctl --user status ${SERVICE_NAME}`
+	};
+}
+function buildWindowsTaskXml(target) {
+	const command = target.runtimePath;
+	const args = [quote(target.scriptPath), ...startCommandArgs(target)].join(" ");
+	return `<?xml version="1.0" encoding="UTF-16"?>
+<Task version="1.2" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">
+  <RegistrationInfo>
+    <Description>GitHub Copilot API proxy (copilot-api)</Description>
+  </RegistrationInfo>
+  <Triggers>
+    <LogonTrigger>
+      <Enabled>true</Enabled>
+    </LogonTrigger>
+  </Triggers>
+  <Principals>
+    <Principal id="Author">
+      <LogonType>InteractiveToken</LogonType>
+      <RunLevel>LeastPrivilege</RunLevel>
+    </Principal>
+  </Principals>
+  <Settings>
+    <MultipleInstancesPolicy>IgnoreNew</MultipleInstancesPolicy>
+    <DisallowStartIfOnBatteries>false</DisallowStartIfOnBatteries>
+    <StopIfGoingOnBatteries>false</StopIfGoingOnBatteries>
+    <AllowHardTerminate>true</AllowHardTerminate>
+    <StartWhenAvailable>true</StartWhenAvailable>
+    <RunOnlyIfNetworkAvailable>false</RunOnlyIfNetworkAvailable>
+    <IdleSettings>
+      <StopOnIdleEnd>false</StopOnIdleEnd>
+      <RestartOnIdle>false</RestartOnIdle>
+    </IdleSettings>
+    <AllowStartOnDemand>true</AllowStartOnDemand>
+    <Enabled>true</Enabled>
+    <Hidden>false</Hidden>
+    <RunOnlyIfIdle>false</RunOnlyIfIdle>
+    <RestartOnFailure>
+      <Interval>PT1M</Interval>
+      <Count>999</Count>
+    </RestartOnFailure>
+    <ExecutionTimeLimit>PT0S</ExecutionTimeLimit>
+    <Priority>7</Priority>
+  </Settings>
+  <Actions Context="Author">
+    <Exec>
+      <Command>${command}</Command>
+      <Arguments>${args}</Arguments>
+    </Exec>
+  </Actions>
+</Task>
+`;
+}
+async function installWindowsTask(target) {
+	const xml = buildWindowsTaskXml(target);
+	const xmlPath = path.join(os.tmpdir(), `${SERVICE_NAME}-task.xml`);
+	await fs.writeFile(xmlPath, `\uFEFF${xml}`, "utf16le");
+	const create = runQuietly("schtasks", [
+		"/Create",
+		"/TN",
+		WINDOWS_TASK_NAME,
+		"/XML",
+		xmlPath,
+		"/F"
+	]);
+	if (!create.ok) return {
+		installed: false,
+		manager: "schtasks",
+		message: `Failed to register task: ${create.output.trim()}. XML written to ${xmlPath}.`
+	};
+	runQuietly("schtasks", [
+		"/Run",
+		"/TN",
+		WINDOWS_TASK_NAME
+	]);
+	return {
+		installed: true,
+		manager: "schtasks",
+		message: `Scheduled task "${WINDOWS_TASK_NAME}" registered and started. Manage it in Task Scheduler.`
+	};
+}
+async function installService(target) {
+	const platform = os.platform();
+	if (platform === "linux") return installSystemdService(target);
+	if (platform === "win32") return installWindowsTask(target);
+	const exec = [
+		target.runtimePath,
+		target.scriptPath,
+		...startCommandArgs(target)
+	].join(" ");
+	return {
+		installed: false,
+		manager: "none",
+		message: `Automatic service install is not supported on "${platform}". Run this manually (e.g. via a launch agent):\n  ${exec}`
+	};
+}
+
+//#endregion
+//#region src/setup.ts
+const ACCOUNT_TYPES = [
+	"individual",
+	"business",
+	"enterprise"
+];
+const resolveRuntime = () => {
+	let scriptPath = process$1.argv[1] ?? "";
+	try {
+		scriptPath = fs$1.realpathSync(scriptPath);
+	} catch {}
+	return {
+		runtimePath: process$1.execPath,
+		scriptPath
+	};
+};
+async function loadModelIds(accountType) {
+	state.accountType = accountType;
+	await cacheVSCodeVersion();
+	const { token } = await getCopilotToken();
+	state.copilotToken = token;
+	await cacheModels();
+	return state.models?.data.map((model) => model.id) ?? [];
+}
+async function pickModel(message, ids, fallback) {
+	if (ids.length === 0) return fallback;
+	return await consola.prompt(message, {
+		type: "select",
+		options: ids,
+		initial: ids.includes(fallback) ? fallback : ids[0]
+	});
+}
+async function promptChoices(initial) {
+	const accountType = await consola.prompt("GitHub Copilot account type", {
+		type: "select",
+		options: ACCOUNT_TYPES,
+		initial: ACCOUNT_TYPES.includes(initial.accountType) ? initial.accountType : "individual"
+	});
+	const portInput = await consola.prompt("Port for the proxy", {
+		type: "text",
+		default: String(initial.port),
+		placeholder: String(initial.port)
+	});
+	const parsedPort = Number.parseInt(portInput, 10);
+	const doCodex = await consola.prompt("Configure Codex CLI?", {
+		type: "confirm",
+		initial: initial.doCodex
+	});
+	const doClaude = await consola.prompt("Configure Claude Code?", {
+		type: "confirm",
+		initial: initial.doClaude
+	});
+	return {
+		accountType,
+		port: Number.isNaN(parsedPort) ? initial.port : parsedPort,
+		doCodex,
+		doClaude
+	};
+}
+async function promptModels(choices, models) {
+	if (!choices.doCodex) return models;
+	let { codexModel } = models;
+	try {
+		const ids = await loadModelIds(choices.accountType);
+		codexModel = await pickModel("Model for Codex CLI", ids, codexModel);
+	} catch (error) {
+		consola.warn(`Could not load the model list, using defaults instead: ${String(error)}`);
+	}
+	return {
+		...models,
+		codexModel
+	};
+}
+async function writeConfigs(choices, configOptions) {
+	if (choices.doCodex) {
+		const written = await writeCodexConfig(configOptions);
+		consola.success(`Configured Codex CLI (model "${configOptions.codexModel}") at ${written}`);
+	}
+	if (choices.doClaude) {
+		const written = await writeClaudeSettings(configOptions);
+		consola.success(`Configured Claude Code at ${written}`);
+	}
+}
+async function maybeInstallService(options, choices) {
+	let doService = options.service;
+	if (!options.yes && options.service) doService = await consola.prompt(`Install an auto-start service on port ${choices.port}?`, {
+		type: "confirm",
+		initial: true
+	});
+	if (!doService) return;
+	const { runtimePath, scriptPath } = resolveRuntime();
+	const target = {
+		port: choices.port,
+		accountType: choices.accountType,
+		runtimePath,
+		scriptPath
+	};
+	const result = await installService(target);
+	if (result.installed) consola.success(result.message);
+	else consola.warn(result.message);
+}
+function printSummary(options, choices) {
+	const baseUrl = proxyBaseUrl(options.host, choices.port);
+	consola.box([
+		`Setup complete. Proxy URL: ${baseUrl}`,
+		``,
+		options.service ? `The proxy is registered to run automatically on port ${choices.port}.` : `Start manually: copilot-api start --port ${choices.port} --account-type ${choices.accountType}`,
+		``,
+		`Config files were written for Codex and/or Claude Code (created even if`,
+		`those tools are not installed yet), so they will work once installed.`
+	].join("\n"));
+}
+async function runSetup(options) {
+	state.showToken = options.showToken;
+	consola.box("copilot-api setup");
+	let choices = {
+		port: options.port,
+		accountType: options.accountType,
+		doClaude: options.claude || !options.codex,
+		doCodex: options.codex || !options.claude
+	};
+	if (!options.yes) choices = await promptChoices(choices);
+	await ensurePaths();
+	consola.info("Checking GitHub authentication...");
+	await setupGitHubToken();
+	let configOptions = {
+		baseUrl: proxyBaseUrl(options.host, choices.port),
+		codexModel: options.codexModel,
+		claudeModel: options.claudeModel,
+		claudeSmallModel: options.claudeSmallModel
+	};
+	if (!options.yes) configOptions = await promptModels(choices, configOptions);
+	await writeConfigs(choices, configOptions);
+	await maybeInstallService(options, choices);
+	printSummary(options, choices);
+	process$1.exit(0);
+}
+const setup = defineCommand({
+	meta: {
+		name: "setup",
+		description: "Guided setup: log in, configure Codex/Claude Code, and install an auto-start service"
+	},
+	args: {
+		port: {
+			alias: "p",
+			type: "string",
+			default: "4141",
+			description: "Port the proxy listens on"
+		},
+		host: {
+			type: "string",
+			default: "localhost",
+			description: "Host the config files point at"
+		},
+		"account-type": {
+			alias: "a",
+			type: "string",
+			default: "individual",
+			description: "Account type (individual, business, enterprise)"
+		},
+		claude: {
+			type: "boolean",
+			default: false,
+			description: "Only configure Claude Code (default: configure both)"
+		},
+		codex: {
+			type: "boolean",
+			default: false,
+			description: "Only configure Codex CLI (default: configure both)"
+		},
+		service: {
+			type: "boolean",
+			default: true,
+			description: "Install an auto-start service (use --no-service to skip)"
+		},
+		yes: {
+			alias: "y",
+			type: "boolean",
+			default: false,
+			description: "Non-interactive: accept all defaults"
+		},
+		"codex-model": {
+			type: "string",
+			default: DEFAULT_CODEX_MODEL,
+			description: "Model to use for Codex CLI"
+		},
+		"claude-model": {
+			type: "string",
+			default: DEFAULT_CLAUDE_MODEL,
+			description: "Pin a Claude Code model (optional; default: let the proxy auto-map)"
+		},
+		"claude-small-model": {
+			type: "string",
+			default: DEFAULT_CLAUDE_SMALL_MODEL,
+			description: "Pin a Claude Code small/fast model (optional)"
+		},
+		"show-token": {
+			type: "boolean",
+			default: false,
+			description: "Show GitHub and Copilot tokens during setup"
+		}
+	},
+	run({ args }) {
+		return runSetup({
+			port: Number.parseInt(args.port, 10),
+			host: args.host,
+			accountType: args["account-type"],
+			codexModel: args["codex-model"],
+			claudeModel: args["claude-model"],
+			claudeSmallModel: args["claude-small-model"],
+			claude: args.claude,
+			codex: args.codex,
+			service: args.service,
+			yes: args.yes,
+			showToken: args["show-token"]
+		});
+	}
+});
+
 //#endregion
 //#region src/lib/proxy.ts
 function initProxyFromEnv() {
@@ -1583,6 +2239,62 @@ modelRoutes.get("/", async (c) => {
 	}
 });
 
+//#endregion
+//#region src/services/copilot/create-responses.ts
+const createResponses = async (payload, extraHeaders = {}) => {
+	if (!state.copilotToken) throw new Error("Copilot token not found");
+	const headers = {
+		...copilotHeaders(state),
+		"openai-intent": "conversation-edits",
+		...extraHeaders
+	};
+	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);
+	}
+	return response;
+};
+
+//#endregion
+//#region src/routes/responses/handler.ts
+async function handleResponses(c) {
+	await checkRateLimit(state);
+	const payload = await c.req.json();
+	consola.debug("Responses request payload:", JSON.stringify(payload).slice(-400));
+	if (state.manualApprove) await awaitApproval();
+	const initiator = c.req.header("x-initiator");
+	const response = await createResponses(payload, initiator ? { "x-initiator": initiator } : {});
+	if ((response.headers.get("content-type") ?? "").includes("text/event-stream")) {
+		consola.debug("Streaming responses response");
+		return streamSSE(c, async (stream) => {
+			for await (const event of events(response)) await stream.writeSSE({
+				data: event.data ?? "",
+				event: event.event,
+				id: event.id === void 0 ? void 0 : String(event.id)
+			});
+		});
+	}
+	const json = await response.json();
+	consola.debug("Non-streaming responses response");
+	return c.json(json);
+}
+
+//#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();
@@ -1618,11 +2330,13 @@ server.use(logger());
 server.use(cors());
 server.get("/", (c) => c.text("Server running"));
 server.route("/chat/completions", completionRoutes);
+server.route("/responses", responsesRoutes);
 server.route("/models", modelRoutes);
 server.route("/embeddings", embeddingRoutes);
 server.route("/usage", usageRoute);
 server.route("/token", tokenRoute);
 server.route("/v1/chat/completions", completionRoutes);
+server.route("/v1/responses", responsesRoutes);
 server.route("/v1/models", modelRoutes);
 server.route("/v1/embeddings", embeddingRoutes);
 server.route("/v1/messages", messageRoutes);
@@ -1796,6 +2510,8 @@ const main = defineCommand({
 	subCommands: {
 		auth,
 		start,
+		setup,
+		config,
 		"check-usage": checkUsage,
 		debug
 	}