copilot-relay 0.4.7 → 0.5.0

package/dist/main.js

@@ -49,6 +49,24 @@ var PromptTooLongError = class extends HTTPError {
 	}
 };
 
+//#endregion
+//#region src/lib/file-identity.ts
+/** True when two stats of a path name the same file: the same device and file index. */
+const sameFile$1 = (left, right) => left.dev === right.dev && left.ino === right.ino;
+/**
+* True when a stat of an open handle and a stat of its path name the same file.
+*
+* On Windows the two can disagree on `dev` for the same file: on Node 22.13.1 a path stat
+* reports `dev` 0 while a handle stat reports the volume serial number. There a `dev` of 0 on
+* either side counts as unreported and the file index (`ino`) alone decides, which is weaker
+* evidence than both. Two nonzero `dev` values must still match, and other platforms compare both.
+*/
+const sameOpenedFile = (left, right, platform = process.platform) => {
+	if (left.ino !== right.ino) return false;
+	if (platform === "win32" && (left.dev === 0 || right.dev === 0)) return true;
+	return left.dev === right.dev;
+};
+
 //#endregion
 //#region src/lib/paths.ts
 const homeDir = os.homedir();
@@ -371,7 +389,6 @@ const formatLogValue = (value) => typeof value === "string" ? value : inspect(va
 });
 const escapeLogLineSeparators = (value) => value.replaceAll("\r", "\\r").replaceAll("\n", "\\n").replaceAll(String.fromCodePoint(8232), "\\u2028").replaceAll(String.fromCodePoint(8233), "\\u2029");
 const isMissing$2 = (error) => error.code === "ENOENT";
-const sameFile$2 = (left, right) => left.dev === right.dev && left.ino === right.ino;
 const ensurePrivateDirectory = async (directory) => {
 	await fs.mkdir(directory, { mode: 448 }).catch((error) => {
 		if (error.code !== "EEXIST") throw error;
@@ -382,7 +399,7 @@ const ensurePrivateDirectory = async (directory) => {
 	const handle = await fs.open(directory, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
 	try {
 		const opened = await handle.stat();
-		if (!opened.isDirectory() || !sameFile$2(observed, opened)) throw new Error("Log directory changed while opening");
+		if (!opened.isDirectory() || !sameOpenedFile(observed, opened)) throw new Error("Log directory changed while opening");
 		await handle.chmod(448);
 	} finally {
 		await handle.close();
@@ -401,10 +418,10 @@ let activeLog;
 let logIdleClose;
 const maxLogWriteBytes = 256 * 1024;
 const hasMode = (stats, mode) => process.platform === "win32" || (stats.mode & 511) === mode;
-const isSameDirectory = (current, checked) => current !== void 0 && current.isDirectory() && sameFile$2(current, checked) && hasMode(current, 448);
+const isSameDirectory = (current, checked) => current !== void 0 && current.isDirectory() && sameFile$1(current, checked) && hasMode(current, 448);
 const isStillActive = async (active) => {
 	const [current, ...directories] = await Promise.all([active.filePath, ...logDirectories].map((target) => fs.lstat(target).catch(() => void 0)));
-	return current !== void 0 && current.isFile() && current.nlink === 1 && sameFile$2(current, active.identity) && hasMode(current, 384) && active.directories.every((checked, index) => isSameDirectory(directories[index], checked));
+	return current !== void 0 && current.isFile() && current.nlink === 1 && sameOpenedFile(current, active.identity) && hasMode(current, 384) && active.directories.every((checked, index) => isSameDirectory(directories[index], checked));
 };
 const openPrivateLog = async (filePath, directories) => {
 	const observed = await fs.lstat(filePath).catch((error) => {
@@ -416,7 +433,7 @@ const openPrivateLog = async (filePath, directories) => {
 	try {
 		const opened = await handle.stat();
 		const current = await fs.lstat(filePath);
-		if (!opened.isFile() || opened.nlink !== 1 || current.isSymbolicLink() || !sameFile$2(opened, current) || observed && !sameFile$2(observed, opened)) throw new Error("Log file changed while opening");
+		if (!opened.isFile() || opened.nlink !== 1 || current.isSymbolicLink() || !sameOpenedFile(opened, current) || observed && !sameOpenedFile(observed, opened)) throw new Error("Log file changed while opening");
 		if (process.platform !== "win32") await handle.chmod(384);
 		return {
 			filePath,
@@ -2296,7 +2313,6 @@ const markDiscardedResponse = (response) => {
 };
 const credentialPattern = /(?:gh[pousr]_|github_pat_|sk-|eyJ)[A-Za-z0-9_-]+/;
 const uuidPattern = /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/;
-const sameFile$1 = (left, right) => left.dev === right.dev && left.ino === right.ino;
 const noFollow = process.platform === "win32" ? 0 : fs.constants.O_NOFOLLOW;
 const safeValue = (value) => typeof value === "string" && /^[A-Za-z0-9_.:/[\]-]{1,160}$/.test(value) && !/(?:gh[pousr]_|github_pat_|sk-|eyJ)[A-Za-z0-9_-]+/.test(value) ? value : void 0;
 const errorName = (error) => error instanceof Error && [
@@ -2444,7 +2460,7 @@ const privateDirectory = async (directory) => {
 	const handle = await fs.open(directory, fs.constants.O_RDONLY | noFollow);
 	try {
 		const opened = await handle.stat();
-		if (!opened.isDirectory() || !sameFile$1(observed, opened)) throw new Error("Capture directory changed.");
+		if (!opened.isDirectory() || !sameOpenedFile(observed, opened)) throw new Error("Capture directory changed.");
 		await handle.chmod(448);
 		return opened;
 	} finally {
@@ -2456,7 +2472,7 @@ const createPrivateFile = async (file) => {
 	try {
 		const opened = await handle.stat();
 		const current = await fs.lstat(file);
-		if (!opened.isFile() || opened.nlink !== 1 || current.isSymbolicLink() || !sameFile$1(opened, current)) throw new Error("Unsafe capture file.");
+		if (!opened.isFile() || opened.nlink !== 1 || current.isSymbolicLink() || !sameOpenedFile(opened, current)) throw new Error("Unsafe capture file.");
 		return handle;
 	} catch (error) {
 		await handle.close();
@@ -2914,7 +2930,7 @@ var RequestTrace = class RequestTrace {
 			}
 			const opened = await handle.stat();
 			const current = await fs.lstat(file);
-			if (!current.isFile() || current.isSymbolicLink() || opened.nlink !== 1 || !sameFile$1(opened, current)) throw new Error("Capture file changed.");
+			if (!current.isFile() || current.isSymbolicLink() || opened.nlink !== 1 || !sameOpenedFile(opened, current)) throw new Error("Capture file changed.");
 			await handle.writeFile(buffer);
 		}).catch(() => {
 			this.manifest.captureError = "capture_write_failed";
@@ -2967,7 +2983,7 @@ var RequestTrace = class RequestTrace {
 				await this.checkDirectories();
 				const manifest = path.join(this.captureDirectory, "meta.json");
 				const current = await fs.lstat(manifest);
-				if (!current.isFile() || current.isSymbolicLink() || current.nlink !== 1 || !this.metadataStat || !sameFile$1(current, this.metadataStat) || current.size !== this.metadataStat.size || current.mtimeMs !== this.metadataStat.mtimeMs || current.ctimeMs !== this.metadataStat.ctimeMs) throw new Error("Unsafe capture metadata.");
+				if (!current.isFile() || current.isSymbolicLink() || current.nlink !== 1 || !this.metadataStat || !sameOpenedFile(current, this.metadataStat) || current.size !== this.metadataStat.size || current.mtimeMs !== this.metadataStat.mtimeMs || current.ctimeMs !== this.metadataStat.ctimeMs) throw new Error("Unsafe capture metadata.");
 				await fs.rename(path.join(this.captureDirectory, "meta.next.json"), manifest);
 			}
 		}).catch(() => {
@@ -3005,7 +3021,7 @@ const readRetentionManifest = async (file) => {
 	const handle = await fs.open(file, fs.constants.O_RDONLY | noFollow);
 	try {
 		const opened = await handle.stat();
-		if (!sameFile$1(observed, opened) || opened.nlink !== 1 || opened.size !== observed.size) throw new Error("Capture metadata changed.");
+		if (!sameOpenedFile(observed, opened) || opened.nlink !== 1 || opened.size !== observed.size) throw new Error("Capture metadata changed.");
 		const bytes = Buffer.alloc(opened.size);
 		let offset = 0;
 		while (offset < bytes.length) {
@@ -3014,7 +3030,7 @@ const readRetentionManifest = async (file) => {
 			offset += bytesRead;
 		}
 		const current = await fs.lstat(file);
-		if (!sameFile$1(opened, current) || current.size !== opened.size || current.mtimeMs !== opened.mtimeMs) throw new Error("Capture metadata changed.");
+		if (!sameOpenedFile(opened, current) || current.size !== opened.size || current.mtimeMs !== opened.mtimeMs) throw new Error("Capture metadata changed.");
 		return JSON.parse(bytes.toString("utf8"));
 	} finally {
 		await handle.close();
@@ -3327,10 +3343,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$6 = (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$6(value)) return;
 	const context = value.max_context_window_tokens;
 	const prompt = value.max_prompt_tokens;
 	const output = value.max_output_tokens;
@@ -3386,13 +3402,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$6(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$6(model) || typeof model.id !== "string" || !model.id) continue;
+			const capabilities = isRecord$6(model.capabilities) ? model.capabilities : void 0;
 			const limits = parseModelTokenLimits(capabilities?.limits);
-			const supports = isRecord$5(capabilities?.supports) ? capabilities.supports : void 0;
+			const supports = isRecord$6(capabilities?.supports) ? capabilities.supports : void 0;
 			const supportedEndpoints = parseStringArray(model.supported_endpoints);
 			const reasoningEfforts = parseReasoningEfforts(supports);
 			models$1.set(model.id, {
@@ -3737,7 +3753,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$5 = (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;
@@ -3755,14 +3771,14 @@ const contentBlocks = (content) => {
 		type: "text",
 		text: content
 	}];
-	return Array.isArray(content) ? content.filter(isRecord$4) : [];
+	return Array.isArray(content) ? content.filter(isRecord$5) : [];
 };
 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$5(message) || message.role === "system") continue;
 		if (message.role !== "user") break;
 		sawUser = true;
 		blocks.unshift(...contentBlocks(message.content));
@@ -3782,11 +3798,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$5(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 getClaudeRequestInitiator = (body) => {
-	if (!isRecord$4(body) || !Array.isArray(body.messages) || isStatusProbe(body)) return "agent";
+	if (!isRecord$5(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";
@@ -4390,7 +4406,7 @@ const webSearchInputSchema = {
 	required: ["query"],
 	additionalProperties: false
 };
-const isRecord$3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const isRecord$4 = (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);
@@ -4430,7 +4446,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$4(parsed) && typeof parsed.query === "string" && parsed.query.trim()) return parsed.query.trim();
 	} catch {
 		return trimmed;
 	}
@@ -4487,7 +4503,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$4(item.action) ? item.action : void 0;
 		const query = getReportedQuery(action, Array.isArray(action?.queries) ? action.queries : []);
 		if (query) return query;
 	}
@@ -4495,7 +4511,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$4(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;
@@ -4519,15 +4535,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$4(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$4(part) && Array.isArray(part.annotations)) sources.push(...part.annotations.filter((annotation) => isRecord$4(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$4(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;
@@ -4579,21 +4595,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$4(raw) || raw.output !== void 0 && (!Array.isArray(raw.output) || !raw.output.every(isRecord$4));
+	const upstream = isRecord$4(raw) ? {
 		...raw,
-		output: Array.isArray(raw.output) ? raw.output.filter(isRecord$3) : []
+		output: Array.isArray(raw.output) ? raw.output.filter(isRecord$4) : []
 	} : {};
 	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$4(upstream.incomplete_details) ? upstream.incomplete_details.reason : void 0, incompleteReasons);
 	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$4(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$4(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$4(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);
@@ -4681,7 +4697,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$4(parsed) && isRecord$4(parsed.error) ? parsed.error : void 0);
 	} catch {
 		if (/^[{[<]/.test(detail)) return "";
 	}
@@ -5253,7 +5269,7 @@ const lookaroundPrefixes = [
 	"(?<=",
 	"(?<!"
 ];
-const isRecord$2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const isRecord$3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 function hasUnsupportedPatternFeatures(pattern) {
 	let inCharacterClass = false;
 	for (let index = 0; index < pattern.length; index++) {
@@ -5299,12 +5315,12 @@ function mapArray(values) {
 }
 function normalizeSchemaValue(value) {
 	if (Array.isArray(value)) return mapArray(value);
-	return isRecord$2(value) ? normalizeResponsesToolSchema(value) : value;
+	return isRecord$3(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$3(value)) return mapRecord(value, (_name, nested) => normalizeSchemaValue(nested));
 		if (nestedSchemaKeywords.has(key)) return normalizeSchemaValue(value);
 		return value;
 	});
@@ -6881,6 +6897,320 @@ claudeRoutes.post("/messages/count_tokens", async (c) => {
 	}
 });
 
+//#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$2 = (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$2(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.
+*
+* A model Copilot's catalog lists is used as named, so Codex's own model IDs reach the same
+* Copilot model. 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 the name is
+* forwarded unchanged. Claude models are refused: Copilot serves them only on Messages and Chat
+* Completions.
+*/
+const resolveCodexModel = async (config, requested) => {
+	if (isClaudeModelId(requested)) throw codexRequestError(`${requested} is not available through the Responses API: Copilot serves Claude models only on Messages and Chat Completions. Choose a GPT model.`, "relay_unsupported_model");
+	const normalized = normalizeCopilotModelId(requested);
+	await ensureCopilotModelCatalog(config, normalized);
+	pinCopilotModelCatalog(config);
+	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;
+};
+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; those are the only changes. Every other field, including Codex's
+* prompt_cache_key and its 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.tools)) {
+		const tools = prepared.tools.filter((tool) => !(isRecord$2(tool) && tool.type === "image_generation"));
+		if (tools.length !== prepared.tools.length) {
+			prepared.tools = tools;
+			removed$1.push("image_generation");
+		}
+	}
+	const reasoning = isRecord$2(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$2(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$2(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/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";
+};
+/**
+* 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 = (body, trace) => {
+	const reader = body.getReader();
+	let settled = false;
+	const settle = (error) => {
+		if (settled) return;
+		settled = true;
+		trace?.handlerSettled(error);
+	};
+	return new ReadableStream({
+		pull: async (controller) => {
+			try {
+				const next = await reader.read();
+				if (settled) return;
+				if (next.done) {
+					controller.close();
+					settle();
+					return;
+				}
+				controller.enqueue(next.value);
+			} catch (error) {
+				if (!settled) controller.error(error);
+				settle(error);
+			}
+		},
+		cancel: async (reason) => {
+			settle();
+			await reader.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 model = await resolveCodexModel(config, payload.model);
+		const prepared = prepareCodexPayload(payload, model, getCachedCopilotModel(config, model));
+		const subagent = readSubagent(c.req.header("x-openai-subagent"));
+		const initiator = getCodexInitiator(payload.input, subagent);
+		log.info(sanitizeTerminalString([
+			`request_id=${requestId}`,
+			"Model request client=codex",
+			`requested_model=${payload.model}`,
+			`upstream_model=${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: {
+						"content-type": "text/event-stream",
+						"cache-control": "no-cache"
+					}
+				});
+			}
+			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;
+		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, trace), {
+		status: response.status,
+		headers
+	});
+});
+
 //#endregion
 //#region src/server.ts
 const loggedRequestHeaders = [
@@ -6935,6 +7265,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();
@@ -6991,7 +7326,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);
@@ -7035,6 +7370,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);
@@ -7741,7 +8077,7 @@ const readCaptureFile = async (directory, file, maximum, optional = false) => {
 	const handle = await fs.open(filePath, fs.constants.O_RDONLY | (process.platform === "win32" ? 0 : fs.constants.O_NOFOLLOW));
 	try {
 		const opened = await handle.stat();
-		requireValid(opened.isFile() && opened.ino === before.ino && opened.dev === before.dev && opened.size === before.size);
+		requireValid(opened.isFile() && sameOpenedFile(opened, before) && opened.size === before.size);
 		const bytes = Buffer.alloc(opened.size);
 		let offset = 0;
 		while (offset < bytes.length) {
@@ -7750,7 +8086,7 @@ const readCaptureFile = async (directory, file, maximum, optional = false) => {
 			offset += read.bytesRead;
 		}
 		const after = await fs.lstat(filePath);
-		requireValid(!after.isSymbolicLink() && after.ino === opened.ino && after.dev === opened.dev && after.size === opened.size && after.mtimeMs === opened.mtimeMs);
+		requireValid(!after.isSymbolicLink() && sameOpenedFile(after, opened) && after.size === opened.size && after.mtimeMs === opened.mtimeMs);
 		return bytes;
 	} finally {
 		await handle.close();
@@ -9498,7 +9834,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,