copilot-relay 0.4.8 → 0.5.1

package/dist/main.js

@@ -17,6 +17,7 @@ import { Hono } from "hono";
 import { streamSSE } from "hono/streaming";
 import { events } from "fetch-event-stream";
 import { execFile } from "node:child_process";
+import { TomlError, parse } from "smol-toml";
 
 //#region src/lib/error.ts
 var ProxyNotImplementedError = class extends Error {
@@ -93,6 +94,7 @@ const logsDir = path.join(appDir, "logs");
 const logFileBaseName = "copilot-relay";
 const legacyLogPath = path.join(logsDir, `${logFileBaseName}.log`);
 const pidPath = path.join(appDir, "copilot-relay.pid");
+const codexCatalogPath = path.join(appDir, "codex-models.json");
 /**
 * Local-date stamp used in log file names.
 *
@@ -112,6 +114,7 @@ const formatLogDate = (date) => [
 const getLogPath = (date = /* @__PURE__ */ new Date()) => path.join(logsDir, `${logFileBaseName}.${formatLogDate(date)}.log`);
 const paths = {
 	appDir,
+	codexCatalogPath,
 	configPath,
 	copilotTokenPath,
 	githubTokenPath,
@@ -1236,7 +1239,7 @@ const assertUnchanged = async (expected) => {
 	if (current.resolvedPath !== expected.resolvedPath || current.raw !== expected.raw || current.mode !== expected.mode || !sameIdentity(current.identity, expected.identity)) throw new FileConflictError();
 };
 const pendingWrites = /* @__PURE__ */ new Map();
-const publish = async (snapshot, content, options) => {
+const publish$1 = async (snapshot, content, options) => {
 	await assertUnchanged(snapshot);
 	const directory = path.dirname(snapshot.resolvedPath);
 	await fs.mkdir(directory, {
@@ -1267,7 +1270,7 @@ const publish = async (snapshot, content, options) => {
 	}
 };
 const writeFileSnapshot = async (snapshot, content, options = {}) => {
-	const current = (pendingWrites.get(snapshot.resolvedPath) ?? Promise.resolve()).catch(() => void 0).then(() => publish(snapshot, content, options));
+	const current = (pendingWrites.get(snapshot.resolvedPath) ?? Promise.resolve()).catch(() => void 0).then(() => publish$1(snapshot, content, options));
 	pendingWrites.set(snapshot.resolvedPath, current);
 	try {
 		await current;
@@ -1317,6 +1320,7 @@ const logLevels = [
 const defaultConfig = {
 	apiKey: "",
 	claudeSetup: true,
+	codexSetup: true,
 	copilotBaseUrl: "https://api.githubcopilot.com",
 	gptModel: "gpt-6-astra",
 	host: "127.0.0.1",
@@ -1343,14 +1347,14 @@ const normalizeClaudeUpstreamApi = (value) => {
 	if (value === "auto" || value === "messages" || value === "chat-completions") return value;
 	throw new Error("Invalid claudeUpstreamApi: expected auto, messages, or chat-completions");
 };
-const normalizeBoolean = (value) => {
+const normalizeBoolean = (value, name) => {
 	if (value === void 0) return;
 	if (typeof value === "boolean") return value;
 	if (typeof value === "string") {
 		if (value.toLowerCase() === "true") return true;
 		if (value.toLowerCase() === "false") return false;
 	}
-	throw new Error("Invalid claudeSetup: expected true or false");
+	throw new Error(`Invalid ${name}: expected true or false`);
 };
 const normalizeInteger = (value, key, minimum, maximum = Number.MAX_SAFE_INTEGER) => {
 	if (value === void 0) return;
@@ -1547,6 +1551,7 @@ const readDefaultConfigTemplate = async () => {
 const configAliases = {
 	api_key: "apiKey",
 	claude_setup: "claudeSetup",
+	codex_setup: "codexSetup",
 	copilot_base_url: "copilotBaseUrl",
 	gpt_model: "gptModel",
 	log_level: "logLevel",
@@ -1583,11 +1588,11 @@ const parseConfigYaml = (content) => {
 		const match = /^([A-Za-z][A-Za-z0-9_-]*)[ \t]*:[ \t]*(.*)$/.exec(line);
 		if (!match) throw new Error(`Invalid config syntax on line ${index + 1}: expected a flat scalar key`);
 		const [, key, value] = match;
-		const canonical = Object.hasOwn(configAliases, key) ? configAliases[key] : key;
-		if (seen.has(canonical)) throw new Error(`Duplicate config key on line ${index + 1}`);
-		seen.add(canonical);
+		const canonical$1 = Object.hasOwn(configAliases, key) ? configAliases[key] : key;
+		if (seen.has(canonical$1)) throw new Error(`Duplicate config key on line ${index + 1}`);
+		seen.add(canonical$1);
 		const scalar = parseYamlScalar(value);
-		if (Object.hasOwn(defaultConfig, canonical)) config[canonical] = scalar;
+		if (Object.hasOwn(defaultConfig, canonical$1)) config[canonical$1] = scalar;
 	}
 	return config;
 };
@@ -1605,7 +1610,7 @@ const serializeConfig = (config) => [
 	"# copilot-relay configuration",
 	"#",
 	"# Valid complete edits hot-reload without rewriting this file.",
-	"# host, port, claudeSetup, and upstreamProxy require restart.",
+	"# host, port, claudeSetup, codexSetup, and upstreamProxy require restart.",
 	"",
 	"# Local host for the Claude Code-compatible HTTP server.",
 	`host: ${config.host}`,
@@ -1627,6 +1632,9 @@ const serializeConfig = (config) => [
 	"# Update ~/.claude/settings.json on start.",
 	`claudeSetup: ${config.claudeSetup}`,
 	"",
+	"# Update Codex's config.toml and model list on start, when Codex is installed.",
+	`codexSetup: ${config.codexSetup}`,
+	"",
 	"# Log verbosity:",
 	"#   error - startup/preflight/request failures only",
 	"#   info  - errors plus status, model/effort and semantic completion summaries",
@@ -1659,7 +1667,8 @@ const serializeConfig = (config) => [
 ].join("\n");
 const resolveConfig = (raw) => ({
 	apiKey: normalizeApiKey(raw.apiKey) ?? defaultConfig.apiKey,
-	claudeSetup: normalizeBoolean(raw.claudeSetup) ?? defaultConfig.claudeSetup,
+	claudeSetup: normalizeBoolean(raw.claudeSetup, "claudeSetup") ?? defaultConfig.claudeSetup,
+	codexSetup: normalizeBoolean(raw.codexSetup, "codexSetup") ?? defaultConfig.codexSetup,
 	copilotBaseUrl: normalizeCopilotBaseUrl(normalizeRequiredString(raw.copilotBaseUrl, "copilotBaseUrl")) ?? defaultConfig.copilotBaseUrl,
 	gptModel: normalizeRequiredString(raw.gptModel, "gptModel") ?? defaultConfig.gptModel,
 	host: normalizeRequiredString(raw.host, "host") ?? defaultConfig.host,
@@ -3164,8 +3173,8 @@ const parseJsonBody = (body) => {
 };
 const isJsonObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 const parseTokenCount = (digits) => {
-	const count = Number(digits);
-	return Number.isSafeInteger(count) ? count : void 0;
+	const count$1 = Number(digits);
+	return Number.isSafeInteger(count$1) ? count$1 : void 0;
 };
 const toPromptTooLongError = (status$1, body, detail) => {
 	if (status$1 !== 400) return;
@@ -3343,10 +3352,10 @@ const pinCopilotModelCatalog = (config) => {
 	pinnedCatalogs.set(config, config.modelCatalog);
 };
 const pendingCatalogs = /* @__PURE__ */ new WeakMap();
-const isRecord$5 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const isRecord$9 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 const isPositiveInteger = (value) => typeof value === "number" && Number.isSafeInteger(value) && value > 0;
 function parseModelTokenLimits(value) {
-	if (!isRecord$5(value)) return;
+	if (!isRecord$9(value)) return;
 	const context = value.max_context_window_tokens;
 	const prompt = value.max_prompt_tokens;
 	const output = value.max_output_tokens;
@@ -3402,13 +3411,13 @@ async function loadCopilotModelCatalog(config) {
 		});
 		if (!response.ok) throw new HTTPError("Failed to validate upstream models", response);
 		const payload = await readCopilotJson(response, signal, config.upstreamTimeoutMs);
-		if (!isRecord$5(payload) || !Array.isArray(payload.data)) throw new Error("Copilot /models returned an invalid model catalog.");
+		if (!isRecord$9(payload) || !Array.isArray(payload.data)) throw new Error("Copilot /models returned an invalid model catalog.");
 		const models$1 = /* @__PURE__ */ new Map();
 		for (const model of payload.data) {
-			if (!isRecord$5(model) || typeof model.id !== "string" || !model.id) continue;
-			const capabilities = isRecord$5(model.capabilities) ? model.capabilities : void 0;
+			if (!isRecord$9(model) || typeof model.id !== "string" || !model.id) continue;
+			const capabilities = isRecord$9(model.capabilities) ? model.capabilities : void 0;
 			const limits = parseModelTokenLimits(capabilities?.limits);
-			const supports = isRecord$5(capabilities?.supports) ? capabilities.supports : void 0;
+			const supports = isRecord$9(capabilities?.supports) ? capabilities.supports : void 0;
 			const supportedEndpoints = parseStringArray(model.supported_endpoints);
 			const reasoningEfforts = parseReasoningEfforts(supports);
 			models$1.set(model.id, {
@@ -3602,8 +3611,8 @@ const renderProbeSummary = (rows) => {
 		NOT_TESTED: "not tested"
 	};
 	return "Summary: " + Object.keys(labels).flatMap((status$1) => {
-		const count = rows.filter((row) => row.status === status$1).length;
-		return count ? [`${count} ${labels[status$1]}`] : [];
+		const count$1 = rows.filter((row) => row.status === status$1).length;
+		return count$1 ? [`${count$1} ${labels[status$1]}`] : [];
 	}).join(" · ");
 };
 const renderProbeDetails = (row, diagnostic) => {
@@ -3753,7 +3762,7 @@ const claudeCodeContext = [
 const claudeCodeContextPatterns = [/^\S+ hook additional context:/];
 const statusProbePrompt = "Reply with the single word: ok";
 const statusProbeMaxTokens = 16;
-const isRecord$4 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const isRecord$8 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 const innermostReminder = /<system-reminder>(?:(?!<system-reminder>)[\s\S])*?<\/system-reminder>/g;
 const withoutReminders = (text$1) => {
 	let previous = text$1;
@@ -3766,22 +3775,22 @@ const withoutReminders = (text$1) => {
 };
 const startsWithAny = (text$1, prefixes) => prefixes.some((prefix) => text$1.startsWith(prefix));
 const matchesAny = (text$1, prefixes, patterns) => startsWithAny(text$1, prefixes) || patterns.some((pattern) => pattern.test(text$1));
-const contentBlocks = (content) => {
+const contentBlocks$1 = (content) => {
 	if (typeof content === "string") return [{
 		type: "text",
 		text: content
 	}];
-	return Array.isArray(content) ? content.filter(isRecord$4) : [];
+	return Array.isArray(content) ? content.filter(isRecord$8) : [];
 };
 const originatingTurn = (messages) => {
 	const blocks = [];
 	let sawUser = false;
 	for (let index = messages.length - 1; index >= 0; index--) {
 		const message = messages[index];
-		if (!isRecord$4(message) || message.role === "system") continue;
+		if (!isRecord$8(message) || message.role === "system") continue;
 		if (message.role !== "user") break;
 		sawUser = true;
-		blocks.unshift(...contentBlocks(message.content));
+		blocks.unshift(...contentBlocks$1(message.content));
 	}
 	return sawUser ? blocks : void 0;
 };
@@ -3798,11 +3807,11 @@ const blockOrigin = (block) => {
 const isStatusProbe = (body) => {
 	if (Object.keys(body).sort().join(",") !== "max_tokens,messages,model" || body.max_tokens !== statusProbeMaxTokens) return false;
 	const messages = body.messages;
-	return Array.isArray(messages) && messages.length === 1 && isRecord$4(messages[0]) && messages[0].role === "user" && messages[0].content === statusProbePrompt;
+	return Array.isArray(messages) && messages.length === 1 && isRecord$8(messages[0]) && messages[0].role === "user" && messages[0].content === statusProbePrompt;
 };
-const systemTexts = (system) => contentBlocks(system).flatMap((block) => block.type === "text" && typeof block.text === "string" ? [block.text] : []);
+const systemTexts = (system) => contentBlocks$1(system).flatMap((block) => block.type === "text" && typeof block.text === "string" ? [block.text] : []);
 const getClaudeRequestInitiator = (body) => {
-	if (!isRecord$4(body) || !Array.isArray(body.messages) || isStatusProbe(body)) return "agent";
+	if (!isRecord$8(body) || !Array.isArray(body.messages) || isStatusProbe(body)) return "agent";
 	const payload = body;
 	if (readBillingLineField(payload, "cc_is_subagent") === "true" || readBillingLineField(payload, "cc_workload") === "cron") return "agent";
 	if (systemTexts(removeBillingLine(payload).system).some((text$1) => startsWithAny(text$1.trimStart(), ownRequestSystemPrompts))) return "agent";
@@ -4406,7 +4415,7 @@ const webSearchInputSchema = {
 	required: ["query"],
 	additionalProperties: false
 };
-const isRecord$3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const isRecord$7 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 const isAnthropicNativeWebSearchTool = (tool) => tool.name === "web_search" && typeof tool.type === "string" && anthropicWebSearchToolPattern.test(tool.type);
 const isClaudeCodeWebSearchTool = (tool) => tool.name === claudeCodeWebSearchToolName;
 const isClaudeWebSearchTool = (tool) => isAnthropicNativeWebSearchTool(tool) || isClaudeCodeWebSearchTool(tool);
@@ -4446,7 +4455,7 @@ const getQueryFromToolArguments = (value) => {
 	if (!trimmed) return;
 	try {
 		const parsed = JSON.parse(trimmed);
-		if (isRecord$3(parsed) && typeof parsed.query === "string" && parsed.query.trim()) return parsed.query.trim();
+		if (isRecord$7(parsed) && typeof parsed.query === "string" && parsed.query.trim()) return parsed.query.trim();
 	} catch {
 		return trimmed;
 	}
@@ -4503,7 +4512,7 @@ const getReportedQuery = (action, queries) => {
 const getSearchQuery = (response, requestedQuery) => {
 	for (const item of response.output ?? []) {
 		if (item.type !== "web_search_call") continue;
-		const action = isRecord$3(item.action) ? item.action : void 0;
+		const action = isRecord$7(item.action) ? item.action : void 0;
 		const query = getReportedQuery(action, Array.isArray(action?.queries) ? action.queries : []);
 		if (query) return query;
 	}
@@ -4511,7 +4520,7 @@ const getSearchQuery = (response, requestedQuery) => {
 };
 const getResponseText = (response) => (response.output ?? []).flatMap((item) => {
 	if (item.type !== "message") return [];
-	return (Array.isArray(item.content) ? item.content : []).flatMap((part) => isRecord$3(part) && part.type === "output_text" && typeof part.text === "string" ? [part.text] : []);
+	return (Array.isArray(item.content) ? item.content : []).flatMap((part) => isRecord$7(part) && part.type === "output_text" && typeof part.text === "string" ? [part.text] : []);
 }).join("\n").trim();
 const cleanTitle = (line, url) => {
 	return line.slice(0, line.indexOf(url)).replace(/^\s*(?:[-*]|\d+[.)])\s*/, "").replace(/\s*(?:[-:|])\s*$/, "").trim() || new URL(url).hostname;
@@ -4535,15 +4544,15 @@ const parseSearchResults = (text$1) => {
 const getStructuredSearchResults = (response) => {
 	const sources = [];
 	for (const item of response.output ?? []) {
-		if (item.type === "web_search_call" && isRecord$3(item.action) && Array.isArray(item.action.sources)) sources.push(...item.action.sources);
+		if (item.type === "web_search_call" && isRecord$7(item.action) && Array.isArray(item.action.sources)) sources.push(...item.action.sources);
 		if (item.type === "message" && Array.isArray(item.content)) {
-			for (const part of item.content) if (isRecord$3(part) && Array.isArray(part.annotations)) sources.push(...part.annotations.filter((annotation) => isRecord$3(annotation) && annotation.type === "url_citation"));
+			for (const part of item.content) if (isRecord$7(part) && Array.isArray(part.annotations)) sources.push(...part.annotations.filter((annotation) => isRecord$7(annotation) && annotation.type === "url_citation"));
 		}
 	}
 	const results = [];
 	const seen = /* @__PURE__ */ new Set();
 	for (const source of sources) {
-		if (!isRecord$3(source) || typeof source.url !== "string") continue;
+		if (!isRecord$7(source) || typeof source.url !== "string") continue;
 		try {
 			const url = new URL(source.url);
 			if (!/^https?:$/.test(url.protocol) || url.username || url.password || seen.has(url.href)) continue;
@@ -4568,7 +4577,7 @@ const responseStates = [
 	"in_progress"
 ];
 const searchStates = [...responseStates, "searching"];
-const incompleteReasons = ["max_output_tokens", "content_filter"];
+const incompleteReasons$1 = ["max_output_tokens", "content_filter"];
 const outputTypes = [
 	"message",
 	"reasoning",
@@ -4584,7 +4593,7 @@ const safeResponseId = (value, token) => typeof value === "string" && /^(?:resp|
 const summarizeCounts = (values) => {
 	const counts = /* @__PURE__ */ new Map();
 	for (const value of values) counts.set(value, (counts.get(value) ?? 0) + 1);
-	return [...counts].sort(([a], [b]) => a.localeCompare(b)).map(([key, count]) => `${key}:${count}`).join(",") || "none";
+	return [...counts].sort(([a], [b]) => a.localeCompare(b)).map(([key, count$1]) => `${key}:${count$1}`).join(",") || "none";
 };
 const getSearchProvenance = (calls, callStates, structured) => {
 	if (calls.length) return callStates.every((state) => state === "completed") ? "completed_call" : "call_unreported";
@@ -4595,21 +4604,21 @@ const getResultSource = (structured, results) => {
 	return results.length ? "text" : "none";
 };
 const interpretSearchResponse = (raw, config, requestedQuery, request, requestedEffort, requestId) => {
-	const malformed = !isRecord$3(raw) || raw.output !== void 0 && (!Array.isArray(raw.output) || !raw.output.every(isRecord$3));
-	const upstream = isRecord$3(raw) ? {
+	const malformed = !isRecord$7(raw) || raw.output !== void 0 && (!Array.isArray(raw.output) || !raw.output.every(isRecord$7));
+	const upstream = isRecord$7(raw) ? {
 		...raw,
-		output: Array.isArray(raw.output) ? raw.output.filter(isRecord$3) : []
+		output: Array.isArray(raw.output) ? raw.output.filter(isRecord$7) : []
 	} : {};
 	const status$1 = recognizedValue(upstream.status, responseStates);
-	const reason = recognizedValue(isRecord$3(upstream.incomplete_details) ? upstream.incomplete_details.reason : void 0, incompleteReasons);
+	const reason = recognizedValue(isRecord$7(upstream.incomplete_details) ? upstream.incomplete_details.reason : void 0, incompleteReasons$1);
 	const items = upstream.output ?? [];
 	const calls = items.filter((item) => item.type === "web_search_call");
 	const callStates = calls.map((item) => recognizedValue(item.status, searchStates));
-	const usage$1 = isRecord$3(upstream.usage) ? upstream.usage : {};
+	const usage$1 = isRecord$7(upstream.usage) ? upstream.usage : {};
 	const inputTokens = reportedTokens(usage$1.input_tokens);
-	const cachedInputTokens = reportedTokens(isRecord$3(usage$1.input_tokens_details) ? usage$1.input_tokens_details.cached_tokens : void 0);
+	const cachedInputTokens = reportedTokens(isRecord$7(usage$1.input_tokens_details) ? usage$1.input_tokens_details.cached_tokens : void 0);
 	const outputTokens = reportedTokens(usage$1.output_tokens);
-	const reasoningTokens = reportedTokens(isRecord$3(usage$1.output_tokens_details) ? usage$1.output_tokens_details.reasoning_tokens : void 0);
+	const reasoningTokens = reportedTokens(isRecord$7(usage$1.output_tokens_details) ? usage$1.output_tokens_details.reasoning_tokens : void 0);
 	const upstreamResponseId = safeResponseId(upstream.id, config.copilotToken);
 	const safeRequestId = typeof requestId === "string" && /^[a-f0-9-]{36}$/i.test(requestId) ? requestId : "unreported";
 	const text$1 = getResponseText(upstream);
@@ -4697,7 +4706,7 @@ const getSearchFailureDetail = (body, token) => {
 	let detail = body.trim();
 	try {
 		const parsed = JSON.parse(detail);
-		detail = getErrorMessageOrCode(isRecord$3(parsed) && isRecord$3(parsed.error) ? parsed.error : void 0);
+		detail = getErrorMessageOrCode(isRecord$7(parsed) && isRecord$7(parsed.error) ? parsed.error : void 0);
 	} catch {
 		if (/^[{[<]/.test(detail)) return "";
 	}
@@ -4829,11 +4838,11 @@ const removeWebSearchTool = (tools, toolNameMapper) => {
 	const remaining = tools.filter((tool) => !isWebSearchTool(tool, toolNameMapper));
 	return remaining.length > 0 ? remaining : void 0;
 };
-const normalizeFinalToolChoice = (toolChoice, tools, toolNameMapper) => {
+const normalizeFinalToolChoice = (toolChoice$1, tools, toolNameMapper) => {
 	if (!tools || tools.length === 0) return;
-	if (toolChoice === "required") return "auto";
-	if (toolChoice && typeof toolChoice === "object" && isClaudeWebSearchToolName(toolNameMapper.toClaude(toolChoice.function.name))) return "auto";
-	return toolChoice;
+	if (toolChoice$1 === "required") return "auto";
+	if (toolChoice$1 && typeof toolChoice$1 === "object" && isClaudeWebSearchToolName(toolNameMapper.toClaude(toolChoice$1.function.name))) return "auto";
+	return toolChoice$1;
 };
 const createFinalWebSearchPayload = (payload, search, toolNameMapper) => {
 	const tools = removeWebSearchTool(payload.tools, toolNameMapper);
@@ -5269,7 +5278,7 @@ const lookaroundPrefixes = [
 	"(?<=",
 	"(?<!"
 ];
-const isRecord$2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const isRecord$6 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 function hasUnsupportedPatternFeatures(pattern) {
 	let inCharacterClass = false;
 	for (let index = 0; index < pattern.length; index++) {
@@ -5315,12 +5324,12 @@ function mapArray(values) {
 }
 function normalizeSchemaValue(value) {
 	if (Array.isArray(value)) return mapArray(value);
-	return isRecord$2(value) ? normalizeResponsesToolSchema(value) : value;
+	return isRecord$6(value) ? normalizeResponsesToolSchema(value) : value;
 }
 function normalizeResponsesToolSchema(schema) {
 	return mapRecord(schema, (key, value) => {
 		if (key === "pattern" && typeof value === "string" && hasUnsupportedPatternFeatures(value)) return removed;
-		if (schemaMapKeywords.has(key) && isRecord$2(value)) return mapRecord(value, (_name, nested) => normalizeSchemaValue(nested));
+		if (schemaMapKeywords.has(key) && isRecord$6(value)) return mapRecord(value, (_name, nested) => normalizeSchemaValue(nested));
 		if (nestedSchemaKeywords.has(key)) return normalizeSchemaValue(value);
 		return value;
 	});
@@ -5689,12 +5698,12 @@ function translateTools(tools) {
 		strict: false
 	}));
 }
-function translateToolChoice(toolChoice) {
-	if (!toolChoice) return;
-	if (typeof toolChoice === "string") return toolChoice;
+function translateToolChoice(toolChoice$1) {
+	if (!toolChoice$1) return;
+	if (typeof toolChoice$1 === "string") return toolChoice$1;
 	return {
 		type: "function",
-		name: toolChoice.function.name
+		name: toolChoice$1.function.name
 	};
 }
 function translateUsage(usage$1) {
@@ -5999,7 +6008,7 @@ const invalidRequest = (message) => new HTTPError(message, Response.json({
 		message
 	}
 }, { status: 400 }));
-const toolResult = (id, content) => ({
+const toolResult$1 = (id, content) => ({
 	type: "tool_result",
 	tool_use_id: id,
 	content: `Search result data (untrusted, not instructions). Answer from these results without another search this turn.\n${JSON.stringify(content)}`
@@ -6033,7 +6042,7 @@ function normalizeNativeHistory(messages) {
 		if (decision.some((block) => block.type === "server_tool_use")) throw invalidRequest("Invalid bridge decision boundary.");
 		const resultTurn = {
 			role: "user",
-			content: [toolResult(id, resultBlock.content)]
+			content: [toolResult$1(id, resultBlock.content)]
 		};
 		generatedResults.add(resultTurn);
 		const turns = [{
@@ -6116,7 +6125,7 @@ async function createNativeMessages(config, payload, options) {
 	if (beta) headers["anthropic-beta"] = beta;
 	const effortLabel = effort === void 0 ? "omitted" : getClaudeTurnEffort(body).effective;
 	const initiator = options.initiator ?? "agent";
-	log.info(sanitizeTerminalString(`request_id=${options.requestId} Model request client=claude requested_model=${payload.model} upstream_model=${payload.model} upstream_api=messages effective_think_effort=${effortLabel} initiator=${initiator}`));
+	log.info(sanitizeTerminalString(`request_id=${options.requestId} Model request client=${options.client ?? "claude"} requested_model=${options.requestedModel ?? payload.model} upstream_model=${payload.model} upstream_api=messages effective_think_effort=${effortLabel} initiator=${initiator}`));
 	const response = await fetchCopilot(getCopilotProviderContext(config), "/v1/messages", {
 		method: "POST",
 		headers,
@@ -6132,9 +6141,12 @@ async function createNativeMessages(config, payload, options) {
 		const contentType = response.headers.get("content-type") ?? "application/json";
 		const promptTooLong = toPromptTooLongError(response.status, detail);
 		if (promptTooLong) throw promptTooLong;
+		const headers$1 = new Headers({ "content-type": contentType });
+		const retryAfter = response.headers.get("retry-after");
+		if (retryAfter !== null) headers$1.set("retry-after", retryAfter);
 		throw new HTTPError("Native upstream request failed", new Response(detail, {
 			status: response.status,
-			headers: { "content-type": contentType }
+			headers: headers$1
 		}));
 	}
 	return response;
@@ -6359,7 +6371,7 @@ async function handleNativeMessages(config, payload, options, write) {
 		type: "web_search_tool_result",
 		tool_use_id: marker
 	};
-	const upstreamToolResult = toolResult(searchCall.id, resultBlock.content);
+	const upstreamToolResult = toolResult$1(searchCall.id, resultBlock.content);
 	const hasSiblingTools = message.content.some((block) => block.type === "tool_use" && block !== searchCall);
 	let usage$1 = mergeUsage(message.usage, searchMessage.usage);
 	const combined = [...displayDecision, resultBlock];
@@ -6897,6 +6909,1121 @@ claudeRoutes.post("/messages/count_tokens", async (c) => {
 	}
 });
 
+//#endregion
+//#region src/codex/thinking.ts
+const thinkingPrefix = "copilot-relay.claude-thinking.v1:";
+const isRecord$5 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const encodeThinking = (block) => thinkingPrefix + Buffer.from(JSON.stringify(block), "utf8").toString("base64url");
+/** Whether a reasoning item's encrypted_content is one the relay wrote for Claude. */
+const isRelayThinking = (encrypted) => typeof encrypted === "string" && encrypted.startsWith(thinkingPrefix);
+/** The Claude thinking block a reasoning item carries, or undefined when it is not the relay's. */
+const decodeThinking = (encrypted) => {
+	if (typeof encrypted !== "string" || !isRelayThinking(encrypted)) return;
+	let block;
+	try {
+		block = JSON.parse(Buffer.from(encrypted.slice(33), "base64url").toString("utf8"));
+	} catch {
+		return;
+	}
+	if (!isRecord$5(block)) return;
+	if (block.type === "thinking" && typeof block.thinking === "string" && typeof block.signature === "string") return {
+		type: "thinking",
+		thinking: block.thinking,
+		signature: block.signature
+	};
+	if (block.type === "redacted_thinking" && typeof block.data === "string") return {
+		type: "redacted_thinking",
+		data: block.data
+	};
+};
+
+//#endregion
+//#region src/codex/request.ts
+const copilotReasoningEfforts = [
+	"none",
+	"minimal",
+	"low",
+	"medium",
+	"high",
+	"xhigh",
+	"max"
+];
+const effortOrder = [
+	"none",
+	"minimal",
+	"low",
+	"medium",
+	"high",
+	"xhigh",
+	"max",
+	"ultra"
+];
+const isRecord$4 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const codexRequestError = (message, code, status$1 = 400) => new HTTPError(message, Response.json({ error: {
+	message,
+	type: "invalid_request_error",
+	code
+} }, { status: status$1 }), message);
+const parseCodexPayload = (text$1) => {
+	let body;
+	try {
+		body = JSON.parse(text$1);
+	} catch {
+		throw codexRequestError("The request body is not valid JSON.", "invalid_json");
+	}
+	if (!isRecord$4(body) || typeof body.model !== "string" || body.model.trim() === "") throw codexRequestError("The request needs a model.", "missing_model");
+	if (typeof body.input !== "string" && !Array.isArray(body.input)) throw codexRequestError("The request needs an input string or array.", "missing_input");
+	return body;
+};
+const catalogDescribesUpstream = (config) => config.modelCatalog?.baseUrl === config.copilotBaseUrl;
+/**
+* The Copilot model a Codex request is sent to, and the API that serves it.
+*
+* A model Copilot's catalog lists is used as named, so Codex's own model IDs reach the same
+* Copilot model. A GPT model listed with /responses is forwarded there; a Claude model listed with
+* /v1/messages is translated to Messages, because Copilot serves Claude only there and on Chat
+* Completions. A name the catalog does not list, such as Codex's internal codex-auto-review, goes
+* to the configured gptModel, as Claude Code's aliases do. Without a catalog a non-Claude name is
+* forwarded unchanged.
+*/
+const resolveCodexModel = async (config, requested) => {
+	const normalized = normalizeCopilotModelId(requested);
+	await ensureCopilotModelCatalog(config, normalized);
+	pinCopilotModelCatalog(config);
+	if (isClaudeModelId(normalized)) {
+		const capabilities$1 = getCachedCopilotModel(config, normalized);
+		if (capabilities$1 === void 0) throw codexRequestError(`${requested} is not in Copilot's model list. Check copilot-relay models for the exact Claude model ID.`, "relay_unsupported_model");
+		if (capabilities$1.supportedEndpoints !== void 0 && !capabilities$1.supportedEndpoints.includes("/v1/messages")) throw codexRequestError(`${normalized} does not serve Claude Messages on Copilot, which Codex needs for Claude models.`, "relay_unsupported_endpoint");
+		return {
+			model: normalized,
+			api: "messages"
+		};
+	}
+	const model = !(getCachedCopilotModel(config, normalized) !== void 0) && catalogDescribesUpstream(config) ? getModelRouting().gptModel : normalized;
+	const capabilities = getCachedCopilotModel(config, model);
+	const notChat = capabilities?.type !== void 0 && capabilities.type !== "chat";
+	const noResponses = capabilities?.supportedEndpoints !== void 0 && !capabilities.supportedEndpoints.includes("/responses");
+	if (notChat || noResponses) throw codexRequestError(`${model} does not serve the Responses API on Copilot. Choose a model that lists /responses in copilot-relay models.`, "relay_unsupported_endpoint");
+	return {
+		model,
+		api: "responses"
+	};
+};
+const effortRank = (effort) => effortOrder.indexOf(effort);
+/**
+* The reasoning effort to send for a requested one.
+*
+* A level the model advertises, or one this relay does not know, is sent as requested. Any other
+* level becomes the highest advertised level below it, or the lowest advertised level when none is
+* below it. A model that advertises no levels gets none, since Copilot rejects the field for it.
+*/
+const clampReasoningEffort = (requested, advertised) => {
+	if (advertised?.length === 0) return;
+	const accepted = advertised ?? copilotReasoningEfforts;
+	if (accepted.includes(requested) || effortRank(requested) === -1) return requested;
+	const ranked = accepted.filter((effort) => effortRank(effort) !== -1).sort((left, right) => effortRank(left) - effortRank(right));
+	return ranked.filter((effort) => effortRank(effort) <= effortRank(requested)).at(-1) ?? ranked[0];
+};
+/**
+* The body sent to Copilot for a Codex request.
+*
+* Copilot answers HTTP 400 to `service_tier`, to an `image_generation` tool, and to an effort it
+* does not accept, so those change. Reasoning items holding the relay's Claude thinking are removed.
+* Every other field, including Codex's prompt_cache_key and GPT's encrypted reasoning, is forwarded
+* unchanged.
+*/
+const prepareCodexPayload = (payload, model, capabilities) => {
+	const prepared = {
+		...payload,
+		model
+	};
+	const removed$1 = [];
+	if (Object.hasOwn(prepared, "service_tier")) {
+		delete prepared.service_tier;
+		removed$1.push("service_tier");
+	}
+	if (Array.isArray(prepared.input)) {
+		const input = prepared.input.filter((item) => !(isRecord$4(item) && item.type === "reasoning" && isRelayThinking(item.encrypted_content)));
+		if (input.length !== prepared.input.length) {
+			prepared.input = input;
+			removed$1.push("claude_reasoning");
+		}
+	}
+	if (Array.isArray(prepared.tools)) {
+		const tools = prepared.tools.filter((tool) => !(isRecord$4(tool) && tool.type === "image_generation"));
+		if (tools.length !== prepared.tools.length) {
+			prepared.tools = tools;
+			removed$1.push("image_generation");
+		}
+	}
+	const reasoning = isRecord$4(prepared.reasoning) ? prepared.reasoning : void 0;
+	const requestedEffort = typeof reasoning?.effort === "string" ? reasoning.effort : void 0;
+	let effectiveEffort = requestedEffort;
+	if (reasoning !== void 0 && requestedEffort !== void 0) {
+		effectiveEffort = clampReasoningEffort(requestedEffort, capabilities?.reasoningEfforts);
+		if (effectiveEffort === void 0) {
+			const withoutEffort = { ...reasoning };
+			delete withoutEffort.effort;
+			prepared.reasoning = withoutEffort;
+		} else if (effectiveEffort !== requestedEffort) prepared.reasoning = {
+			...reasoning,
+			effort: effectiveEffort
+		};
+	}
+	return {
+		payload: prepared,
+		removed: removed$1,
+		requestedEffort,
+		effectiveEffort
+	};
+};
+/**
+* Who started a Codex request, for Copilot's x-initiator header.
+*
+* A request continues the agent's own work unless its last input item is a user message: after a
+* tool call the last item is the tool's output. Codex marks its subagents (review, compaction,
+* memory consolidation, spawned agents) with x-openai-subagent, and those are always the agent.
+*/
+const getCodexInitiator = (input, subagent) => {
+	if (subagent !== void 0) return "agent";
+	if (typeof input === "string") return "user";
+	const last = Array.isArray(input) ? input.at(-1) : void 0;
+	return isRecord$4(last) && last.role === "user" && (last.type === void 0 || last.type === "message") ? "user" : "agent";
+};
+const includesImage = (value) => {
+	if (Array.isArray(value)) return value.some(includesImage);
+	if (!isRecord$4(value)) return false;
+	return value.type === "input_image" || Object.values(value).some(includesImage);
+};
+/**
+* A stream holding only `response.failed` with code `context_length_exceeded`.
+*
+* Copilot reports a prompt over the model's input limit as HTTP 400, which Codex treats as a fatal
+* error. Codex recognizes a context-window overflow only from this event, and answers it by
+* compacting the conversation.
+*/
+const contextOverflowStream = (requestId, message) => {
+	const event = {
+		type: "response.failed",
+		response: {
+			id: `resp_relay_${requestId}`,
+			object: "response",
+			status: "failed",
+			error: {
+				code: "context_length_exceeded",
+				message
+			}
+		}
+	};
+	return `event: response.failed\ndata: ${JSON.stringify(event)}\n\n`;
+};
+
+//#endregion
+//#region src/codex/messages.ts
+const claudeReasoningEfforts = [
+	"low",
+	"medium",
+	"high",
+	"xhigh",
+	"max"
+];
+const defaultMaxTokens = 32e3;
+const isRecord$3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const nameLimit = 64;
+/**
+* Claude tool names for Codex tools, and the way back.
+*
+* Claude accepts letters, digits, underscores and hyphens, at most 64 characters. A Codex name
+* outside that, or a tool inside a namespace, gets a sanitized name, made unique with a numbered
+* suffix. Names are assigned in the order tools are listed, so the same request gets the same names.
+*/
+var CodexToolNames = class {
+	byKey = /* @__PURE__ */ new Map();
+	byClaudeName = /* @__PURE__ */ new Map();
+	claudeName(target) {
+		const key = `${target.kind}\u0000${target.namespace ?? ""}\u0000${target.name}`;
+		const known = this.byKey.get(key);
+		if (known !== void 0) return known;
+		const base = (target.namespace === void 0 ? target.name : `${target.namespace}__${target.name}`).replaceAll(/[^A-Za-z0-9_-]/g, "_").slice(0, nameLimit) || "tool";
+		let name = base;
+		let suffix = 2;
+		while (this.byClaudeName.has(name)) {
+			const tail = `_${suffix}`;
+			name = base.slice(0, nameLimit - tail.length) + tail;
+			suffix++;
+		}
+		this.byKey.set(key, name);
+		this.byClaudeName.set(name, target);
+		return name;
+	}
+	target(claudeName) {
+		return this.byClaudeName.get(claudeName) ?? {
+			kind: "function",
+			name: claudeName
+		};
+	}
+};
+const customInputSchema = {
+	type: "object",
+	properties: { input: {
+		type: "string",
+		description: "The raw tool input."
+	} },
+	required: ["input"]
+};
+const customDescription = (tool) => {
+	const description = typeof tool.description === "string" ? tool.description : "";
+	const format = isRecord$3(tool.format) ? tool.format : void 0;
+	if (format?.type !== "grammar" || typeof format.definition !== "string") return description;
+	return `${description}\n\nPut the raw input in the input field. It must match this ${String(format.syntax ?? "")} grammar:\n${format.definition}`.trim();
+};
+const functionTool = (tool, name) => ({
+	name,
+	...typeof tool.description === "string" && tool.description && { description: tool.description },
+	input_schema: isRecord$3(tool.parameters) ? tool.parameters : {
+		type: "object",
+		properties: {}
+	}
+});
+const convertTool = (tool, names, namespace) => {
+	if (typeof tool.name !== "string") return;
+	const scope = namespace === void 0 ? {} : { namespace };
+	if (tool.type === "function") return functionTool(tool, names.claudeName({
+		kind: "function",
+		name: tool.name,
+		...scope
+	}));
+	if (tool.type === "custom") return {
+		name: names.claudeName({
+			kind: "custom",
+			name: tool.name,
+			...scope
+		}),
+		description: customDescription(tool),
+		input_schema: customInputSchema
+	};
+};
+const convertTools = (tools, names, dropped) => {
+	if (!Array.isArray(tools)) return [];
+	const converted = [];
+	for (const tool of tools) {
+		if (!isRecord$3(tool) || typeof tool.type !== "string") continue;
+		if (tool.type === "namespace" && typeof tool.name === "string" && Array.isArray(tool.tools)) {
+			for (const inner of tool.tools) {
+				if (!isRecord$3(inner)) continue;
+				const claudeTool$1 = convertTool(inner, names, tool.name);
+				if (claudeTool$1) converted.push(claudeTool$1);
+				else dropped.add(`tool:${tool.name}.${String(inner.type)}`);
+			}
+			continue;
+		}
+		const claudeTool = convertTool(tool, names, void 0);
+		if (claudeTool) converted.push(claudeTool);
+		else dropped.add(`tool:${tool.type}`);
+	}
+	return converted;
+};
+const imageBlock = (url) => {
+	const data = /^data:(image\/(?:png|jpeg|gif|webp));base64,(.+)$/s.exec(url);
+	if (data) return {
+		type: "image",
+		source: {
+			type: "base64",
+			media_type: data[1],
+			data: data[2]
+		}
+	};
+	if (/^https?:\/\//i.test(url)) return {
+		type: "image",
+		source: {
+			type: "url",
+			url
+		}
+	};
+};
+const contentBlocks = (content, allowImages) => {
+	if (typeof content === "string") return content ? [{
+		type: "text",
+		text: content
+	}] : [];
+	if (!Array.isArray(content)) return [];
+	const blocks = [];
+	for (const part of content) {
+		if (!isRecord$3(part)) continue;
+		const text$1 = part.type === "refusal" ? part.refusal : part.text;
+		if ((part.type === "input_text" || part.type === "output_text" || part.type === "refusal") && typeof text$1 === "string" && text$1) blocks.push({
+			type: "text",
+			text: text$1
+		});
+		else if (part.type === "input_image" && allowImages && typeof part.image_url === "string") {
+			const image = imageBlock(part.image_url);
+			if (image) blocks.push(image);
+		}
+	}
+	return blocks;
+};
+const toolResult = (callId, output) => {
+	const blocks = contentBlocks(output, true);
+	return {
+		type: "tool_result",
+		tool_use_id: callId,
+		content: blocks.length > 0 ? blocks : [{
+			type: "text",
+			text: "(no output)"
+		}]
+	};
+};
+const pushBlocks = (turns, role, blocks) => {
+	if (blocks.length === 0) return;
+	const last = turns.at(-1);
+	if (last?.role === role) last.content.push(...blocks);
+	else turns.push({
+		role,
+		content: [...blocks]
+	});
+};
+const toolId = (id) => typeof id === "string" && id ? id.replaceAll(/[^A-Za-z0-9_-]/g, "_") : "call_missing";
+const parseArguments = (value) => {
+	if (typeof value !== "string") return {};
+	try {
+		const parsed = JSON.parse(value);
+		return isRecord$3(parsed) ? parsed : {};
+	} catch {
+		return {};
+	}
+};
+const isCacheable = (block) => block.type !== "thinking" && block.type !== "redacted_thinking";
+const markCache = (block) => {
+	if (block) block.cache_control = { type: "ephemeral" };
+};
+const lastCacheable = (turn) => turn?.content.filter(isCacheable).at(-1);
+/**
+* Prompt-cache breakpoints as Claude Code places them: the end of the system prompt, the last tool,
+* the end of the conversation, and the end of the user turn before it, so the next request in a
+* tool loop still finds this one's prefix. Four marks, Claude's limit.
+*/
+const markCacheBreakpoints = (system, tools, turns) => {
+	markCache(system.at(-1));
+	markCache(tools.at(-1));
+	markCache(lastCacheable(turns.at(-1)));
+	markCache(lastCacheable(turns.slice(0, -1).filter((turn) => turn.role === "user").at(-1)));
+};
+const toolChoice = (choice, parallel, names) => {
+	let selected;
+	if (choice === "required") selected = { type: "any" };
+	else if (choice === "none") selected = { type: "none" };
+	else if (isRecord$3(choice) && choice.type === "function" && typeof choice.name === "string") selected = {
+		type: "tool",
+		name: names.claudeName({
+			kind: "function",
+			name: choice.name
+		})
+	};
+	else if (choice === "auto" || parallel === false) selected = { type: "auto" };
+	if (selected && parallel === false && selected.type !== "none") selected.disable_parallel_tool_use = true;
+	return selected;
+};
+const jsonSchemaFormat = (text$1) => {
+	const format = isRecord$3(text$1) && isRecord$3(text$1.format) ? text$1.format : void 0;
+	if (format?.type !== "json_schema" || !isRecord$3(format.schema)) return;
+	return `Your final answer must be a single JSON value that matches this JSON Schema, with no other text and no code fence:\n${JSON.stringify(format.schema)}`;
+};
+/**
+* The Claude Messages request for a Codex Responses request.
+*
+* Instructions and leading developer or system messages become the system prompt; a later developer
+* message becomes user text in place, so the history keeps its order. Function, custom and namespace
+* tools become Claude tools; hosted tools such as web_search are dropped. Calls and their outputs
+* become tool_use and tool_result blocks, and the relay's reasoning items become Claude thinking.
+*/
+const toClaudeRequest = (payload, model, capabilities) => {
+	const names = new CodexToolNames();
+	const dropped = /* @__PURE__ */ new Set();
+	const tools = convertTools(payload.tools, names, dropped);
+	const system = [];
+	const turns = [];
+	if (typeof payload.instructions === "string" && payload.instructions) system.push({
+		type: "text",
+		text: payload.instructions
+	});
+	const outputSchema = jsonSchemaFormat(payload.text);
+	if (outputSchema !== void 0) system.push({
+		type: "text",
+		text: outputSchema
+	});
+	const items = typeof payload.input === "string" ? [{
+		type: "message",
+		role: "user",
+		content: payload.input
+	}] : payload.input;
+	for (const item of items) {
+		if (!isRecord$3(item)) continue;
+		const type = typeof item.type === "string" ? item.type : "message";
+		if (type === "message" && (item.role === "developer" || item.role === "system")) {
+			const blocks = contentBlocks(item.content, false);
+			if (turns.length === 0) system.push(...blocks);
+			else pushBlocks(turns, "user", blocks);
+		} else if (type === "message") {
+			const role = item.role === "assistant" ? "assistant" : "user";
+			pushBlocks(turns, role, contentBlocks(item.content, role === "user"));
+		} else if (type === "reasoning") {
+			const block = decodeThinking(item.encrypted_content);
+			if (block) pushBlocks(turns, "assistant", [block]);
+			else dropped.add("reasoning");
+		} else if ((type === "function_call" || type === "custom_tool_call") && typeof item.name === "string") {
+			const custom = type === "custom_tool_call";
+			const target = {
+				kind: custom ? "custom" : "function",
+				name: item.name,
+				...typeof item.namespace === "string" && { namespace: item.namespace }
+			};
+			const input = custom ? { input: typeof item.input === "string" ? item.input : "" } : parseArguments(item.arguments);
+			pushBlocks(turns, "assistant", [{
+				type: "tool_use",
+				id: toolId(item.call_id),
+				name: names.claudeName(target),
+				input
+			}]);
+		} else if (type === "function_call_output" || type === "custom_tool_call_output") pushBlocks(turns, "user", [toolResult(toolId(item.call_id), item.output)]);
+		else dropped.add(type);
+	}
+	for (const turn of turns) if (turn.role === "user") turn.content.sort((left, right) => Number(right.type === "tool_result") - Number(left.type === "tool_result"));
+	markCacheBreakpoints(system, tools, turns);
+	const reasoning = isRecord$3(payload.reasoning) ? payload.reasoning : void 0;
+	const requestedEffort = typeof reasoning?.effort === "string" ? reasoning.effort : void 0;
+	const advertised = capabilities?.reasoningEfforts?.filter((effort) => claudeReasoningEfforts.includes(effort));
+	const effectiveEffort = requestedEffort === void 0 ? void 0 : clampReasoningEffort(requestedEffort, advertised ?? claudeReasoningEfforts);
+	const maxTokens = typeof payload.max_output_tokens === "number" && payload.max_output_tokens > 0 ? payload.max_output_tokens : capabilities?.limits?.max_output_tokens ?? defaultMaxTokens;
+	const choice = tools.length > 0 ? toolChoice(payload.tool_choice, payload.parallel_tool_calls, names) : void 0;
+	return {
+		payload: {
+			model,
+			max_tokens: maxTokens,
+			messages: turns,
+			stream: true,
+			...system.length > 0 && { system },
+			...tools.length > 0 && { tools },
+			...choice && { tool_choice: choice },
+			...effectiveEffort !== void 0 && {
+				thinking: { type: "adaptive" },
+				output_config: { effort: effectiveEffort }
+			}
+		},
+		tools: names,
+		dropped: [...dropped],
+		requestedEffort,
+		effectiveEffort
+	};
+};
+const callItem = (block, status$1) => {
+	if (block.target.kind === "custom") {
+		let input = block.json;
+		try {
+			const parsed = JSON.parse(block.json);
+			if (isRecord$3(parsed) && typeof parsed.input === "string") input = parsed.input;
+		} catch {}
+		return {
+			type: "custom_tool_call",
+			id: block.id,
+			call_id: block.callId,
+			name: block.target.name,
+			...block.target.namespace !== void 0 && { namespace: block.target.namespace },
+			input,
+			status: status$1
+		};
+	}
+	return {
+		type: "function_call",
+		id: block.id,
+		call_id: block.callId,
+		name: block.target.name,
+		...block.target.namespace !== void 0 && { namespace: block.target.namespace },
+		arguments: status$1 === "completed" ? block.json || "{}" : "",
+		status: status$1
+	};
+};
+const newBlock = (start$1, names, fallbackCallId) => {
+	if (start$1.type === "text") return {
+		kind: "message",
+		text: typeof start$1.text === "string" ? start$1.text : ""
+	};
+	if (start$1.type === "thinking") return {
+		kind: "reasoning",
+		thinking: typeof start$1.thinking === "string" ? start$1.thinking : "",
+		signature: ""
+	};
+	if (start$1.type === "redacted_thinking") return {
+		kind: "redacted",
+		data: typeof start$1.data === "string" ? start$1.data : ""
+	};
+	if (start$1.type === "tool_use" && typeof start$1.name === "string") return {
+		kind: "call",
+		callId: typeof start$1.id === "string" ? start$1.id : fallbackCallId,
+		target: names.target(start$1.name),
+		json: ""
+	};
+};
+const applyDelta = (block, delta) => {
+	if (block.kind === "message" && delta.type === "text_delta" && typeof delta.text === "string") {
+		block.text += delta.text;
+		return delta.text;
+	}
+	if (block.kind === "reasoning" && delta.type === "thinking_delta" && typeof delta.thinking === "string") {
+		block.thinking += delta.thinking;
+		return delta.thinking;
+	}
+	if (block.kind === "reasoning" && delta.type === "signature_delta" && typeof delta.signature === "string") {
+		block.signature += delta.signature;
+		return "";
+	}
+	if (block.kind === "call" && delta.type === "input_json_delta" && typeof delta.partial_json === "string") {
+		block.json += delta.partial_json;
+		return delta.partial_json;
+	}
+	return "";
+};
+const streamed = (block) => {
+	if (block.kind === "message") return block.text;
+	if (block.kind === "reasoning") return block.thinking;
+	if (block.kind === "call") return block.json;
+	return "";
+};
+const itemFor = (block) => {
+	if (block.kind === "message") return {
+		type: "message",
+		id: block.id,
+		role: "assistant",
+		status: "completed",
+		content: [{
+			type: "output_text",
+			text: block.text,
+			annotations: []
+		}]
+	};
+	if (block.kind === "reasoning") return {
+		type: "reasoning",
+		id: block.id,
+		summary: block.thinking ? [{
+			type: "summary_text",
+			text: block.thinking
+		}] : [],
+		encrypted_content: encodeThinking({
+			type: "thinking",
+			thinking: block.thinking,
+			signature: block.signature
+		})
+	};
+	if (block.kind === "redacted") return {
+		type: "reasoning",
+		id: block.id,
+		summary: [],
+		encrypted_content: encodeThinking({
+			type: "redacted_thinking",
+			data: block.data
+		})
+	};
+	return callItem(block, "completed");
+};
+const startEvents = (block) => {
+	if (block.kind === "message") return [{
+		type: "response.output_item.added",
+		output_index: block.index,
+		item: {
+			type: "message",
+			id: block.id,
+			role: "assistant",
+			status: "in_progress",
+			content: []
+		}
+	}, {
+		type: "response.content_part.added",
+		item_id: block.id,
+		output_index: block.index,
+		content_index: 0,
+		part: {
+			type: "output_text",
+			text: "",
+			annotations: []
+		}
+	}];
+	if (block.kind === "reasoning") return [{
+		type: "response.output_item.added",
+		output_index: block.index,
+		item: {
+			type: "reasoning",
+			id: block.id,
+			summary: []
+		}
+	}, {
+		type: "response.reasoning_summary_part.added",
+		item_id: block.id,
+		output_index: block.index,
+		summary_index: 0,
+		part: {
+			type: "summary_text",
+			text: ""
+		}
+	}];
+	if (block.kind === "redacted") return [{
+		type: "response.output_item.added",
+		output_index: block.index,
+		item: {
+			type: "reasoning",
+			id: block.id,
+			summary: []
+		}
+	}];
+	return [{
+		type: "response.output_item.added",
+		output_index: block.index,
+		item: callItem(block, "in_progress")
+	}];
+};
+const deltaEvents = (block, delta) => {
+	if (!delta) return [];
+	if (block.kind === "message") return [{
+		type: "response.output_text.delta",
+		item_id: block.id,
+		output_index: block.index,
+		content_index: 0,
+		delta
+	}];
+	if (block.kind === "reasoning") return [{
+		type: "response.reasoning_summary_text.delta",
+		item_id: block.id,
+		output_index: block.index,
+		summary_index: 0,
+		delta
+	}];
+	if (block.kind === "call" && block.target.kind === "function") return [{
+		type: "response.function_call_arguments.delta",
+		item_id: block.id,
+		output_index: block.index,
+		delta
+	}];
+	return [];
+};
+const doneEvents = (block, item) => {
+	const itemDone = {
+		type: "response.output_item.done",
+		output_index: block.index,
+		item
+	};
+	if (block.kind === "message") {
+		const part = {
+			type: "output_text",
+			text: block.text,
+			annotations: []
+		};
+		return [
+			{
+				type: "response.output_text.done",
+				item_id: block.id,
+				output_index: block.index,
+				content_index: 0,
+				text: block.text
+			},
+			{
+				type: "response.content_part.done",
+				item_id: block.id,
+				output_index: block.index,
+				content_index: 0,
+				part
+			},
+			itemDone
+		];
+	}
+	if (block.kind === "reasoning") return [
+		{
+			type: "response.reasoning_summary_text.done",
+			item_id: block.id,
+			output_index: block.index,
+			summary_index: 0,
+			text: block.thinking
+		},
+		{
+			type: "response.reasoning_summary_part.done",
+			item_id: block.id,
+			output_index: block.index,
+			summary_index: 0,
+			part: {
+				type: "summary_text",
+				text: block.thinking
+			}
+		},
+		itemDone
+	];
+	if (block.kind === "call" && block.target.kind === "function") return [{
+		type: "response.function_call_arguments.done",
+		item_id: block.id,
+		output_index: block.index,
+		arguments: item.arguments
+	}, itemDone];
+	return [itemDone];
+};
+const incompleteReasons = {
+	max_tokens: "max_output_tokens",
+	refusal: "content_filter"
+};
+const heldProgressMs = 3e4;
+const count = (value) => typeof value === "number" && Number.isFinite(value) ? value : 0;
+const responsesUsage = (usage$1) => {
+	const cacheRead = count(usage$1.cache_read_input_tokens);
+	const inputTokens = count(usage$1.input_tokens) + cacheRead + count(usage$1.cache_creation_input_tokens);
+	const outputTokens = count(usage$1.output_tokens);
+	return {
+		input_tokens: inputTokens,
+		input_tokens_details: { cached_tokens: cacheRead },
+		output_tokens: outputTokens,
+		output_tokens_details: { reasoning_tokens: 0 },
+		total_tokens: inputTokens + outputTokens
+	};
+};
+/**
+* The Responses events for a Claude Messages stream.
+*
+* Text becomes a message item, thinking a reasoning item whose summary is the thinking text and
+* whose encrypted_content carries the signed block back on the next turn, and tool_use a
+* function_call or custom_tool_call. Codex runs a call as soon as its item is done, so from the first
+* tool_use on, blocks are held in order until Claude stops: released with their calls when it stops
+* with tool_use, released without them when it stops any other way, as when max_tokens cuts a call
+* short. The stream ends with response.completed, or response.incomplete when Claude stopped at
+* max_tokens or refused. An upstream failure, or a stream that ends with a block still open, ends it
+* with response.failed, which Codex retries.
+*/
+async function* toCodexEvents(events$1, model, names) {
+	let responseId = "resp_relay";
+	const createdAt = Math.floor(Date.now() / 1e3);
+	const output = [];
+	const open = /* @__PURE__ */ new Map();
+	const held = [];
+	let holding = false;
+	let lastProgress = 0;
+	let usage$1 = {};
+	let stopReason;
+	let nextIndex = 0;
+	let stopped = false;
+	const response = (status$1, extra = {}) => ({
+		id: responseId,
+		object: "response",
+		created_at: createdAt,
+		model,
+		status: status$1,
+		output: output.filter(Boolean),
+		...extra
+	});
+	const place = (block) => {
+		const index = nextIndex;
+		nextIndex++;
+		return {
+			...block,
+			id: `${responseId}_${index}`,
+			index
+		};
+	};
+	try {
+		for await (const event of events$1) {
+			if (holding && Date.now() - lastProgress >= heldProgressMs) {
+				lastProgress = Date.now();
+				yield {
+					type: "response.in_progress",
+					response: response("in_progress")
+				};
+			}
+			if (event.type === "message_start") {
+				const message = isRecord$3(event.message) ? event.message : {};
+				if (typeof message.id === "string") responseId = `resp_${message.id}`;
+				usage$1 = {
+					...usage$1,
+					...isRecord$3(message.usage) ? message.usage : {}
+				};
+				yield {
+					type: "response.created",
+					response: response("in_progress")
+				};
+				yield {
+					type: "response.in_progress",
+					response: response("in_progress")
+				};
+			} else if (event.type === "content_block_start" && typeof event.index === "number" && isRecord$3(event.content_block)) {
+				const block = newBlock(event.content_block, names, `${responseId}_call_${event.index}`);
+				if (block?.kind === "call" && !holding) {
+					holding = true;
+					lastProgress = Date.now();
+				}
+				if (block !== void 0 && holding) {
+					held.push(block);
+					open.set(event.index, { block });
+				} else if (block !== void 0) {
+					const placed = place(block);
+					open.set(event.index, {
+						block: placed,
+						placed
+					});
+					yield* startEvents(placed);
+					yield* deltaEvents(placed, streamed(placed));
+				}
+			} else if (event.type === "content_block_delta" && typeof event.index === "number" && isRecord$3(event.delta)) {
+				const entry = open.get(event.index);
+				if (entry !== void 0) {
+					const piece = applyDelta(entry.block, event.delta);
+					if (entry.placed !== void 0) yield* deltaEvents(entry.placed, piece);
+				}
+			} else if (event.type === "content_block_stop" && typeof event.index === "number") {
+				const entry = open.get(event.index);
+				open.delete(event.index);
+				if (entry?.placed !== void 0) {
+					const item = itemFor(entry.placed);
+					output[entry.placed.index] = item;
+					yield* doneEvents(entry.placed, item);
+				}
+			} else if (event.type === "message_delta") {
+				if (isRecord$3(event.delta) && typeof event.delta.stop_reason === "string") stopReason = event.delta.stop_reason;
+				usage$1 = {
+					...usage$1,
+					...isRecord$3(event.usage) ? event.usage : {}
+				};
+			} else if (event.type === "message_stop") {
+				stopped = true;
+				if (open.size > 0) throw new Error("Claude stream stopped with a content block still open.");
+				for (const block of held) {
+					if (block.kind === "call" && stopReason !== "tool_use") continue;
+					const placed = place(block);
+					const item = itemFor(placed);
+					output[placed.index] = item;
+					yield* startEvents(placed);
+					yield* deltaEvents(placed, streamed(placed));
+					yield* doneEvents(placed, item);
+				}
+				const incompleteReason = incompleteReasons[String(stopReason)];
+				if (incompleteReason !== void 0) yield {
+					type: "response.incomplete",
+					response: response("incomplete", {
+						usage: responsesUsage(usage$1),
+						incomplete_details: { reason: incompleteReason }
+					})
+				};
+				else yield {
+					type: "response.completed",
+					response: response("completed", { usage: responsesUsage(usage$1) })
+				};
+			}
+		}
+		if (!stopped) throw new Error("Claude stream ended without message_stop.");
+	} catch (error) {
+		yield {
+			type: "response.failed",
+			response: response("failed", { error: {
+				code: "server_error",
+				message: error instanceof Error ? error.message : "Claude stream failed."
+			} })
+		};
+	}
+}
+/** The final response of a translated stream, for a request that did not ask to stream. */
+const collectCodexResponse = async (events$1) => {
+	let final = {
+		status: "failed",
+		error: {
+			code: "server_error",
+			message: "Claude stream produced no response."
+		}
+	};
+	for await (const event of events$1) if ((event.type === "response.completed" || event.type === "response.incomplete" || event.type === "response.failed") && isRecord$3(event.response)) final = event.response;
+	return final;
+};
+/** Responses events as SSE bytes. */
+async function* encodeSse(events$1) {
+	const encoder = new TextEncoder();
+	for await (const event of events$1) yield encoder.encode(`event: ${String(event.type)}\ndata: ${JSON.stringify(event)}\n\n`);
+}
+
+//#endregion
+//#region src/routes/responses.ts
+const responsesRoutes = new Hono();
+const forwardedHeaders = [
+	"content-type",
+	"retry-after",
+	"openai-model",
+	"x-request-id",
+	"x-github-request-id",
+	"x-copilot-service-request-id"
+];
+const copyForwardedHeaders = (source) => {
+	const headers = new Headers();
+	for (const name of forwardedHeaders) {
+		const value = source.get(name);
+		if (value !== null) headers.set(name, value);
+	}
+	return headers;
+};
+const readSubagent = (value) => {
+	if (value === void 0) return;
+	return /^[\w.-]{1,64}$/.test(value) ? value : "other";
+};
+const sourceOf = (chunks) => ({
+	read: async () => await chunks.next(),
+	cancel: async () => await chunks.return(void 0)
+});
+const sseHeaders = {
+	"content-type": "text/event-stream",
+	"cache-control": "no-cache"
+};
+/**
+* Passes the upstream body to the client and settles the request trace when it ends.
+*
+* The trace cancels every upstream body still open once the handler settles, so a streamed answer
+* must settle the handler only after its last byte, an error, or the client's cancellation.
+*/
+const settleWhenDone = (source, trace) => {
+	let settled = false;
+	const settle = (error) => {
+		if (settled) return;
+		settled = true;
+		trace?.handlerSettled(error);
+	};
+	return new ReadableStream({
+		pull: async (controller) => {
+			try {
+				const next = await source.read();
+				if (settled) return;
+				if (next.done || next.value === void 0) {
+					controller.close();
+					settle();
+					return;
+				}
+				controller.enqueue(next.value);
+			} catch (error) {
+				if (!settled) controller.error(error);
+				settle(error);
+			}
+		},
+		cancel: async (reason) => {
+			settle();
+			await source.cancel(reason).catch(() => {});
+		}
+	}, { highWaterMark: 0 });
+};
+responsesRoutes.post("/responses", async (c) => {
+	const config = c.get("config");
+	const requestId = c.get("requestId");
+	const trace = c.get("requestTrace");
+	const signal = createCopilotRequestSignal(c.req.raw.signal, config.upstreamTimeoutMs);
+	let response;
+	let stream = false;
+	try {
+		const payload = parseCodexPayload(await c.req.text());
+		stream = payload.stream === true;
+		const route = await resolveCodexModel(config, payload.model);
+		const capabilities = getCachedCopilotModel(config, route.model);
+		const subagent = readSubagent(c.req.header("x-openai-subagent"));
+		const initiator = getCodexInitiator(payload.input, subagent);
+		if (route.api === "messages") {
+			const request = toClaudeRequest(payload, route.model, capabilities);
+			if (request.dropped.length > 0) log.info(sanitizeTerminalString(`request_id=${requestId} Codex items Claude has no equivalent for, dropped: ${request.dropped.join(",")}`));
+			const events$1 = toCodexEvents(nativeEvents(await createNativeMessages(config, request.payload, {
+				requestId,
+				initiator,
+				signal,
+				client: "codex",
+				requestedModel: payload.model
+			})), payload.model, request.tools);
+			if (!stream) {
+				const final = await collectCodexResponse(events$1);
+				return c.json(final, final.status === "failed" ? 502 : 200);
+			}
+			trace?.deferHandler();
+			return new Response(settleWhenDone(sourceOf(encodeSse(events$1)), trace), {
+				status: 200,
+				headers: sseHeaders
+			});
+		}
+		const prepared = prepareCodexPayload(payload, route.model, capabilities);
+		log.info(sanitizeTerminalString([
+			`request_id=${requestId}`,
+			"Model request client=codex",
+			`requested_model=${payload.model}`,
+			`upstream_model=${route.model}`,
+			"upstream_api=responses",
+			`requested_think_effort=${prepared.requestedEffort ?? "unset"}`,
+			`effective_think_effort=${prepared.effectiveEffort ?? "omitted"}`,
+			`initiator=${initiator}`,
+			...subagent === void 0 ? [] : [`subagent=${subagent}`],
+			...prepared.removed.length === 0 ? [] : [`removed=${prepared.removed.join(",")}`]
+		].join(" ")));
+		response = await fetchCopilot(getCopilotProviderContext(config), "/responses", {
+			method: "POST",
+			headers: {
+				accept: stream ? "text/event-stream" : "application/json",
+				"content-type": "application/json"
+			},
+			body: JSON.stringify(prepared.payload)
+		}, {
+			initiator,
+			requestId,
+			signal,
+			timeoutMs: config.upstreamTimeoutMs,
+			vision: includesImage(prepared.payload.input)
+		});
+		if (!response.ok) {
+			const detail = await readCopilotText(response, signal, config.upstreamTimeoutMs);
+			const overflow = toPromptTooLongError(response.status, detail);
+			if (overflow && stream) {
+				c.set("requestErrorMessage", overflow.message);
+				log.error(`request_id=${requestId} ${overflow.message}; sent to Codex as context_length_exceeded`);
+				return new Response(contextOverflowStream(requestId, overflow.message), {
+					status: 200,
+					headers: sseHeaders
+				});
+			}
+			const message = `Copilot /responses returned ${response.status}`;
+			c.set("requestErrorMessage", message);
+			log.error(`request_id=${requestId} ${message}`);
+			return new Response(detail, {
+				status: response.status,
+				headers: copyForwardedHeaders(response.headers)
+			});
+		}
+	} catch (error) {
+		if (error instanceof ProxyNotImplementedError) {
+			c.set("requestErrorMessage", error.message);
+			return c.json({ error: {
+				message: error.message,
+				type: "server_error",
+				code: "relay_not_configured"
+			} }, 501);
+		}
+		if (!(error instanceof HTTPError)) throw error;
+		if (error instanceof PromptTooLongError && stream) {
+			c.set("requestErrorMessage", error.message);
+			log.error(`request_id=${requestId} ${error.message}; sent to Codex as context_length_exceeded`);
+			return new Response(contextOverflowStream(requestId, error.message), {
+				status: 200,
+				headers: sseHeaders
+			});
+		}
+		const message = sanitizeTerminalString(error.message);
+		c.set("requestErrorMessage", message);
+		log.error(`request_id=${requestId} ${message}`);
+		if (error.response.status === 400 && trace?.manifest.exchanges.length === 0) trace.recordFailure("local-validation");
+		return new Response(await error.response.arrayBuffer(), {
+			status: error.response.status,
+			headers: copyForwardedHeaders(error.response.headers)
+		});
+	}
+	const headers = copyForwardedHeaders(response.headers);
+	if (stream) headers.set("cache-control", "no-cache");
+	if (!response.body) return new Response(null, {
+		status: response.status,
+		headers
+	});
+	trace?.deferHandler();
+	return new Response(settleWhenDone(response.body.getReader(), trace), {
+		status: response.status,
+		headers
+	});
+});
+
 //#endregion
 //#region src/server.ts
 const loggedRequestHeaders = [
@@ -6951,6 +8078,11 @@ const presentsApiKey = (headers, apiKey) => {
 	for (const presented of [headers.get("x-api-key"), bearer]) if (typeof presented === "string" && timingSafeEqual(sha256(presented), expected)) matched = true;
 	return matched;
 };
+const jsonBodyPaths = new Set([
+	"/v1/messages",
+	"/v1/messages/count_tokens",
+	"/v1/responses"
+]);
 const isOpenProbe = (method, path$1) => method === "GET" && path$1 === "/healthz" || (method === "GET" || method === "HEAD") && path$1 === "/api/hello";
 const createServer = (config) => {
 	const app = new Hono();
@@ -7007,7 +8139,7 @@ const createServer = (config) => {
 				}
 			}, 401, { "www-authenticate": "Bearer" });
 		}
-		if (c.req.method === "POST" && (c.req.path === "/v1/messages" || c.req.path === "/v1/messages/count_tokens") && (incoming ? Boolean(incoming.headers["transfer-encoding"]) || Number(incoming.headers["content-length"] ?? 0) > 0 : c.req.raw.body !== null) && c.req.header("content-type")?.split(";", 1)[0].trim().toLowerCase() !== "application/json") {
+		if (c.req.method === "POST" && jsonBodyPaths.has(c.req.path) && (incoming ? Boolean(incoming.headers["transfer-encoding"]) || Number(incoming.headers["content-length"] ?? 0) > 0 : c.req.raw.body !== null) && c.req.header("content-type")?.split(";", 1)[0].trim().toLowerCase() !== "application/json") {
 			const message = "Content-Type must be application/json";
 			c.set("requestErrorMessage", message);
 			return c.json({ error: { message } }, 415);
@@ -7051,6 +8183,7 @@ const createServer = (config) => {
 	}));
 	app.on(["GET", "HEAD"], "/api/hello", (c) => c.body(null, 200));
 	app.route("/v1", claudeRoutes);
+	app.route("/v1", responsesRoutes);
 	app.notFound(async (c) => {
 		const message = "Unsupported Claude API route";
 		c.set("requestErrorMessage", message);
@@ -7428,14 +8561,14 @@ const renderConfigGuide = (configPath$1, configured, chosen) => {
 //#region src/models.ts
 var ModelsUsageError = class extends Error {};
 const printable = (text$1) => scrubLogSecrets(terminalText(text$1));
-const displayName = (name) => {
+const displayName$1 = (name) => {
 	const text$1 = printable(name ?? "").trim();
 	if (text$1 === "") return;
 	return text$1.length > 80 ? `${text$1.slice(0, 77)}...` : text$1;
 };
 const listedModels = (config, catalog) => [...catalog.models.keys()].sort().map((id) => {
 	const selection = selectCopilotEndpoint(config, id);
-	const name = displayName(catalog.models.get(id)?.name);
+	const name = displayName$1(catalog.models.get(id)?.name);
 	return {
 		id: printable(id),
 		...name !== void 0 && { name },
@@ -8230,9 +9363,9 @@ const packagedEntryCandidate = (command, cwd) => {
 const packageEntryProof = async (entry) => {
 	try {
 		if (!(await fs.stat(entry)).isFile()) return "nonrelay";
-		const canonical = (await fs.realpath(entry)).replaceAll("\\", "/");
-		if (!/\/(?:dist\/main\.js|src\/main\.ts)$/.test(canonical)) return "nonrelay";
-		const manifest = JSON.parse(await fs.readFile(posix.join(posix.dirname(posix.dirname(canonical)), "package.json"), "utf8"));
+		const canonical$1 = (await fs.realpath(entry)).replaceAll("\\", "/");
+		if (!/\/(?:dist\/main\.js|src\/main\.ts)$/.test(canonical$1)) return "nonrelay";
+		const manifest = JSON.parse(await fs.readFile(posix.join(posix.dirname(posix.dirname(canonical$1)), "package.json"), "utf8"));
 		return typeof manifest === "object" && manifest !== null && "name" in manifest && manifest.name === "copilot-relay" ? "relay" : "nonrelay";
 	} catch {
 		return "nonrelay";
@@ -8300,9 +9433,9 @@ const verifyCommand = async (command, cwd) => {
 		}
 		const program = resolve$1(flat.program);
 		if (!(await fs.stat(program)).isFile()) return "unknown";
-		const canonical = (await fs.realpath(program)).replaceAll("\\", "/");
-		if (!/(?:^|\/)copilot-relay(?:-[A-Za-z0-9._-]+)?\/(?:dist\/main\.js|src\/main\.ts)$/.test(canonical)) return "unknown";
-		const packagePath = posix.join(posix.dirname(posix.dirname(canonical)), "package.json");
+		const canonical$1 = (await fs.realpath(program)).replaceAll("\\", "/");
+		if (!/(?:^|\/)copilot-relay(?:-[A-Za-z0-9._-]+)?\/(?:dist\/main\.js|src\/main\.ts)$/.test(canonical$1)) return "unknown";
+		const packagePath = posix.join(posix.dirname(posix.dirname(canonical$1)), "package.json");
 		if (!(await fs.stat(packagePath)).isFile()) return "unknown";
 		const manifest = JSON.parse(await fs.readFile(packagePath, "utf8"));
 		if (typeof manifest !== "object" || manifest === null || !("name" in manifest) || manifest.name !== "copilot-relay") return "unknown";
@@ -8601,11 +9734,11 @@ const knownModelEnvKeys = [
 	"ANTHROPIC_SMALL_FAST_MODEL",
 	"CLAUDE_CODE_SUBAGENT_MODEL"
 ];
-const isRecord$1 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const isRecord$2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 const hasMalformedModelOverride = (parsed) => {
 	if (parsed.model !== void 0 && typeof parsed.model !== "string") return true;
 	const env = parsed.env;
-	if (!isRecord$1(env)) return false;
+	if (!isRecord$2(env)) return false;
 	return knownModelEnvKeys.some((key) => env[key] !== void 0 && typeof env[key] !== "string");
 };
 const hasPrimaryModelOverride = (parsed, env) => typeof parsed.model === "string" || typeof env.ANTHROPIC_MODEL === "string";
@@ -8629,7 +9762,7 @@ async function applyClaudeConfig(input) {
 	};
 	if (raw.trim().length > 0) try {
 		const value = JSON.parse(raw);
-		if (!isRecord$1(value) || value.env !== void 0 && !isRecord$1(value.env) || hasMalformedModelOverride(value)) return {
+		if (!isRecord$2(value) || value.env !== void 0 && !isRecord$2(value.env) || hasMalformedModelOverride(value)) return {
 			configPath: configPath$1,
 			changed: false,
 			created: false
@@ -8642,7 +9775,7 @@ async function applyClaudeConfig(input) {
 			created: false
 		};
 	}
-	const env = isRecord$1(parsed.env) ? { ...parsed.env } : {};
+	const env = isRecord$2(parsed.env) ? { ...parsed.env } : {};
 	const previousBaseUrl = typeof env.ANTHROPIC_BASE_URL === "string" ? env.ANTHROPIC_BASE_URL : void 0;
 	const hadPrimaryModelOverride = hasPrimaryModelOverride(parsed, env);
 	const contextWindow = input.gptLimits?.max_context_window_tokens;
@@ -8680,9 +9813,370 @@ async function applyClaudeConfig(input) {
 	};
 }
 
+//#endregion
+//#region src/codex/catalog.ts
+const effortDescriptions = {
+	none: "No extra reasoning",
+	minimal: "Minimal reasoning",
+	low: "Fast responses with lighter reasoning",
+	medium: "Balances speed and reasoning depth for everyday tasks",
+	high: "Greater reasoning depth for complex problems",
+	xhigh: "Extra high reasoning depth for complex problems",
+	max: "Maximum reasoning depth for the hardest problems"
+};
+const codexContextWindow = 272e3;
+const isRecord$1 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const readVendorFile = async (name) => {
+	let currentDir = dirname(fileURLToPath(import.meta.url));
+	while (true) try {
+		return await fs.readFile(resolve(currentDir, "vendor", "codex", name), "utf8");
+	} catch (error) {
+		if (error.code !== "ENOENT") throw error;
+		const parentDir = dirname(currentDir);
+		if (parentDir === currentDir) throw new Error(`vendor/codex/${name} is missing from the package.`);
+		currentDir = parentDir;
+	}
+};
+const readCodexVendorFiles = async () => {
+	const models$1 = JSON.parse(await readVendorFile("models.json"));
+	const entries = isRecord$1(models$1) && Array.isArray(models$1.models) ? models$1.models : [];
+	const bundled = /* @__PURE__ */ new Map();
+	for (const entry of entries) if (isRecord$1(entry) && typeof entry.slug === "string") bundled.set(entry.slug, entry);
+	return {
+		bundled,
+		prompt: await readVendorFile("prompt.md")
+	};
+};
+const displayName = (model) => model.capabilities?.name || model.id;
+/**
+* A catalog entry for a model Codex does not ship.
+*
+* It enables Codex's freeform apply_patch tool and its shell tool, lists the reasoning levels Copilot
+* advertises, and uses the instructions Codex gives any model it does not know.
+*/
+const generatedEntry = (model, priority, prompt) => {
+	const levels = (model.capabilities?.reasoningEfforts ?? []).filter((effort) => Object.hasOwn(effortDescriptions, effort)).map((effort) => ({
+		effort,
+		description: effortDescriptions[effort]
+	}));
+	const defaultLevel = levels.find((level) => level.effort === "medium") ?? levels[0];
+	const maxPrompt = model.capabilities?.limits?.max_prompt_tokens;
+	return {
+		slug: model.id,
+		display_name: displayName(model),
+		description: `${displayName(model)} through copilot-relay`,
+		...defaultLevel && { default_reasoning_level: defaultLevel.effort },
+		supported_reasoning_levels: levels,
+		shell_type: "shell_command",
+		visibility: "list",
+		supported_in_api: true,
+		priority,
+		support_verbosity: false,
+		truncation_policy: {
+			mode: "tokens",
+			limit: 1e4
+		},
+		experimental_supported_tools: [],
+		apply_patch_tool_type: "freeform",
+		supports_parallel_tool_calls: true,
+		input_modalities: ["text", "image"],
+		...maxPrompt !== void 0 && {
+			context_window: Math.min(codexContextWindow, maxPrompt),
+			max_context_window: maxPrompt
+		},
+		model_messages: { instructions_template: prompt }
+	};
+};
+/**
+* The catalog for these models, in order: the first is Codex's default.
+*
+* A model Codex ships keeps Codex's own entry, so its tuned instructions and settings are unchanged;
+* only its position and visibility change. Any other model, such as a Claude model, gets a generated
+* entry.
+*/
+const buildCodexCatalog = (models$1, vendor) => {
+	const seen = /* @__PURE__ */ new Set();
+	const entries = [];
+	for (const model of models$1) {
+		if (seen.has(model.id)) continue;
+		seen.add(model.id);
+		const priority = entries.length + 1;
+		const bundled = vendor.bundled.get(model.id);
+		entries.push(bundled ? {
+			...bundled,
+			visibility: "list",
+			priority
+		} : generatedEntry(model, priority, vendor.prompt));
+	}
+	return { models: entries };
+};
+
+//#endregion
+//#region src/codex/setup.ts
+const codexProviderId = "copilot-relay";
+/** config.toml holds the relay's provider in a form the relay will not rewrite safely. */
+var CodexConfigError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "CodexConfigError";
+	}
+};
+const isTable = (value) => typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Date);
+const tomlString = (value) => JSON.stringify(value);
+const parseOptions = { integersAsBigInt: "asNeeded" };
+const providerPath = ["model_providers", codexProviderId];
+const providerBlock = (input) => [
+	`[model_providers.${codexProviderId}]`,
+	"# Written by copilot-relay start (codexSetup); edits in this table are replaced on the next start.",
+	`name = ${tomlString(codexProviderId)}`,
+	`base_url = ${tomlString(`${input.baseUrl}/v1`)}`,
+	"wire_api = \"responses\"",
+	"requires_openai_auth = false",
+	"supports_websockets = false",
+	...input.apiKey ? [`http_headers = { "x-api-key" = ${tomlString(input.apiKey)} }`] : []
+];
+const providerValue = (input) => ({
+	name: codexProviderId,
+	base_url: `${input.baseUrl}/v1`,
+	wire_api: "responses",
+	requires_openai_auth: false,
+	supports_websockets: false,
+	...input.apiKey ? { http_headers: { "x-api-key": input.apiKey } } : {}
+});
+const isProviderPath = (parts) => providerPath.every((part, index) => parts[index] === part);
+const findClose = (line, from, quote) => {
+	let at = from;
+	while (at < line.length) if (quote === "\"" && line[at] === "\\") at += 2;
+	else if (line[at] === quote) return at;
+	else at++;
+	return -1;
+};
+const unescapeBasic = (raw) => {
+	try {
+		return JSON.parse(`"${raw}"`);
+	} catch {
+		return raw;
+	}
+};
+const skipSpace = (line, from) => {
+	let at = from;
+	while (line[at] === " " || line[at] === "	") at++;
+	return at;
+};
+const bareKey = /[A-Za-z0-9_-]+/y;
+const readKey = (line, start$1) => {
+	const parts = [];
+	let at = skipSpace(line, start$1);
+	while (at < line.length) {
+		const quote = line[at];
+		if (quote === "\"" || quote === "'") {
+			const close = findClose(line, at + 1, quote);
+			if (close === -1) return;
+			const raw = line.slice(at + 1, close);
+			parts.push(quote === "\"" ? unescapeBasic(raw) : raw);
+			at = close + 1;
+		} else {
+			bareKey.lastIndex = at;
+			const match = bareKey.exec(line);
+			if (!match) return;
+			parts.push(match[0]);
+			at = bareKey.lastIndex;
+		}
+		at = skipSpace(line, at);
+		if (line[at] !== ".") return {
+			parts,
+			end: at
+		};
+		at = skipSpace(line, at + 1);
+	}
+};
+const readHeader = (line) => {
+	const open = /^\s*\[\[?/.exec(line);
+	if (!open) return;
+	const key = readKey(line, open[0].length);
+	if (!key) return;
+	const close = open[0].trimStart() === "[[" ? "]]" : "]";
+	const rest = line.slice(key.end);
+	if (!rest.startsWith(close) || !/^\s*(?:#.*)?$/.test(rest.slice(close.length))) return;
+	return key.parts;
+};
+const readAssignedKey = (line) => {
+	const key = readKey(line, 0);
+	if (!key || line[key.end] !== "=") return;
+	return key.parts;
+};
+const stringStateAfter = (line, state) => {
+	let open = state;
+	let at = 0;
+	while (at < line.length) {
+		const char = line[at];
+		if (open === "\"\"\"" && char === "\\") at += 2;
+		else if (open !== "" && line.startsWith(open, at)) {
+			at += 3;
+			while (line[at] === open[0]) at++;
+			open = "";
+		} else if (open !== "") at++;
+		else if (char === "#") return "";
+		else if (line.startsWith("\"\"\"", at) || line.startsWith("'''", at)) {
+			open = line.slice(at, at + 3);
+			at += 3;
+		} else if (char === "\"" || char === "'") {
+			const close = findClose(line, at + 1, char);
+			at = close === -1 ? line.length : close + 1;
+		} else at++;
+	}
+	return open;
+};
+const parseLines = (lines) => {
+	const parsed = [];
+	let table = [];
+	let state = "";
+	for (const text$1 of lines) {
+		if (state !== "") parsed.push({
+			text: text$1,
+			table,
+			header: false
+		});
+		else {
+			const header = readHeader(text$1);
+			if (header) table = header;
+			const key = header ? void 0 : readAssignedKey(text$1);
+			parsed.push({
+				text: text$1,
+				table,
+				header: header !== void 0,
+				...key && { key }
+			});
+		}
+		state = stringStateAfter(text$1, state);
+	}
+	return parsed;
+};
+const parseToml = (text$1) => {
+	try {
+		return parse(text$1, parseOptions);
+	} catch (error) {
+		if (error instanceof TomlError) throw new CodexConfigError(`config.toml is not valid TOML (line ${error.line}); fix it, or set codexSetup: false.`);
+		throw error;
+	}
+};
+const canonical = (value) => {
+	if (value instanceof Date) return ["date", value.toISOString()];
+	if (Array.isArray(value)) return ["array", value.map(canonical)];
+	if (isTable(value)) return ["table", Object.fromEntries(Object.keys(value).sort().map((key) => [key, canonical(value[key])]))];
+	if (typeof value === "number" && Object.is(value, -0)) return ["number", "-0"];
+	return [typeof value, String(value)];
+};
+const sameToml = (left, right) => JSON.stringify(canonical(left)) === JSON.stringify(canonical(right));
+const parsesTo = (text$1) => {
+	try {
+		return parse(text$1, parseOptions);
+	} catch {
+		return;
+	}
+};
+/**
+* config.toml with the relay's provider selected.
+*
+* Sets the top-level model_provider and model_catalog_json, and model when it does not already name
+* one of the catalog's models. Replaces the [model_providers.copilot-relay] table, or appends it.
+* The edit works line by line so comments and layout stay, and is then checked by parsing: unless
+* the result reads as the original with only those values changed, it throws instead.
+*/
+const editCodexConfig = (text$1, input) => {
+	const original = parseToml(text$1);
+	const eol = text$1.includes("\r\n") ? "\r\n" : "\n";
+	const parsed = parseLines(text$1.length === 0 ? [] : text$1.replace(/\r?\n$/, "").split(/\r?\n/));
+	for (const [index, line] of parsed.entries()) {
+		if (line.key === void 0 || isProviderPath(line.table)) continue;
+		const assigned = [...line.table, ...line.key];
+		if (isProviderPath(assigned)) throw new CodexConfigError(`config.toml line ${index + 1} defines model_providers.${codexProviderId} outside its own table; move it into [model_providers.${codexProviderId}] or remove it.`);
+		if (assigned.length === 1 && assigned[0] === "model_providers") throw new CodexConfigError(`config.toml line ${index + 1} defines model_providers as an inline table, which cannot take a [model_providers.${codexProviderId}] table; write it as [model_providers.<name>] tables.`);
+	}
+	const kept = parsed.filter((line) => !isProviderPath(line.table));
+	const lines = kept.map((line) => line.text);
+	let firstHeader = kept.findIndex((line) => line.header);
+	if (firstHeader === -1) firstHeader = lines.length;
+	const currentModel = typeof original.model === "string" ? original.model : void 0;
+	const model = currentModel !== void 0 && input.models.includes(currentModel) ? currentModel : input.models[0];
+	const settings = [
+		["model_provider", codexProviderId],
+		["model_catalog_json", input.catalogPath],
+		["model", model]
+	];
+	const inserted = [];
+	for (const [key, value] of settings) {
+		const existing = kept.findIndex((line, index) => index < firstHeader && line.key?.length === 1 && line.key[0] === key);
+		if (existing === -1) inserted.push(`${key} = ${tomlString(value)}`);
+		else lines[existing] = `${key} = ${tomlString(value)}`;
+	}
+	if (inserted.length > 0) {
+		let insertAt = firstHeader;
+		while (insertAt > 0 && lines[insertAt - 1].trim() === "") insertAt--;
+		const needsGap = insertAt === firstHeader && firstHeader < lines.length;
+		lines.splice(insertAt, 0, ...inserted, ...needsGap ? [""] : []);
+	}
+	while (lines.length > 0 && lines.at(-1).trim() === "") lines.pop();
+	const block = providerBlock(input);
+	const result = (lines.length > 0 ? [
+		...lines,
+		"",
+		...block
+	] : block).join(eol) + eol;
+	const otherProviders = isTable(original.model_providers) ? original.model_providers : {};
+	const expected = {
+		...original,
+		model_provider: codexProviderId,
+		model_catalog_json: input.catalogPath,
+		model,
+		model_providers: {
+			...otherProviders,
+			[codexProviderId]: providerValue(input)
+		}
+	};
+	const actual = parsesTo(result);
+	if (actual === void 0 || !sameToml(actual, expected)) throw new CodexConfigError(`config.toml could not be edited without changing other settings; add the ${codexProviderId} provider by hand, or set codexSetup: false.`);
+	return result;
+};
+const publish = async (snapshot, content, holdsKey) => {
+	const keyExposed = holdsKey && process.platform !== "win32" && snapshot.raw !== null && (snapshot.mode & 63) !== 0;
+	if (snapshot.raw === content && !keyExposed) return false;
+	await writeFileSnapshot(snapshot, content, { ownerOnly: holdsKey });
+	return true;
+};
+/**
+* Sets up Codex for this relay when Codex is installed, that is when $CODEX_HOME exists.
+*
+* Writes the two-model catalog, then config.toml. Neither file is rewritten when it is already
+* current. config.toml is edited from the snapshot it is published against, so an edit saved in
+* between is refused as a conflict rather than lost.
+*/
+const applyCodexSetup = async (input) => {
+	const configPath$1 = path.join(input.codexHome, "config.toml");
+	if (!(await fs.stat(input.codexHome).catch(() => void 0))?.isDirectory()) return {
+		configPath: configPath$1,
+		skipped: true,
+		changed: false
+	};
+	const catalog = buildCodexCatalog(input.models, await readCodexVendorFiles());
+	await fs.mkdir(path.dirname(input.catalogPath), { recursive: true });
+	const catalogChanged = await publish(await readFileSnapshot(input.catalogPath), `${JSON.stringify(catalog, null, 2)}\n`, false);
+	const snapshot = await readFileSnapshot(configPath$1);
+	const configChanged = await publish(snapshot, editCodexConfig(snapshot.raw ?? "", {
+		...input,
+		models: input.models.map((model) => model.id)
+	}), Boolean(input.apiKey));
+	return {
+		configPath: configPath$1,
+		skipped: false,
+		changed: catalogChanged || configChanged
+	};
+};
+
 //#endregion
 //#region src/lib/defaults.ts
 const claudeConfigPath = path.join(os.homedir(), ".claude", "settings.json");
+const getCodexHome = () => process.env.CODEX_HOME || path.join(os.homedir(), ".codex");
 
 //#endregion
 //#region src/lib/preflight.ts
@@ -8853,6 +10347,26 @@ async function startRelay(appConfig) {
 	} catch (error) {
 		log.error(`Could not update claude settings (${claudeConfigPath$1}):`, error);
 	}
+	if (appConfig.codexSetup) {
+		const codexHome = getCodexHome();
+		try {
+			const codexResult = await applyCodexSetup({
+				apiKey: appConfig.apiKey,
+				baseUrl,
+				catalogPath: paths.codexCatalogPath,
+				codexHome,
+				models: [appConfig.gptModel, appConfig.opusModel].map((id) => ({
+					id,
+					capabilities: getCachedCopilotModel(config, id)
+				}))
+			});
+			if (codexResult.skipped) log.info(`codex setup skipped: ${codexHome} does not exist`);
+			else if (codexResult.changed) log.info(`codex settings updated: ${codexResult.configPath}`);
+			else log.info(`codex settings already up to date: ${codexResult.configPath}`);
+		} catch (error) {
+			log.error(`Could not update codex settings (${codexHome}):`, error);
+		}
+	}
 	const configWatcher = watchAppConfig((nextConfig) => {
 		const previousApiKey = config.apiKey;
 		applyRuntimeConfig(nextConfig);
@@ -9001,14 +10515,15 @@ const configRowOrder = {
 	copilotBaseUrl: 3,
 	upstreamProxy: 4,
 	claudeSetup: 5,
-	logLevel: 6,
-	logRetentionDays: 7,
-	thinkEffort: 8,
-	upstreamTimeoutSeconds: 9,
-	webSearchBackend: 10,
-	gptModel: 11,
-	opusModel: 12,
-	claudeUpstreamApi: 13
+	codexSetup: 6,
+	logLevel: 7,
+	logRetentionDays: 8,
+	thinkEffort: 9,
+	upstreamTimeoutSeconds: 10,
+	webSearchBackend: 11,
+	gptModel: 12,
+	opusModel: 13,
+	claudeUpstreamApi: 14
 };
 const configRowKeys = Object.keys(configRowOrder).sort((a, b) => configRowOrder[a] - configRowOrder[b]);
 const unsetConfigText = {
@@ -9021,7 +10536,7 @@ const unsetConfigText = {
 *
 * These are the values on disk. That is not the same question as "what is the
 * running daemon honouring", and the footnote says so rather than leaving it
-* implied: applyRuntimeConfig() in start.ts never reads claudeSetup, and
+* implied: applyRuntimeConfig() in start.ts never reads claudeSetup or codexSetup, and
 * deliberately neither rebinds the listening socket when host or port changes
 * nor rebuilds the upstream dispatcher when upstreamProxy changes; it
 * hot-reloads the rest. Printing every key without that line would imply a
@@ -9036,7 +10551,7 @@ const renderConfig = (config, running) => {
 		const rendered = (value === null || value === "" ? unsetConfigText[key] : void 0) ?? String(value);
 		return `    ${key.padEnd(24)}${sanitizeTerminalString(rendered)}`;
 	});
-	if (running) lines.push("    host, port, claudeSetup and upstreamProxy take effect on restart; the rest hot-reload.");
+	if (running) lines.push("    host, port, claudeSetup, codexSetup and upstreamProxy take effect on restart; the rest hot-reload.");
 	return lines;
 };
 /**
@@ -9514,7 +11029,7 @@ const usage = defineCommand({
 await runMain(defineCommand({
 	meta: {
 		name: "copilot-relay",
-		description: "Yet, just another relay for Claude Code to use a GitHub Copilot subscription."
+		description: "Yet, just another relay for Claude Code and Codex to use a GitHub Copilot subscription."
 	},
 	subCommands: {
 		auth,