copilot-relay 0.4.8 → 0.5.0

package/README.md

@@ -1,15 +1,16 @@
 # copilot-relay
 
-**Use Claude Code with the models available through your GitHub Copilot subscription.**
+**Use Claude Code and Codex with the models available through your GitHub Copilot subscription.**
 
-[![CI](https://github.com/D0n9X1n/copilot-relay/actions/workflows/ci.yml/badge.svg)](https://github.com/D0n9X1n/copilot-relay/actions/workflows/ci.yml)
-[![npm version](https://img.shields.io/npm/v/copilot-relay.svg?logo=npm)](https://www.npmjs.com/package/copilot-relay)
-[![Node.js](https://img.shields.io/badge/node-%3E%3D22-339933?logo=node.js&logoColor=white)](https://nodejs.org/)
-[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+[![CI](https://img.shields.io/github/actions/workflow/status/D0n9X1n/copilot-relay/ci.yml?branch=main&logo=githubactions&logoColor=white&label=CI)](https://github.com/D0n9X1n/copilot-relay/actions/workflows/ci.yml) [![npm version](https://img.shields.io/npm/v/copilot-relay?logo=npm)](https://www.npmjs.com/package/copilot-relay) [![npm downloads](https://img.shields.io/npm/dm/copilot-relay?logo=npm&label=downloads)](https://www.npmjs.com/package/copilot-relay) [![GitHub release](https://img.shields.io/github/v/release/D0n9X1n/copilot-relay?logo=github)](https://github.com/D0n9X1n/copilot-relay/releases/latest)
+[![Node.js](https://img.shields.io/badge/node-%3E%3D22-339933?logo=node.js&logoColor=white)](https://nodejs.org/) [![TypeScript](https://img.shields.io/badge/TypeScript-strict-3178C6?logo=typescript&logoColor=white)](tsconfig.json) [![Platforms](https://img.shields.io/badge/platform-macOS%20%7C%20Windows%20%7C%20Linux-lightgrey)](wiki/README.md) [![License: MIT](https://img.shields.io/github/license/D0n9X1n/copilot-relay?color=blue)](LICENSE)
 
 ## Features
 
+[![Watch a one-minute video tour of copilot-relay](https://gitdiagram.com/video-badge.svg)](https://gitdiagram.com/d0n9x1n/copilot-relay/video)
+
 - **Claude Code, familiar workflow** — Messages API compatibility, streaming responses, and tool calls.
+- **Codex CLI and the Codex app** — an OpenAI Responses passthrough for Copilot's GPT models; [set it up](wiki/EN-Codex.md) · [中文](wiki/ZH-Codex.md).
 - **WebSearch that fits the conversation** — relay-managed search, followed by an answer that can still use your tools.
 - **Your models, your settings** — configurable GPT/Opus routes and reasoning effort; existing selections survive upgrades.
 - **Use the advertised capacity** — discovered context/output limits, without silently shortening your input.
@@ -74,6 +75,5 @@ scripts. It asks GitHub with the stored token, so no relay needs to run.
 - Run at login: [macOS](wiki/EN-macOS-LaunchAgent.md) · [Windows](wiki/EN-Windows-Service.md) · [Linux](wiki/EN-Linux-systemd.md)
 - [Commands](wiki/EN-Commands.md) · [Prompt caching](wiki/EN-Prompt-Caching.md) · [Troubleshoot](wiki/EN-Logging-Troubleshooting.md) · [Understand the architecture](wiki/EN-Architecture.md) · [Contribute](wiki/EN-Development.md)
 
-Unofficial research project; not affiliated with GitHub or Anthropic. Upstream
-services and compatibility can change. Model and tool support are not guaranteed;
-see the Wiki for known limitations. [MIT licensed](LICENSE).
+Unofficial research project; not affiliated with GitHub, Anthropic or OpenAI. Upstream services and
+compatibility can change; model and tool support are not guaranteed (see the Wiki). [MIT licensed](LICENSE).

package/dist/main.js

@@ -3343,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;
@@ -3402,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, {
@@ -3753,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;
@@ -3771,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));
@@ -3798,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";
@@ -4406,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);
@@ -4446,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;
 	}
@@ -4503,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;
 	}
@@ -4511,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;
@@ -4535,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;
@@ -4595,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);
@@ -4697,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 "";
 	}
@@ -5269,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++) {
@@ -5315,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;
 	});
@@ -6897,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 = [
@@ -6951,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();
@@ -7007,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);
@@ -7051,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);
@@ -9514,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,