ghc-proxy 0.8.0 → 0.9.0

package/dist/main.mjs

@@ -5739,7 +5739,8 @@ const reasoningEffortSchema = _enum([
 	"low",
 	"medium",
 	"high",
-	"xhigh"
+	"xhigh",
+	"max"
 ]);
 const configFileSchema = object({
 	githubToken: string().optional(),
@@ -5759,6 +5760,7 @@ const configFileSchema = object({
 		params: array(string()).min(1)
 	})).optional(),
 	responsesApiParameterFiltersReplaceDefault: boolean().optional(),
+	chatCompletionsUseMaxCompletionTokens: array(string()).optional(),
 	responsesOfficialEmulator: boolean().optional(),
 	responsesOfficialEmulatorTtlSeconds: number().int().positive().optional(),
 	modelReasoningEfforts: record(string(), reasoningEffortSchema).optional(),
@@ -5885,6 +5887,14 @@ var ConfigStore = class {
 	getModelRewrites() {
 		return getCachedConfig().modelRewrites ?? [];
 	}
+	/**
+	* Extra model globs whose `/chat/completions` requests must send
+	* `max_completion_tokens` instead of `max_tokens`. Adds to the built-in
+	* evidence-backed list rather than replacing it.
+	*/
+	getChatCompletionsMaxCompletionTokensModels() {
+		return getCachedConfig().chatCompletionsUseMaxCompletionTokens ?? [];
+	}
 	getModelFallback() {
 		return getCachedConfig().modelFallback;
 	}
@@ -5897,14 +5907,30 @@ const RESPONSES_ENDPOINT = "/responses";
 * Models whose upstream `/v1/messages` endpoint rejects the `output_config`
 * field with "Extra inputs are not permitted".
 *
-* Verified via `scripts/probes/messages/output-config.ts` (2026-03-14).
+* Verified via `scripts/probes/messages/output-config.ts` (2026-03-14); the
+* probe enumerates the live `/models` surface, so this list only ever covers
+* models that existed on the probe date. `claude-sonnet-4` was dropped
+* 2026-07-26 after leaving that surface.
 * When new models appear, re-run the probe and update this list.
 */
-const MODELS_REJECTING_OUTPUT_CONFIG = new Set([
-	"claude-sonnet-4",
-	"claude-sonnet-4.5",
-	"claude-haiku-4.5"
-]);
+const MODELS_REJECTING_OUTPUT_CONFIG = new Set(["claude-sonnet-4.5", "claude-haiku-4.5"]);
+/**
+* Models that advertise `structured_outputs` but cannot serve it on native
+* `/v1/messages`, because a Google Cloud organization policy blocks the feature
+* for the Vertex-served deployment:
+*
+*   Organization Policy constraint constraints/vertexai.allowedPartnerModelFeatures
+*   violated for `projects/<id>` attempting to use a disallowed feature
+*   structured_outputs for Partner model claude-opus-4-7
+*
+* Probed 2026-07-26 (`scripts/probes/messages/output-format.ts`). This is an
+* account-scoped policy rather than a protocol limit — it names a specific GCP
+* project, so another Copilot subscriber may see different results, and the
+* policy can be changed without notice. It is therefore an explicit ID list
+* bounded in time, not a rule derived from the payload shape: re-run the probe
+* when models change, and delete entries that start passing.
+*/
+const MODELS_BLOCKING_NATIVE_STRUCTURED_OUTPUT = new Set(["claude-opus-4.7", "claude-sonnet-4.6"]);
 var ModelCache = class {
 	models;
 	vsCodeVersion;
@@ -5951,6 +5977,10 @@ var ModelCache = class {
 		if (!model) return true;
 		return !MODELS_REJECTING_OUTPUT_CONFIG.has(model.id);
 	}
+	supportsStructuredOutputs(model) {
+		if (!model || MODELS_BLOCKING_NATIVE_STRUCTURED_OUTPUT.has(model.id)) return false;
+		return model.capabilities.supports.structured_outputs ?? false;
+	}
 };
 const modelCache = new ModelCache();
 //#endregion
@@ -5980,7 +6010,46 @@ var HTTPError = class extends Error {
 		return Response.json(this.body, { status: this.status });
 	}
 };
+const TRANSIENT_UPSTREAM_STATUSES = new Set([
+	408,
+	429,
+	500,
+	502,
+	503,
+	504,
+	529
+]);
+/**
+* Upstream statuses worth retrying: request-scoped faults (timeouts, gateway
+* errors) plus capacity limits. Shared by `UpstreamRequestQueue` and the
+* Copilot token refresh so both agree on what "transient" means.
+*/
+function isTransientUpstreamStatus(status) {
+	return TRANSIENT_UPSTREAM_STATUSES.has(status);
+}
+/**
+* Capacity signals that apply to the whole account or service rather than one
+* request. Only these warrant global back-pressure — applying a queue-wide
+* cooldown to a request-scoped 5xx turns one bad request into a proxy stall.
+*/
+function isCapacityLimitStatus(status) {
+	return status === 429 || status === 529;
+}
+/**
+* Reject a request locally with a 400.
+*
+* Logs on the way out. `onError` in `src/server.ts` returns early for
+* `code === 'HTTP'` (HTTPError carries its own `toResponse`), so nothing
+* downstream reports these — without this line a locally rejected request is
+* indistinguishable in the logs from one that reached upstream and came back
+* fine, leaving only the access-log status to go on.
+*/
 function throwInvalidRequestError(message, param, code) {
+	consola.warn("Rejected request", {
+		param,
+		code,
+		message
+	});
 	throw new HTTPError(400, { error: {
 		message,
 		type: "invalid_request_error",
@@ -5989,9 +6058,15 @@ function throwInvalidRequestError(message, param, code) {
 	} });
 }
 function fromTranslationFailure(failure) {
+	consola.warn("Translation failed", {
+		kind: failure.kind,
+		status: failure.status,
+		message: failure.message
+	});
 	return new HTTPError(failure.status, { error: {
 		message: failure.message,
-		type: "translation_error"
+		type: "translation_error",
+		...failure.kind ? { code: failure.kind } : {}
 	} });
 }
 function resolveModelOrThrow(modelId) {
@@ -6014,7 +6089,9 @@ function isStructuredErrorPayload(value) {
 	return typeof value === "object" && value !== null && "error" in value && typeof value.error === "object" && value.error !== null;
 }
 function upstreamErrorType(status) {
-	return status === 429 ? "rate_limit_error" : "upstream_error";
+	if (status === 429) return "rate_limit_error";
+	if (status === 529) return "overloaded_error";
+	return "upstream_error";
 }
 function createFallbackUpstreamError(message, response, rawText) {
 	return { error: {
@@ -6125,7 +6202,6 @@ function createResponsesEmulatorState(opts) {
 	const conversationHeadRecords = /* @__PURE__ */ new Map();
 	const inputItemRecords = /* @__PURE__ */ new Map();
 	const responseDeletionFlags = /* @__PURE__ */ new Map();
-	const conversationDeletionFlags = /* @__PURE__ */ new Map();
 	const inputItemDeletionFlags = /* @__PURE__ */ new Map();
 	const allMaps = [
 		responseRecords,
@@ -6133,7 +6209,6 @@ function createResponsesEmulatorState(opts) {
 		conversationHeadRecords,
 		inputItemRecords,
 		responseDeletionFlags,
-		conversationDeletionFlags,
 		inputItemDeletionFlags
 	];
 	let pruneIntervalId;
@@ -6201,7 +6276,6 @@ function createResponsesEmulatorState(opts) {
 	function deletionMap(kind) {
 		switch (kind) {
 			case "response": return responseDeletionFlags;
-			case "conversation": return conversationDeletionFlags;
 			case "input_items": return inputItemDeletionFlags;
 		}
 	}
@@ -6211,7 +6285,6 @@ function createResponsesEmulatorState(opts) {
 		pruneMap(conversationHeadRecords, at);
 		pruneMap(inputItemRecords, at);
 		pruneMap(responseDeletionFlags, at);
-		pruneMap(conversationDeletionFlags, at);
 		pruneMap(inputItemDeletionFlags, at);
 	}
 	function evictOldestFromLargestMap() {
@@ -6240,19 +6313,12 @@ function createResponsesEmulatorState(opts) {
 		}
 	}
 	return {
-		isEnabled() {
-			return configStore.isEmulatorEnabled();
-		},
-		getDefaultTtlSeconds() {
-			return configStore.getEmulatorTtlSeconds();
-		},
 		clear() {
 			responseRecords.clear();
 			conversationRecords.clear();
 			conversationHeadRecords.clear();
 			inputItemRecords.clear();
 			responseDeletionFlags.clear();
-			conversationDeletionFlags.clear();
 			inputItemDeletionFlags.clear();
 			stopBackgroundPrune();
 		},
@@ -6267,7 +6333,7 @@ function createResponsesEmulatorState(opts) {
 				conversations: conversationRecords.size,
 				conversationHeads: conversationHeadRecords.size,
 				inputItems: inputItemRecords.size,
-				deletions: responseDeletionFlags.size + conversationDeletionFlags.size + inputItemDeletionFlags.size
+				deletions: responseDeletionFlags.size + inputItemDeletionFlags.size
 			};
 		},
 		setResponse(response, options) {
@@ -6276,7 +6342,6 @@ function createResponsesEmulatorState(opts) {
 				const conversationId = responseKeyFromConversation(response.conversation);
 				writeMap(conversationRecords, conversationId, response.conversation, options?.ttlSeconds);
 				writeMap(conversationHeadRecords, conversationId, response.id, options?.ttlSeconds);
-				removeDeletionFlag(conversationDeletionFlags, conversationId);
 			}
 			return writeMap(responseRecords, response.id, response, options?.ttlSeconds);
 		},
@@ -6302,25 +6367,11 @@ function createResponsesEmulatorState(opts) {
 			};
 		},
 		setConversation(conversation, options) {
-			const conversationId = responseKeyFromConversation(conversation);
-			removeDeletionFlag(conversationDeletionFlags, conversationId);
-			return writeMap(conversationRecords, conversationId, conversation, options?.ttlSeconds);
+			return writeMap(conversationRecords, responseKeyFromConversation(conversation), conversation, options?.ttlSeconds);
 		},
 		getConversation(conversationId) {
-			if (readDeletionFlag(conversationDeletionFlags, conversationId)) return;
 			return readMap(conversationRecords, conversationId);
 		},
-		deleteConversation(conversationId, options) {
-			pruneExpiredRecords();
-			deleteMapEntry(conversationRecords, conversationId);
-			deleteMapEntry(conversationHeadRecords, conversationId);
-			putDeletionFlag(conversationDeletionFlags, conversationId, options?.ttlSeconds);
-			return {
-				id: conversationId,
-				object: "conversation.deleted",
-				deleted: true
-			};
-		},
 		setConversationHead(conversationId, responseId, options) {
 			return writeMap(conversationHeadRecords, conversationId, responseId, options?.ttlSeconds);
 		},
@@ -6335,16 +6386,6 @@ function createResponsesEmulatorState(opts) {
 			if (readDeletionFlag(inputItemDeletionFlags, responseId)) return;
 			return readMap(inputItemRecords, responseId);
 		},
-		deleteInputItems(responseId, options) {
-			pruneExpiredRecords();
-			deleteMapEntry(inputItemRecords, responseId);
-			putDeletionFlag(inputItemDeletionFlags, responseId, options?.ttlSeconds);
-			return {
-				id: responseId,
-				object: "response.input_items.deleted",
-				deleted: true
-			};
-		},
 		getDeletionFlag(kind, id) {
 			return readDeletionFlag(deletionMap(kind), id);
 		}
@@ -6592,7 +6633,7 @@ var CopilotClient = class {
 		const { response, release } = await this.request(path, errorMessage, {
 			method: "POST",
 			body: JSON.stringify(payload),
-			retryable: true,
+			retryable: "capacity",
 			...options
 		});
 		if (payload.stream) return withRelease(events(response), release);
@@ -6626,10 +6667,11 @@ var CopilotClient = class {
 			}
 		});
 	}
-	async createEmbeddings(payload) {
+	async createEmbeddings(payload, options) {
 		return this.requestJson("/embeddings", "Failed to create embeddings", {
 			method: "POST",
 			body: JSON.stringify(payload),
+			signal: options?.signal,
 			retryable: true
 		});
 	}
@@ -6890,6 +6932,27 @@ function normalizeGheDomain(input) {
 	return domain;
 }
 /**
+* Resolve the effective GHE domain onto `authStore` and promote the account
+* type when one is in play.
+*
+* Every entry point (`start`, `auth`, `check-usage`) needs both halves: the
+* domain selects the GitHub URLs, while `accountType` selects the Copilot base
+* URL in `copilotBaseUrl()`. Applying only the first sends GHE users to the
+* public Copilot endpoint, so the two are resolved together here rather than
+* re-derived per command.
+*
+* @param auth Mutated in place — receives the resolved domain and, when a
+* domain is in play, an account type promoted from `individual`.
+* @param configuredDomain Persisted `gheDomain` from config.json.
+* @param overrideDomain CLI argument. `undefined` leaves the persisted value
+* alone; an empty string explicitly clears it.
+*/
+function applyGheDomain(auth, configuredDomain, overrideDomain) {
+	auth.gheDomain = configuredDomain;
+	if (overrideDomain !== void 0) auth.gheDomain = overrideDomain ? normalizeGheDomain(overrideDomain) : void 0;
+	if (auth.gheDomain && auth.accountType === "individual") auth.accountType = "enterprise";
+}
+/**
 * Build GitHub base URL and API base URL for a given GHE domain,
 * or return the public GitHub defaults when no domain is provided.
 */
@@ -6957,8 +7020,10 @@ var UpstreamRequestQueue = class {
 				lease.release();
 				throw error;
 			}
-			if (response.status !== 429 || !context.retryable || attempt >= this.options.maxRetries) {
-				if (response.status === 429 && !context.retryable) this.applyCooldown(this.getRetryDelayMs(response, 0));
+			const { status } = response;
+			const isCapacityLimit = isCapacityLimitStatus(status);
+			if (!((context.retryable === "capacity" ? isCapacityLimit : context.retryable === true && isTransientUpstreamStatus(status)) && attempt < this.options.maxRetries)) {
+				if (isCapacityLimit) this.applyCooldown(this.getRetryDelayMs(response, 0));
 				return {
 					response,
 					release: lease.release
@@ -6966,10 +7031,10 @@ var UpstreamRequestQueue = class {
 			}
 			const delayMs = this.getRetryDelayMs(response, attempt);
 			await discardResponse(response);
+			if (isCapacityLimit) this.applyCooldown(delayMs);
 			lease.release();
-			this.applyCooldown(delayMs);
 			this.logger.warn([
-				"Upstream rate limited;",
+				`Upstream ${status};`,
 				`retrying ${formatRequestContext(context)}`,
 				`in ${formatDurationMs(delayMs)}`,
 				`(attempt ${attempt + 1}/${this.options.maxRetries})`
@@ -7244,16 +7309,8 @@ async function setupGitHubToken(options) {
 function isAuthError(error) {
 	return error instanceof HTTPError && (error.status === 401 || error.status === 403);
 }
-const TRANSIENT_HTTP_STATUSES = new Set([
-	408,
-	429,
-	500,
-	502,
-	503,
-	504
-]);
 function isTransientHttpError(error) {
-	return TRANSIENT_HTTP_STATUSES.has(error.status);
+	return isTransientUpstreamStatus(error.status);
 }
 async function logUser() {
 	const user = await createGitHubClient().getGitHubUser();
@@ -7291,9 +7348,7 @@ async function runAuth(options) {
 	authStore.showToken = options.showToken;
 	await ensurePaths();
 	await readConfig();
-	authStore.gheDomain = getCachedConfig().gheDomain;
-	if (options.gheDomain !== void 0) authStore.gheDomain = options.gheDomain ? normalizeGheDomain(options.gheDomain) : void 0;
-	if (authStore.gheDomain && authStore.accountType === "individual") authStore.accountType = "enterprise";
+	applyGheDomain(authStore, getCachedConfig().gheDomain, options.gheDomain);
 	await cacheVSCodeVersion();
 	await setupGitHubToken({ force: true });
 	consola.success("GitHub token written to config.json");
@@ -7339,7 +7394,7 @@ const checkUsage = defineCommand({
 	async run() {
 		await ensurePaths();
 		await readConfig();
-		authStore.gheDomain = getCachedConfig().gheDomain;
+		applyGheDomain(authStore, getCachedConfig().gheDomain);
 		await cacheVSCodeVersion();
 		await setupGitHubToken();
 		try {
@@ -7364,7 +7419,7 @@ const checkUsage = defineCommand({
 });
 //#endregion
 //#region src/util/version.ts
-const VERSION = "0.8.0";
+const VERSION = "0.9.0";
 //#endregion
 //#region src/debug.ts
 function getRuntimeInfo() {
@@ -47896,6 +47951,20 @@ function inferReasoningEffort(budgetTokens) {
 	if (budgetTokens <= 24e3) return "medium";
 	return "high";
 }
+/**
+* The effort to send upstream: the level the caller named, else one inferred
+* from the thinking budget.
+*
+* `output_config.effort` used to be dropped entirely on this path — it is not
+* part of the OpenAI chat schema, so the normalizer never read it — which
+* silently downgraded a caller asking for `max` to whatever the budget
+* heuristic produced (`high` at most). Copilot does accept `reasoning_effort`
+* here: probed 2026-07-26, every reasoning Claude model on `/chat/completions`
+* accepts the levels it advertises, `max` included.
+*/
+function resolveRequestEffort(request, budgetTokens) {
+	return request.outputEffort ?? inferReasoningEffort(budgetTokens);
+}
 function inferModelFamily(model) {
 	if (model.startsWith("claude")) return "claude";
 	if (model.startsWith("gpt") || model.startsWith("o1") || model.startsWith("o3") || model.startsWith("o4")) return "gpt";
@@ -47909,8 +47978,9 @@ const baseProfile = {
 	includeUsageOnStream: true,
 	applyThinking(request) {
 		const thinking = request.thinking;
-		if (!thinking || thinking.type === "disabled") return {};
-		return { reasoning_effort: inferReasoningEffort(thinking.type === "adaptive" ? 24e3 : thinking.budgetTokens) };
+		if (thinking?.type === "disabled") return {};
+		if (!thinking) return request.outputEffort ? { reasoning_effort: request.outputEffort } : {};
+		return { reasoning_effort: resolveRequestEffort(request, thinking.type === "adaptive" ? 24e3 : thinking.budgetTokens) };
 	}
 };
 const claudeProfile = {
@@ -47920,10 +47990,11 @@ const claudeProfile = {
 	includeUsageOnStream: true,
 	applyThinking(request) {
 		const thinking = request.thinking;
-		if (!thinking || thinking.type === "disabled") return {};
+		if (thinking?.type === "disabled") return {};
+		if (!thinking) return request.outputEffort ? { reasoning_effort: request.outputEffort } : {};
 		const budgetTokens = thinking.type === "adaptive" ? 24e3 : thinking.budgetTokens;
 		return {
-			reasoning_effort: inferReasoningEffort(budgetTokens),
+			reasoning_effort: resolveRequestEffort(request, budgetTokens),
 			thinking_budget: budgetTokens
 		};
 	}
@@ -48448,6 +48519,7 @@ function buildCapiExecutionPlan(request, options = {}) {
 		stream: request.stream,
 		temperature: request.temperature,
 		top_p: request.topP,
+		...request.topK != null ? { top_k: request.topK } : {},
 		user: request.userId,
 		tools: serializeTools(request.tools),
 		tool_choice: serializeToolChoice(request.toolChoice),
@@ -48706,6 +48778,12 @@ const anthropicThinkingSchema = union([
 		budget_tokens: number().int().positive()
 	}).loose()
 ]);
+/**
+* `format` stays strict: an unrecognized key here means the caller expects a
+* constraint the proxy cannot translate, and silently accepting it would let a
+* schema-constrained request come back unconstrained. Rejecting is the honest
+* answer — see docs/solutions/integration-issues/claude-code-messages-startup-payloads.md.
+*/
 const anthropicOutputFormatSchema = object({
 	type: literal("json_schema"),
 	schema: jsonObjectSchema,
@@ -48713,16 +48791,24 @@ const anthropicOutputFormatSchema = object({
 	description: string().nullable().optional(),
 	strict: boolean().optional()
 }).strict();
+/**
+* `output_config` itself is loose. It is the fastest-moving object in the
+* Anthropic Messages schema, and it was the only strict container on this
+* boundary — so every field Anthropic added arrived here as a local 400 before
+* the request could reach a model that may well accept it. Unknown keys are
+* forwarded rather than rejected; `format` keeps its own strict contract above,
+* and `sanitizeOutputConfig` preserves the extras rather than dropping them.
+*/
 const anthropicOutputConfigSchema = object({
 	effort: _enum([
 		"low",
 		"medium",
 		"high",
-		"max",
-		"xhigh"
+		"xhigh",
+		"max"
 	]).nullable().optional(),
 	format: anthropicOutputFormatSchema.optional()
-}).strict();
+}).loose();
 const anthropicMessagesBasePayloadSchema = object({
 	model: string().min(1),
 	messages: array(anthropicMessageSchema).min(1),
@@ -48767,11 +48853,23 @@ function parseEmbeddingRequest(payload) {
 }
 //#endregion
 //#region src/types/copilot.ts
+/**
+* Effort levels Copilot accepts on `reasoning_effort`.
+*
+* Probed 2026-07-26 (`scripts/probes/effort-and-tokens.ts`): a model accepts
+* exactly the levels it advertises in `capabilities.supports.reasoning_effort`
+* and rejects the rest with 400, so always clamp against that list rather than
+* assuming this union is universally valid. `max` is gpt-5.6-and-later on the
+* Responses boundary, but available across the Claude family.
+*/
 const REASONING_EFFORT_VALUES = [
+	"none",
 	"minimal",
 	"low",
 	"medium",
-	"high"
+	"high",
+	"xhigh",
+	"max"
 ];
 //#endregion
 //#region src/ingest/validation/openai-chat.ts
@@ -48885,9 +48983,19 @@ function parseOpenAIChatPayload(payload) {
 }
 //#endregion
 //#region src/ingest/validation/responses.ts
+/**
+* Marks where a reusable cache prefix ends. Only models with explicit prompt
+* caching accept it — probed 2026-07-26, gpt-5.6 returns 200 while gpt-5.5 and
+* earlier return `400 prompt_cache_breakpoint is not supported on this model`
+* (`scripts/probes/prompt-caching.ts`).
+*
+* `explicit` is the only documented mode.
+*/
+const promptCacheBreakpointSchema = object({ mode: literal("explicit") }).loose();
 const responsesInputTextSchema = object({
 	type: _enum(["input_text", "output_text"]),
-	text: string()
+	text: string(),
+	prompt_cache_breakpoint: promptCacheBreakpointSchema.nullable().optional()
 }).loose();
 const responsesInputImageSchema = object({
 	type: literal("input_image"),
@@ -48898,7 +49006,8 @@ const responsesInputImageSchema = object({
 		"high",
 		"auto",
 		"original"
-	]).optional()
+	]).optional(),
+	prompt_cache_breakpoint: promptCacheBreakpointSchema.nullable().optional()
 }).loose().superRefine((item, ctx) => {
 	if (!item.image_url && !item.file_id) ctx.addIssue({
 		code: "custom",
@@ -49076,14 +49185,7 @@ const responsesToolChoiceSchema = union([
 	}).loose()
 ]);
 const responsesReasoningConfigSchema = object({
-	effort: _enum([
-		"none",
-		"minimal",
-		"low",
-		"medium",
-		"high",
-		"xhigh"
-	]).nullable().optional(),
+	effort: _enum(REASONING_EFFORT_VALUES).nullable().optional(),
 	generate_summary: _enum([
 		"auto",
 		"concise",
@@ -49141,6 +49243,10 @@ function createResponsesPayloadSchema(options) {
 		stream_options: object({ include_obfuscation: boolean().nullable().optional() }).loose().nullable().optional(),
 		safety_identifier: string().nullable().optional(),
 		prompt_cache_key: string().nullable().optional(),
+		prompt_cache_options: object({
+			mode: _enum(["implicit", "explicit"]).optional(),
+			ttl: literal("30m").optional()
+		}).loose().nullable().optional(),
 		prompt_cache_retention: _enum(["in-memory", "24h"]).nullable().optional(),
 		truncation: _enum(["auto", "disabled"]).nullable().optional(),
 		parallel_tool_calls: boolean().nullable().optional(),
@@ -49317,154 +49423,9 @@ function createUpstreamSignalFromConfig(clientSignal) {
 	return createUpstreamSignal(clientSignal, authStore.upstreamTimeoutSeconds !== void 0 ? authStore.upstreamTimeoutSeconds * 1e3 : void 0);
 }
 //#endregion
-//#region src/pipeline/runner.ts
-async function runPipeline(params, config) {
-	const ingested = protocolRegistry.ingest(config.protocol, params.body, params.headers);
-	const meta = ingested.meta;
-	const payload = config.afterIngest ? config.afterIngest({
-		payload: ingested.payload,
-		meta,
-		headers: params.headers
-	}) : ingested.payload;
-	const transformResult = config.transformChain.apply({
-		model: payload.model,
-		payload,
-		meta: { betaHeaders: meta.betaHeaders }
-	});
-	payload.model = transformResult.model;
-	const selectedModel = transformResult.resolvedModel;
-	const modelMapping = {
-		originalModel: transformResult.trace.length > 0 ? transformResult.trace[0].from : payload.model,
-		steps: transformResult.trace.map((r) => ({
-			tag: r.tag,
-			from: r.from,
-			to: r.to
-		}))
-	};
-	if (config.afterTransform) await config.afterTransform({
-		payload,
-		meta,
-		headers: params.headers,
-		transformResult,
-		selectedModel
-	});
-	const upstreamSignal = createUpstreamSignalFromConfig(params.signal);
-	const copilotClient = createCopilotClient();
-	const ctx = config.buildStrategyContext({
-		payload,
-		meta,
-		headers: params.headers,
-		selectedModel,
-		copilotClient,
-		upstreamSignal,
-		modelMapping
-	});
-	return {
-		result: await config.strategyRegistry.select(selectedModel, ctx).execute(ctx),
-		modelMapping
-	};
-}
-//#endregion
-//#region src/transform/chain.ts
-function composeModelTransforms(...steps) {
-	return { apply(input) {
-		let current = input.model;
-		const trace = [];
-		let resolvedModel = input.resolvedModel;
-		const payload = input.payload;
-		for (const step of steps) {
-			const output = step.apply({
-				...input,
-				model: current,
-				payload,
-				resolvedModel
-			});
-			if (output === null) continue;
-			const from = current;
-			const to = output.model;
-			if (output.mutatePayload) output.mutatePayload(payload);
-			if (output.tag) trace.push({
-				tag: output.tag,
-				from,
-				to
-			});
-			current = to;
-			if (output.resolvedModel !== void 0) resolvedModel = output.resolvedModel;
-		}
-		if (resolvedModel === void 0) resolvedModel = modelCache.findById(current);
-		return {
-			model: current,
-			resolvedModel,
-			trace
-		};
-	} };
-}
-//#endregion
 //#region src/transform/constants.ts
 const CONTEXT_BETA_RE = /^context-\d+[km]-/;
 //#endregion
-//#region src/transform/request-model-policy.ts
-const COMPACT_SYSTEM_PROMPT_START = "You are a helpful AI assistant tasked with summarizing conversations";
-function applyMessagesModelPolicy(payload, options) {
-	const originalModel = payload.model;
-	if (options?.betaUpgraded) return {
-		originalModel,
-		routedModel: originalModel
-	};
-	const smallModel = configStore.getSmallModel();
-	if (!smallModel || !configStore.isCompactSmallModelEnabled() || !isCompactRequest(payload)) return {
-		originalModel,
-		routedModel: originalModel
-	};
-	if (canRouteToSmallModel(payload, modelCache.findById(originalModel), modelCache.findById(smallModel))) {
-		payload.model = smallModel;
-		return {
-			originalModel,
-			routedModel: smallModel,
-			reason: "compact"
-		};
-	}
-	return {
-		originalModel,
-		routedModel: originalModel
-	};
-}
-function isCompactRequest(payload) {
-	if (typeof payload.system === "string") return payload.system.startsWith(COMPACT_SYSTEM_PROMPT_START);
-	if (!Array.isArray(payload.system)) return false;
-	return payload.system.some((block) => typeof block.text === "string" && block.text.startsWith(COMPACT_SYSTEM_PROMPT_START));
-}
-function canRouteToSmallModel(payload, originalModel, smallModel) {
-	if (!originalModel || !smallModel) return false;
-	const originalEndpoints = new Set(originalModel.supported_endpoints ?? []);
-	const smallEndpoints = new Set(smallModel.supported_endpoints ?? []);
-	for (const endpoint of originalEndpoints) if (!smallEndpoints.has(endpoint)) return false;
-	if (payload.tools?.length && !(smallModel.capabilities.supports.tool_calls ?? false)) return false;
-	if (payload.thinking && !(smallModel.capabilities.supports.adaptive_thinking ?? false)) return false;
-	if (hasVisionInput$1(payload) && !(smallModel.capabilities.supports.vision ?? false)) return false;
-	return true;
-}
-function hasVisionInput$1(payload) {
-	return payload.messages.some((message) => containsVisionContent$1(message.content));
-}
-function containsVisionContent$1(content) {
-	if (!Array.isArray(content)) return false;
-	return content.some((block) => block.type === "image");
-}
-//#endregion
-//#region src/transform/policy.ts
-const modelPolicyStep = {
-	tag: "POLICY",
-	apply({ payload, meta }) {
-		const routing = applyMessagesModelPolicy(payload, { betaUpgraded: meta?.betaHeaders?.some((b) => CONTEXT_BETA_RE.test(b)) ?? false });
-		if (!routing.reason) return null;
-		return {
-			model: routing.routedModel,
-			tag: "COMPACT"
-		};
-	}
-};
-//#endregion
 //#region src/transform/model-rewrite.ts
 /**
 * Unified model rewrite: user rules → built-in normalization → pass-through.
@@ -49521,42 +49482,133 @@ function matchesGlob(pattern, value) {
 	return new RegExp(`^${pattern.replace(GLOB_SPECIAL_RE, "\\$&").replace(GLOB_STAR_RE, ".*")}$`).test(value);
 }
 //#endregion
-//#region src/transform/rewrite.ts
-const rewriteStep = {
-	tag: "rewrite",
-	apply(input) {
-		const payload = input.payload;
-		const original = payload.model;
-		payload.model = input.model;
-		let result;
-		try {
-			result = applyModelRewrite(payload);
-		} finally {
-			payload.model = original;
-		}
-		if (!result.reason) return null;
+//#region src/transform/request-model-policy.ts
+const COMPACT_SYSTEM_PROMPT_START = "You are a helpful AI assistant tasked with summarizing conversations";
+function applyMessagesModelPolicy(payload, options) {
+	const originalModel = payload.model;
+	if (options?.betaUpgraded) return {
+		originalModel,
+		routedModel: originalModel
+	};
+	const smallModel = configStore.getSmallModel();
+	if (!smallModel || !configStore.isCompactSmallModelEnabled() || !isCompactRequest(payload)) return {
+		originalModel,
+		routedModel: originalModel
+	};
+	if (canRouteToSmallModel(payload, modelCache.findById(originalModel), modelCache.findById(smallModel))) {
+		payload.model = smallModel;
 		return {
-			model: result.model,
-			tag: result.reason,
-			mutatePayload: (p) => {
-				p.model = result.model;
-			}
+			originalModel,
+			routedModel: smallModel,
+			reason: "compact"
 		};
 	}
-};
+	return {
+		originalModel,
+		routedModel: originalModel
+	};
+}
+function isCompactRequest(payload) {
+	if (typeof payload.system === "string") return payload.system.startsWith(COMPACT_SYSTEM_PROMPT_START);
+	if (!Array.isArray(payload.system)) return false;
+	return payload.system.some((block) => typeof block.text === "string" && block.text.startsWith(COMPACT_SYSTEM_PROMPT_START));
+}
+function canRouteToSmallModel(payload, originalModel, smallModel) {
+	if (!originalModel || !smallModel) return false;
+	const originalEndpoints = new Set(originalModel.supported_endpoints ?? []);
+	const smallEndpoints = new Set(smallModel.supported_endpoints ?? []);
+	for (const endpoint of originalEndpoints) if (!smallEndpoints.has(endpoint)) return false;
+	if (payload.tools?.length && !(smallModel.capabilities.supports.tool_calls ?? false)) return false;
+	if (payload.thinking && !(smallModel.capabilities.supports.adaptive_thinking ?? false)) return false;
+	if (hasVisionInput$1(payload) && !(smallModel.capabilities.supports.vision ?? false)) return false;
+	return true;
+}
+function hasVisionInput$1(payload) {
+	return payload.messages.some((message) => containsVisionContent$1(message.content));
+}
+function containsVisionContent$1(content) {
+	if (!Array.isArray(content)) return false;
+	return content.some((block) => block.type === "image");
+}
 //#endregion
-//#region src/transform/beta-headers.ts
-const COPILOT_UNSUPPORTED_BETA_RE = /^mid-conversation-system-\d{4}-\d{2}-\d{2}$/;
-function processAnthropicBetaHeader(rawHeader) {
-	if (!rawHeader) return void 0;
-	const values = rawHeader.split(",").map((v) => v.trim()).filter(Boolean);
-	const filtered = [];
-	for (const value of values) {
-		if (CONTEXT_BETA_RE.test(value)) continue;
-		if (COPILOT_UNSUPPORTED_BETA_RE.test(value)) continue;
-		filtered.push(value);
+//#region src/transform/resolve-model.ts
+/**
+* Resolve the model a request should be dispatched with.
+*
+* Applies, in order:
+* 1. model rewrite -- user `modelRewrites` rules, then dash/dot normalization
+* 2. compact small-model routing -- only when `applyPolicy` is set
+* 3. lookup against the cached Copilot model list
+*
+* Order is load-bearing: policy inspects `payload.model`, so the rewrite must
+* be written back to the payload before policy runs. Both steps mutate
+* `payload.model` directly, which is also what dispatch reads downstream.
+*/
+function resolveRequestModel({ payload, betaHeaders, applyPolicy }) {
+	const originalModel = payload.model;
+	const steps = [];
+	const rewrite = applyModelRewrite(payload);
+	if (rewrite.reason) steps.push({
+		tag: rewrite.reason,
+		from: originalModel,
+		to: rewrite.model
+	});
+	if (applyPolicy) {
+		const routing = applyMessagesModelPolicy(payload, { betaUpgraded: betaHeaders?.some((b) => CONTEXT_BETA_RE.test(b)) ?? false });
+		if (routing.reason) {
+			steps.push({
+				tag: "COMPACT",
+				from: routing.originalModel,
+				to: routing.routedModel
+			});
+			payload.model = routing.routedModel;
+		}
 	}
-	return filtered.length > 0 ? filtered.join(",") : void 0;
+	return {
+		model: payload.model,
+		resolvedModel: modelCache.findById(payload.model),
+		modelMapping: {
+			originalModel,
+			steps
+		}
+	};
+}
+//#endregion
+//#region src/pipeline/runner.ts
+async function runPipeline(params, config) {
+	const ingested = protocolRegistry.ingest(config.protocol, params.body, params.headers);
+	const meta = ingested.meta;
+	const payload = config.afterIngest ? config.afterIngest({
+		payload: ingested.payload,
+		meta,
+		headers: params.headers
+	}) : ingested.payload;
+	const { resolvedModel: selectedModel, modelMapping } = resolveRequestModel({
+		payload,
+		betaHeaders: meta.betaHeaders,
+		applyPolicy: config.applyModelPolicy
+	});
+	if (config.afterTransform) await config.afterTransform({
+		payload,
+		meta,
+		headers: params.headers,
+		selectedModel
+	});
+	const upstreamSignal = createUpstreamSignalFromConfig(params.signal);
+	const copilotClient = createCopilotClient();
+	const ctx = config.buildStrategyContext({
+		payload,
+		meta,
+		headers: params.headers,
+		selectedModel,
+		copilotClient,
+		upstreamSignal,
+		modelMapping
+	});
+	return {
+		result: await config.strategyRegistry.select(selectedModel, ctx).execute(ctx),
+		modelMapping
+	};
 }
 //#endregion
 //#region src/translator/responses/signature-codec.ts
@@ -49628,7 +49680,28 @@ function isOutputConfigEffort(value) {
 	return OUTPUT_CONFIG_EFFORT_RANK.has(value);
 }
 function normalizeOutputConfigEffort(effort, model) {
-	const supportedEfforts = model?.capabilities.supports.reasoning_effort?.filter(isOutputConfigEffort);
+	return clampEffortToAdvertised(effort, model?.capabilities.supports.reasoning_effort);
+}
+/**
+* Clamp an effort to the highest level a model actually advertises.
+*
+* Probed 2026-07-26 (`scripts/probes/effort-and-tokens.ts`): a model rejects
+* every level it does not advertise, and the levels are NOT an ordered ladder
+* every model implements a prefix of — `claude-opus-4.6` and
+* `claude-sonnet-4.6` advertise `max` but not `xhigh`, and reject `xhigh` while
+* accepting `max`. So the target must be derived from the advertised list, not
+* from a fixed fallback.
+*
+* Levels outside the Anthropic `output_config` vocabulary (`none`, `minimal`)
+* are filtered out first: they are valid clamp *inputs* on the Responses
+* boundary but never valid clamp *targets*, since silently landing on `none`
+* would disable reasoning the caller asked for.
+*
+* Returns undefined when the model advertises nothing usable, which callers
+* treat as "leave the request alone".
+*/
+function clampEffortToAdvertised(effort, advertised) {
+	const supportedEfforts = advertised?.filter(isOutputConfigEffort);
 	if (!supportedEfforts?.length) return;
 	if (supportedEfforts.includes(effort)) return effort;
 	return supportedEfforts.reduce((highest, current) => {
@@ -49639,6 +49712,45 @@ function normalizeOutputConfigEffort(effort, model) {
 function hasOutputConfigFormat(payload) {
 	return payload?.output_config?.format != null;
 }
+/**
+* Whether {@link reduceOutputFormatForNativeMessages} can produce a
+* native-acceptable format without dropping a caller guarantee.
+*
+* Split from the reducer so strategy selection stays a pure predicate.
+*/
+function canReduceOutputFormatForNativeMessages(payload) {
+	const format = payload?.output_config?.format;
+	return !format || format.strict === void 0 && format.description === void 0;
+}
+/**
+* Reduce `output_config.format` to the shape Copilot's native `/v1/messages`
+* accepts.
+*
+* Probed 2026-07-26 (`scripts/probes/messages/output-format.ts`): native
+* Messages serves a bare `{ type, schema }` on every model that advertises
+* `structured_outputs`, but rejects every optional Anthropic annotation —
+* `output_config.format.name: Extra inputs are not permitted`, same for
+* `description` and `strict`. The Anthropic schema allows all three, so a
+* caller can legitimately send them.
+*
+* Only `name` is dropped here, and only because it is a pure label: Anthropic
+* documents no effect on the reply, and the Responses translator has to invent
+* one when the caller omits it. `description` and `strict` both influence the
+* reply — one guides the model's output, the other promises the schema is
+* enforced — so {@link canReduceOutputFormatForNativeMessages} keeps those
+* requests off this path entirely rather than quietly reducing them here.
+*/
+function reduceOutputFormatForNativeMessages(payload) {
+	const format = payload.output_config?.format;
+	if (!format || format.name === void 0) return;
+	payload.output_config = {
+		...payload.output_config,
+		format: {
+			type: format.type,
+			schema: format.schema
+		}
+	};
+}
 function budgetTokensToEffort(budget) {
 	if (budget >= 24e3) return "high";
 	if (budget >= 8e3) return "medium";
@@ -49664,6 +49776,15 @@ function convertEnabledThinkingToAdaptive(payload, model) {
 		effort: budgetTokensToEffort(budget)
 	};
 }
+/**
+* Normalize `output_config` for the native `/v1/messages` boundary.
+*
+* Rebuilds nothing it does not have to: the effort is clamped in place and
+* every other key is preserved. `output_config` is loose at ingress precisely
+* so newer Anthropic fields can reach a model that may accept them — dropping
+* them here would move the failure from a visible 400 to a silent semantic
+* change, which is worse.
+*/
 function sanitizeOutputConfig(payload, model) {
 	if (!payload.output_config) return;
 	if (!modelCache.supportsOutputConfig(model)) {
@@ -49672,10 +49793,14 @@ function sanitizeOutputConfig(payload, model) {
 	}
 	const effort = payload.output_config.effort;
 	if (effort == null) {
+		if (payload.output_config.format) {
+			delete payload.output_config.effort;
+			return;
+		}
 		delete payload.output_config;
 		return;
 	}
-	payload.output_config = { effort: normalizeOutputConfigEffort(effort, model) ?? effort };
+	payload.output_config.effort = normalizeOutputConfigEffort(effort, model) ?? effort;
 }
 function normalizeCacheControlBlock(obj) {
 	if (obj.cache_control && typeof obj.cache_control === "object") obj.cache_control = { type: obj.cache_control.type };
@@ -49688,11 +49813,223 @@ function sanitizeCacheControl(payload) {
 	}
 	if (payload.tools) for (const tool of payload.tools) normalizeCacheControlBlock(tool);
 }
+/**
+* Drop `top_p` when `temperature` is also present.
+*
+* Copilot's native `/v1/messages` endpoint rejects the pair outright for
+* non-reasoning Claude models:
+*
+*   `temperature` and `top_p` cannot both be specified for this model.
+*   Please use only one.
+*
+* Probed 2026-07-26 (`scripts/probes/sampling-params.ts`): reproduced on
+* claude-sonnet-4.5 and claude-haiku-4.5; every reasoning model accepted both.
+* Rather than leak a 400 for a combination clients send routinely, the proxy
+* keeps `temperature` — the more widely used control, and the one both the
+* Anthropic and OpenAI defaults are expressed in — and drops `top_p`.
+*
+* Applied unconditionally on this boundary: models that accept the pair are
+* unaffected in practice, since sending only `temperature` is always valid.
+*/
+function sanitizeExclusiveSamplingParams(payload) {
+	if (payload.temperature === void 0 || payload.top_p === void 0) return;
+	consola.warn(`Dropped top_p=${payload.top_p}: Copilot rejects temperature and top_p together on /v1/messages. Keeping temperature=${payload.temperature}.`);
+	delete payload.top_p;
+}
 //#endregion
-//#region src/transform/index.ts
-const messagesModelChain = composeModelTransforms(rewriteStep, modelPolicyStep);
-const chatCompletionsModelChain = composeModelTransforms(rewriteStep);
-const responsesModelChain = composeModelTransforms(rewriteStep);
+//#region src/transform/parameter-filter.ts
+/**
+* Parameters the default rule strips for reasoning models on the Responses
+* boundary. Reasoning models (gpt-5 family, o-series, codex) reject sampling
+* parameters upstream with a 400 "Unsupported parameter" error, so the proxy
+* drops them instead of leaking the incompatibility to the client.
+*/
+const DEFAULT_REASONING_UNSUPPORTED_PARAMS = ["temperature", "top_p"];
+/**
+* Models that accept a parameter the blanket reasoning rule would otherwise
+* strip. Probed 2026-07-26 (`scripts/probes/sampling-params.ts`): every
+* `/responses` reasoning model rejected `temperature`, but `gpt-5.3-codex`
+* accepted `top_p` (200) while its siblings returned
+* `Unsupported parameter: 'top_p' is not supported with this model`.
+*
+* Copilot does not advertise per-parameter support — `capabilities.supports`
+* is byte-identical across gpt-5.3-codex, gpt-5.4 and gpt-5.4-mini — so this
+* cannot be derived and has to be an evidence-backed glob list. Re-run the
+* probe when new models appear.
+*/
+const REASONING_PARAM_EXEMPTIONS = [{
+	models: ["*-codex", "*-codex-*"],
+	params: ["top_p"]
+}];
+/**
+* A reasoning model is any model that advertises one or more
+* `reasoning_effort` levels. This dynamically covers the full reasoning
+* family (mini, codex, future point releases) without a hardcoded ID list.
+*/
+function isReasoningModel(model) {
+	return modelCache.supportsReasoningEffort(model);
+}
+/**
+* Resolve the set of request parameters to strip for a given model on the
+* Responses boundary.
+*
+* Rule composition:
+* 1. Built-in default: reasoning models strip {@link DEFAULT_REASONING_UNSUPPORTED_PARAMS}.
+*    Disabled entirely when `responsesApiParameterFiltersReplaceDefault` is true.
+* 2. User rules (`responsesApiParameterFilters`): every rule whose `models`
+*    glob matches the resolved model id contributes its `params`.
+*
+* The result is the union of all matching rules, so user rules ADD to the
+* default. Setting `responsesApiParameterFiltersReplaceDefault: true` disables
+* the default so user rules fully OVERWRITE it.
+*/
+function resolveStrippedResponsesParams(model) {
+	const params = /* @__PURE__ */ new Set();
+	const modelId = model?.id;
+	if (!configStore.shouldReplaceDefaultParameterFilters() && isReasoningModel(model)) {
+		const exempt = modelId ? resolveReasoningExemptions(modelId) : /* @__PURE__ */ new Set();
+		for (const param of DEFAULT_REASONING_UNSUPPORTED_PARAMS) if (!exempt.has(param)) params.add(param);
+	}
+	if (modelId) {
+		for (const rule of configStore.getResponsesParameterFilters()) if (rule.models.some((pattern) => matchesGlob(pattern, modelId))) for (const param of rule.params) params.add(param);
+	}
+	return params;
+}
+/**
+* Params the default reasoning rule must NOT strip for this model.
+*
+* Exemptions only narrow the built-in default — a user rule naming the same
+* param still strips it, so an operator can always be more conservative than
+* the probe evidence.
+*/
+function resolveReasoningExemptions(modelId) {
+	const exempt = /* @__PURE__ */ new Set();
+	for (const rule of REASONING_PARAM_EXEMPTIONS) if (rule.models.some((pattern) => matchesGlob(pattern, modelId))) for (const param of rule.params) exempt.add(param);
+	return exempt;
+}
+/**
+* Strip unsupported parameters from a Responses payload before dispatch.
+* Keys are deleted entirely (never set to null) because upstream rejects the
+* mere presence of the key, not just non-null values.
+*/
+function applyResponsesParameterFilters(payload, model) {
+	const strip = resolveStrippedResponsesParams(model);
+	if (strip.size === 0) return;
+	const removed = [];
+	for (const key of strip) if (key in payload) {
+		delete payload[key];
+		removed.push(key);
+	}
+	if (removed.length > 0) consola.debug(`Stripped unsupported responses params for model ${model?.id}: ${removed.join(", ")}`);
+}
+/**
+* Models whose `/chat/completions` endpoint rejects `max_tokens` and require
+* `max_completion_tokens` instead:
+*
+*   Unsupported parameter: 'max_tokens' is not supported with this model.
+*   Use 'max_completion_tokens' instead.
+*
+* Probed 2026-07-26 (`scripts/probes/effort-and-tokens.ts`): reproduced on
+* gpt-5.4. Every other reachable model accepted both spellings — though for
+* reasoning models the two differ in meaning, since `max_tokens` counts
+* thinking tokens against the budget while `max_completion_tokens` does not.
+*
+* Copilot advertises nothing that distinguishes these models, so this is an
+* evidence-backed glob list. Extend it via `chatCompletionsUseMaxCompletionTokens`.
+*/
+const DEFAULT_MAX_COMPLETION_TOKENS_MODELS = ["gpt-5.4", "gpt-5.4-*"];
+/**
+* Rename `max_tokens` to `max_completion_tokens` for models that reject the
+* former. No-op when the caller sent neither, or when the model accepts
+* `max_tokens` — which is still the majority.
+*/
+function applyChatCompletionsTokenParam(payload, model) {
+	if (payload.max_tokens == null) return;
+	const modelId = model?.id;
+	if (!modelId || !requiresMaxCompletionTokens(modelId)) return;
+	const record = payload;
+	record.max_completion_tokens = payload.max_tokens;
+	delete record.max_tokens;
+	consola.debug(`Renamed max_tokens to max_completion_tokens for model ${modelId}`);
+}
+function requiresMaxCompletionTokens(modelId) {
+	return [...DEFAULT_MAX_COMPLETION_TOKENS_MODELS, ...configStore.getChatCompletionsMaxCompletionTokensModels()].some((pattern) => matchesGlob(pattern, modelId));
+}
+/**
+* Copilot's `/responses` minimum for `max_output_tokens`:
+*
+*   Invalid 'max_output_tokens': integer below minimum value.
+*   Expected a value >= 16
+*
+* Probed 2026-07-26 (`scripts/probes/effort-and-tokens.ts`): identical across
+* all 9 `/responses` models. The ceiling is NOT enforced — the advertised
+* `limits.max_output_tokens` + 1 was accepted everywhere — so only the floor
+* is clamped.
+*/
+const RESPONSES_MIN_OUTPUT_TOKENS = 16;
+/**
+* Raise a below-minimum `max_output_tokens` to Copilot's floor.
+*
+* The client-facing schema still accepts 0..15: those are valid OpenAI input,
+* and this floor is a Copilot quirk the proxy absorbs rather than leaks back
+* as a 400.
+*/
+function clampResponsesOutputTokens(payload) {
+	const requested = payload.max_output_tokens;
+	if (requested == null || requested >= RESPONSES_MIN_OUTPUT_TOKENS) return;
+	payload.max_output_tokens = RESPONSES_MIN_OUTPUT_TOKENS;
+	consola.debug(`Raised max_output_tokens from ${requested} to the Copilot minimum of ${RESPONSES_MIN_OUTPUT_TOKENS}`);
+}
+/**
+* Clamp `reasoning.effort` on the OpenAI-facing `/responses` route to a level
+* the resolved model advertises.
+*
+* This route forwards the caller's own vocabulary, so leaving effort alone is
+* defensible in isolation — but it is not a passthrough in practice. The same
+* `afterTransform` already strips `temperature`/`top_p` for reasoning models and
+* raises a below-minimum `max_output_tokens`, so effort was the one parameter
+* where the proxy knew the request would 400 and forwarded it anyway.
+*
+* `none` and `minimal` pass through unranked, matching the Anthropic-to-Responses
+* path: they are Responses-only levels rather than rungs on the effort ladder,
+* and clamping `none` upward would invert the caller's intent.
+*/
+function clampResponsesReasoningEffort(payload, model) {
+	const requested = payload.reasoning?.effort;
+	if (!requested || requested === "none" || requested === "minimal") return;
+	const clamped = clampEffortToAdvertised(requested, model?.capabilities.supports.reasoning_effort);
+	if (!clamped || clamped === requested) return;
+	payload.reasoning = {
+		...payload.reasoning,
+		effort: clamped
+	};
+	consola.warn(`Lowered reasoning.effort from ${requested} to ${clamped}, the highest level ${model?.id} advertises.`);
+}
+/**
+* Lower a `max_tokens` above the model's advertised ceiling to that ceiling.
+*
+* Copilot's native `/v1/messages` enforces its ceiling, unlike `/responses`
+* where the advertised value is advisory:
+*
+*   max_tokens: 64001 > 64000, which is the maximum allowed number of output
+*   tokens for claude
+*
+* Probed 2026-07-26 (`scripts/probes/effort-and-tokens.ts`). The model record
+* already carries the bound, so leaking a 400 for a value the proxy could have
+* corrected is a worse outcome than serving a shorter completion.
+*
+* Unlike the `/responses` floor this is a real semantic change — the caller
+* receives less output than they asked for — so it warns rather than logs at
+* debug level. No advertised ceiling means no clamp: an unknown bound is not a
+* reason to guess one.
+*/
+function clampMessagesOutputTokens(payload, model) {
+	const ceiling = model?.capabilities.limits.max_output_tokens;
+	const requested = payload.max_tokens;
+	if (ceiling == null || requested == null || requested <= ceiling) return;
+	payload.max_tokens = ceiling;
+	consola.warn(`Lowered max_tokens from ${requested} to ${ceiling}, the ceiling ${model?.id} advertises. Copilot rejects a higher value outright on /v1/messages.`);
+}
 //#endregion
 //#region src/translator/anthropic/document.ts
 /** Trimmed text of a `content`-source document part, or undefined when it carries none. */
@@ -49890,6 +50227,7 @@ function normalizeAnthropicRequest(payload) {
 		})),
 		toolChoice: normalizeToolChoice(payload.tool_choice),
 		thinking: normalizeThinking(payload.thinking),
+		outputEffort: payload.output_config?.effort ?? void 0,
 		serviceTier: payload.service_tier
 	};
 }
@@ -50364,11 +50702,6 @@ function toConversationTurn(turn) {
 	};
 }
 function recordAnthropicRequestIssues(request, context) {
-	if (request.topK !== void 0) context.record({
-		kind: "unsupported_top_k",
-		severity: "warning",
-		message: "Anthropic top_k is not supported by the upstream Copilot CAPI payload and was dropped."
-	}, { fatalInStrict: true });
 	if (request.serviceTier !== void 0) context.record({
 		kind: "unsupported_service_tier",
 		severity: "warning",
@@ -50435,6 +50768,7 @@ function normalizeAnthropicConversation(payload, policy) {
 			stream: normalized.stream,
 			temperature: normalized.temperature,
 			topP: normalized.topP,
+			topK: normalized.topK,
 			userId: normalized.userId,
 			tools: normalized.tools?.map((tool) => ({
 				name: tool.name,
@@ -50442,7 +50776,8 @@ function normalizeAnthropicConversation(payload, policy) {
 				inputSchema: tool.inputSchema
 			})),
 			toolChoice: normalized.toolChoice,
-			thinking: normalized.thinking
+			thinking: normalized.thinking,
+			outputEffort: normalized.outputEffort ?? void 0
 		},
 		issues: context.getIssues()
 	};
@@ -50764,7 +51099,6 @@ async function handleCompletionCore({ body, signal, headers }) {
 		headers
 	}, {
 		protocol: "openai-chat",
-		transformChain: chatCompletionsModelChain,
 		strategyRegistry: chatCompletionsStrategyRegistry,
 		afterIngest({ payload }) {
 			consola.debug("Request payload:", JSON.stringify(payload).slice(-400));
@@ -50783,6 +51117,7 @@ async function handleCompletionCore({ body, signal, headers }) {
 				payload.max_tokens = selectedModel?.capabilities.limits.max_output_tokens;
 				consola.debug("Set max_tokens to:", JSON.stringify(payload.max_tokens));
 			}
+			applyChatCompletionsTokenParam(payload, selectedModel);
 		},
 		buildStrategyContext({ payload, meta, copilotClient, upstreamSignal, modelMapping }) {
 			return {
@@ -50820,16 +51155,27 @@ function normalizeEmbeddingRequest(payload) {
 }
 /**
 * Core handler for creating embeddings.
+*
+* `client` is an injection seam for tests; production callers omit it. This
+* route does not go through `runPipeline`, so it constructs its own client and
+* derives its own upstream signal — otherwise a client disconnect would leave
+* the upstream request running and the configured timeout unenforced.
 */
-async function handleEmbeddingsCore(body, headers) {
+async function handleEmbeddingsCore(body, headers, client, signal) {
 	const { payload } = protocolRegistry.ingest("embeddings", body, headers);
-	return await createCopilotClient().createEmbeddings(normalizeEmbeddingRequest(payload));
+	const copilotClient = client ?? createCopilotClient();
+	const upstreamSignal = signal ? createUpstreamSignalFromConfig(signal) : void 0;
+	try {
+		return await copilotClient.createEmbeddings(normalizeEmbeddingRequest(payload), { signal: upstreamSignal?.signal });
+	} finally {
+		upstreamSignal?.cleanup();
+	}
 }
 //#endregion
 //#region src/routes/embeddings/route.ts
 function createEmbeddingRoutes() {
 	return new Elysia().use(requestGuardPlugin).post("/embeddings", async ({ body, request }) => {
-		return handleEmbeddingsCore(body, request.headers);
+		return handleEmbeddingsCore(body, request.headers, void 0, request.signal);
 	}, { guarded: true });
 }
 //#endregion
@@ -50883,6 +51229,20 @@ async function handleCountTokensCore({ body, headers }) {
 	return { input_tokens: finalTokenCount };
 }
 //#endregion
+//#region src/transform/beta-headers.ts
+const COPILOT_UNSUPPORTED_BETA_RE = /^mid-conversation-system-\d{4}-\d{2}-\d{2}$/;
+function processAnthropicBetaHeader(rawHeader) {
+	if (!rawHeader) return void 0;
+	const values = rawHeader.split(",").map((v) => v.trim()).filter(Boolean);
+	const filtered = [];
+	for (const value of values) {
+		if (CONTEXT_BETA_RE.test(value)) continue;
+		if (COPILOT_UNSUPPORTED_BETA_RE.test(value)) continue;
+		filtered.push(value);
+	}
+	return filtered.length > 0 ? filtered.join(",") : void 0;
+}
+//#endregion
 //#region src/transform/context-management.ts
 /** Default token threshold when model limits are unknown. */
 const DEFAULT_COMPACT_THRESHOLD = 5e4;
@@ -50944,59 +51304,32 @@ function containsVisionContent(value) {
 	return false;
 }
 //#endregion
-//#region src/transform/parameter-filter.ts
+//#region src/transform/responses-input.ts
 /**
-* Parameters the default rule strips for reasoning models on the Responses
-* boundary. Reasoning models (gpt-5 family, o-series, codex) reject sampling
-* parameters upstream with a 400 "Unsupported parameter" error, so the proxy
-* drops them instead of leaking the incompatibility to the client.
-*/
-const DEFAULT_REASONING_UNSUPPORTED_PARAMS = ["temperature", "top_p"];
-/**
-* A reasoning model is any model that advertises one or more
-* `reasoning_effort` levels. This dynamically covers the full reasoning
-* family (mini, codex, future point releases) without a hardcoded ID list.
-*/
-function isReasoningModel(model) {
-	return modelCache.supportsReasoningEffort(model);
-}
-/**
-* Resolve the set of request parameters to strip for a given model on the
-* Responses boundary.
+* Strip `phase` from input message items.
 *
-* Rule composition:
-* 1. Built-in default: reasoning models strip {@link DEFAULT_REASONING_UNSUPPORTED_PARAMS}.
-*    Disabled entirely when `responsesApiParameterFiltersReplaceDefault` is true.
-* 2. User rules (`responsesApiParameterFilters`): every rule whose `models`
-*    glob matches the resolved model id contributes its `params`.
+* `phase` (`commentary` / `final_answer`) is an output-only annotation. Some
+* models reject it when it is sent back as input — this repo traced an
+* upstream `400 invalid_request_body` to exactly that (see
+* `docs/investigation-responses-404.md`).
 *
-* The result is the union of all matching rules, so user rules ADD to the
-* default. Setting `responsesApiParameterFiltersReplaceDefault: true` disables
-* the default so user rules fully OVERWRITE it.
+* Both Responses dispatch paths must call this. `POST /responses` receives the
+* field from clients replaying prior output; the `/v1/messages` → Responses
+* strategy has the translator *generate* it (see `resolveAssistantPhase` in
+* `translator/responses/response-items.ts`), so neither path is exempt.
 */
-function resolveStrippedResponsesParams(model) {
-	const params = /* @__PURE__ */ new Set();
-	if (!configStore.shouldReplaceDefaultParameterFilters() && isReasoningModel(model)) for (const param of DEFAULT_REASONING_UNSUPPORTED_PARAMS) params.add(param);
-	const modelId = model?.id;
-	if (modelId) {
-		for (const rule of configStore.getResponsesParameterFilters()) if (rule.models.some((pattern) => matchesGlob(pattern, modelId))) for (const param of rule.params) params.add(param);
-	}
-	return params;
-}
-/**
-* Strip unsupported parameters from a Responses payload before dispatch.
-* Keys are deleted entirely (never set to null) because upstream rejects the
-* mere presence of the key, not just non-null values.
-*/
-function applyResponsesParameterFilters(payload, model) {
-	const strip = resolveStrippedResponsesParams(model);
-	if (strip.size === 0) return;
-	const removed = [];
-	for (const key of strip) if (key in payload) {
-		delete payload[key];
-		removed.push(key);
+function stripPhaseFromInputMessages(payload) {
+	if (!Array.isArray(payload.input)) return;
+	let stripped = 0;
+	for (const item of payload.input) {
+		if (typeof item !== "object" || item === null) continue;
+		const rec = item;
+		if ((!("type" in rec) || rec.type === "message") && "phase" in rec) {
+			delete rec.phase;
+			stripped++;
+		}
 	}
-	if (removed.length > 0) consola.debug(`Stripped unsupported responses params for model ${model?.id}: ${removed.join(", ")}`);
+	if (stripped > 0) consola.debug(`Stripped phase from ${stripped} input message item(s)`);
 }
 //#endregion
 //#region src/translator/responses/function-schema.ts
@@ -51218,6 +51551,7 @@ function translateAnthropicToResponsesPayload(payload, options) {
 		instructions: translateSystemPrompt(payload.system),
 		temperature: payload.temperature ?? null,
 		top_p: payload.top_p ?? null,
+		...payload.top_k !== void 0 ? { top_k: payload.top_k } : {},
 		max_output_tokens: payload.max_tokens,
 		tools: convertAnthropicTools(payload.tools),
 		tool_choice: convertAnthropicToolChoice(payload.tool_choice),
@@ -51387,25 +51721,49 @@ function resolveResponsesTextConfig(payload) {
 		} };
 	}
 }
+/**
+* Resolve the Responses `reasoning.effort` for an Anthropic request.
+*
+* Every branch below produces a *candidate* the caller did not name directly —
+* a hardcoded tier, a config default, or a mapped `output_config.effort` — so
+* all of them are clamped at the single exit. Clamping only the
+* `output_config.effort` branch left the others able to emit a level the model
+* rejects: `adaptive` sent `medium` to a model advertising `[high, xhigh, max]`,
+* and `enabled` sent the configured default with an `as` cast and no check.
+*/
 function resolveResponsesReasoningEffort(payload, options) {
+	const candidate = resolveEffortCandidate(payload, options);
+	if (!candidate) return candidate;
+	return clampResponsesEffort(candidate, options);
+}
+function resolveEffortCandidate(payload, options) {
 	if (payload.thinking?.type === "disabled") return "none";
-	if (payload.output_config?.effort) return mapAnthropicEffortToResponses(payload.output_config.effort);
+	if (payload.output_config?.effort) return payload.output_config.effort;
 	if (payload.thinking?.type === "adaptive") return "medium";
 	if (payload.thinking?.type === "enabled") return options?.reasoningEffortResolver?.(payload.model) ?? "medium";
 }
-function mapAnthropicEffortToResponses(effort) {
-	if (effort === "max") return "xhigh";
-	return effort;
+/**
+* Clamp a Responses effort to what the target model advertises.
+*
+* `none` and `minimal` belong to the Responses vocabulary but not to the
+* Anthropic `output_config` ladder, so they are passed through rather than
+* ranked: `none` means "do not reason", and clamping it *up* to the model's
+* highest advertised level would invert the caller's intent. Every model
+* observed on `/responses` advertises `none` (probed 2026-07-26).
+*
+* With no advertised list the effort passes through untouched — with nothing to
+* derive from, forwarding the request beats guessing at a level that may be both
+* a downgrade and still unsupported.
+*/
+function clampResponsesEffort(effort, options) {
+	if (effort === "none" || effort === "minimal") return effort;
+	return clampEffortToAdvertised(effort, options?.supportedEfforts) ?? effort;
 }
 function assertResponsesCompatibleRequest(payload) {
 	if (payload.stop_sequences?.length) throw new TranslationFailure("Anthropic stop_sequences cannot be forwarded through the Responses execution path.", {
 		status: 400,
 		kind: "unsupported_stop_sequences"
 	});
-	if (payload.top_k !== void 0) throw new TranslationFailure("Anthropic top_k is not supported on the Responses execution path.", {
-		status: 400,
-		kind: "unsupported_top_k"
-	});
 	if (payload.service_tier !== void 0) throw new TranslationFailure("Anthropic service_tier is not supported on the Responses execution path.", {
 		status: 400,
 		kind: "unsupported_service_tier"
@@ -51687,10 +52045,12 @@ function mapResponsesUsage(response) {
 	const inputTokens = response.usage?.input_tokens ?? 0;
 	const outputTokens = response.usage?.output_tokens ?? 0;
 	const cachedTokens = response.usage?.input_tokens_details?.cached_tokens;
+	const writtenTokens = response.usage?.input_tokens_details?.cache_write_tokens;
 	return {
 		input_tokens: inputTokens - (cachedTokens ?? 0),
 		output_tokens: outputTokens,
-		...cachedTokens !== void 0 ? { cache_read_input_tokens: cachedTokens } : {}
+		...cachedTokens !== void 0 ? { cache_read_input_tokens: cachedTokens } : {},
+		...writtenTokens ? { cache_creation_input_tokens: writtenTokens } : {}
 	};
 }
 function isRecord$1(value) {
@@ -52143,12 +52503,15 @@ function createMessagesViaResponsesStrategy(copilotClient, responsesPayload, opt
 //#region src/routes/messages/strategy-registry.ts
 const nativeMessagesEntry = {
 	name: "native-messages",
-	canHandle: (model, ctx) => modelCache.supportsEndpoint(model, "/v1/messages") && !hasOutputConfigFormat(ctx?.anthropicPayload),
+	canHandle: (model, ctx) => modelCache.supportsEndpoint(model, "/v1/messages") && (!hasOutputConfigFormat(ctx?.anthropicPayload) || modelCache.supportsStructuredOutputs(model) && canReduceOutputFormatForNativeMessages(ctx?.anthropicPayload)),
 	async execute(ctx) {
 		convertEnabledThinkingToAdaptive(ctx.anthropicPayload, ctx.selectedModel);
 		filterThinkingBlocksForNativeMessages(ctx.anthropicPayload);
 		sanitizeOutputConfig(ctx.anthropicPayload, ctx.selectedModel);
+		reduceOutputFormatForNativeMessages(ctx.anthropicPayload);
+		sanitizeExclusiveSamplingParams(ctx.anthropicPayload);
 		sanitizeCacheControl(ctx.anthropicPayload);
+		clampMessagesOutputTokens(ctx.anthropicPayload, ctx.selectedModel);
 		return await runStrategy(createNativeMessagesStrategy(ctx.copilotClient, ctx.anthropicPayload, ctx.anthropicBetaHeader, {
 			signal: ctx.upstreamSignal.signal,
 			requestContext: ctx.requestContext
@@ -52159,10 +52522,15 @@ const responsesApiEntry = {
 	name: "responses-api",
 	canHandle: (model) => modelCache.supportsEndpoint(model, RESPONSES_ENDPOINT),
 	async execute(ctx) {
-		const responsesPayload = withTranslationErrors(() => translateAnthropicToResponsesPayload(ctx.anthropicPayload, { reasoningEffortResolver: (model) => configStore.getReasoningEffort(model) }));
+		const responsesPayload = withTranslationErrors(() => translateAnthropicToResponsesPayload(ctx.anthropicPayload, {
+			reasoningEffortResolver: (model) => configStore.getReasoningEffort(model),
+			supportedEfforts: ctx.selectedModel?.capabilities.supports.reasoning_effort
+		}));
 		applyContextManagement(responsesPayload, ctx.selectedModel?.capabilities.limits.max_prompt_tokens);
 		compactInputByLatestCompaction(responsesPayload);
+		stripPhaseFromInputMessages(responsesPayload);
 		applyResponsesParameterFilters(responsesPayload, ctx.selectedModel);
+		clampResponsesOutputTokens(responsesPayload);
 		const { vision, initiator } = getResponsesRequestOptions(responsesPayload);
 		return await runStrategy(createMessagesViaResponsesStrategy(ctx.copilotClient, responsesPayload, {
 			vision,
@@ -52199,7 +52567,7 @@ async function handleMessagesCore({ body, signal, headers }) {
 		headers
 	}, {
 		protocol: "anthropic-messages",
-		transformChain: messagesModelChain,
+		applyModelPolicy: true,
 		strategyRegistry: defaultStrategyRegistry,
 		afterIngest({ payload, headers: reqHeaders }) {
 			if (consola.level >= 4) consola.debug("Anthropic request payload:", JSON.stringify(payload));
@@ -52244,9 +52612,13 @@ function createMessageRoutes() {
 //#region src/routes/models/handler.ts
 /**
 * Core handler for listing models.
+*
+* `client` is an injection seam for tests; production callers omit it. This
+* route does not go through `runPipeline`, so it constructs its own client on
+* a cache miss.
 */
-async function handleModelsCore() {
-	if (!modelCache.getModels()) await cacheModels(createCopilotClient());
+async function handleModelsCore(client) {
+	if (!modelCache.getModels()) await cacheModels(client ?? createCopilotClient());
 	return {
 		object: "list",
 		data: modelCache.getModels()?.data.map((model) => ({
@@ -52264,9 +52636,9 @@ async function handleModelsCore() {
 //#endregion
 //#region src/routes/models/route.ts
 function createModelRoutes() {
-	return new Elysia().get("/models", async () => {
+	return new Elysia().use(requestGuardPlugin).get("/models", async () => {
 		return handleModelsCore();
-	});
+	}, { guarded: true });
 }
 //#endregion
 //#region src/routes/responses/emulator.ts
@@ -52646,7 +53018,6 @@ async function handleResponsesCore({ body, signal, headers }) {
 		headers
 	}, {
 		protocol: "responses",
-		transformChain: responsesModelChain,
 		strategyRegistry: responsesStrategyRegistry,
 		afterIngest({ payload }) {
 			originalPayload = payload;
@@ -52661,6 +53032,8 @@ async function handleResponsesCore({ body, signal, headers }) {
 			if (!modelCache.supportsEndpoint(selectedModel, "/responses")) throwInvalidRequestError("The selected model does not support the responses endpoint.", "model");
 			applyContextManagement(payload, selectedModel.capabilities.limits.max_prompt_tokens);
 			applyResponsesParameterFilters(payload, selectedModel);
+			clampResponsesOutputTokens(payload);
+			clampResponsesReasoningEffort(payload, selectedModel);
 		},
 		buildStrategyContext({ payload, meta, copilotClient, upstreamSignal }) {
 			const { vision, initiator } = getResponsesRequestOptions(payload);
@@ -52733,23 +53106,6 @@ function applyResponsesInputPolicies(payload) {
 	rejectUnsupportedRemoteImageUrls(payload);
 }
 /**
-* Strip `phase` from input message items. The `phase` field is an output
-* annotation that some models may reject when sent back as input.
-*/
-function stripPhaseFromInputMessages(payload) {
-	if (!Array.isArray(payload.input)) return;
-	let stripped = 0;
-	for (const item of payload.input) {
-		if (typeof item !== "object" || item === null) continue;
-		const rec = item;
-		if ((!("type" in rec) || rec.type === "message") && "phase" in rec) {
-			delete rec.phase;
-			stripped++;
-		}
-	}
-	if (stripped > 0) consola.debug(`Stripped phase from ${stripped} input message item(s)`);
-}
-/**
 * Remove input items that Copilot cannot resolve and would trigger 404:
 * - `item_reference` items (opaque IDs from store=true sessions)
 * - `function_call_output` items whose `call_id` has no matching prior
@@ -52822,35 +53178,42 @@ var UpstreamResourceDispatcher = class {
 		return this.client.deleteResponse(responseId, options);
 	}
 };
-function createResourceDispatcher() {
-	return configStore.isEmulatorEnabled() ? new EmulatorResourceDispatcher() : new UpstreamResourceDispatcher(createCopilotClient());
+/**
+* Build the dispatcher backing the `/responses/{id}` resource routes.
+*
+* `client` is an injection seam for tests: pass a stand-in to exercise the
+* upstream path without patching `CopilotClient.prototype`. Production callers
+* omit it and get the configured client.
+*/
+function createResourceDispatcher(client) {
+	return configStore.isEmulatorEnabled() ? new EmulatorResourceDispatcher() : new UpstreamResourceDispatcher(client ?? createCopilotClient());
 }
 //#endregion
 //#region src/routes/responses/resource-handler.ts
-async function handleRetrieveResponseCore({ params, url, headers, signal }) {
+async function handleRetrieveResponseCore({ params, url, headers, signal, client }) {
 	const responseId = requireResponseId(params.responseId);
-	return await createResourceDispatcher().retrieve(responseId, getRetrieveParamsFromUrl(url), {
+	return await createResourceDispatcher(client).retrieve(responseId, getRetrieveParamsFromUrl(url), {
 		requestContext: readCapiRequestContext(headers),
 		signal
 	});
 }
-async function handleListResponseInputItemsCore({ params, url, headers, signal }) {
+async function handleListResponseInputItemsCore({ params, url, headers, signal, client }) {
 	const responseId = requireResponseId(params.responseId);
-	return await createResourceDispatcher().listInputItems(responseId, getInputItemsParamsFromUrl(url), {
+	return await createResourceDispatcher(client).listInputItems(responseId, getInputItemsParamsFromUrl(url), {
 		requestContext: readCapiRequestContext(headers),
 		signal
 	});
 }
-async function handleCreateResponseInputTokensCore({ body, headers, signal }) {
+async function handleCreateResponseInputTokensCore({ body, headers, signal, client }) {
 	const { payload, meta } = protocolRegistry.ingest("responses-input-tokens", body, headers);
-	return await createResourceDispatcher().createInputTokens(payload, {
+	return await createResourceDispatcher(client).createInputTokens(payload, {
 		requestContext: meta.requestContext,
 		signal
 	});
 }
-async function handleDeleteResponseCore({ params, headers, signal }) {
+async function handleDeleteResponseCore({ params, headers, signal, client }) {
 	const responseId = requireResponseId(params.responseId);
-	return await createResourceDispatcher().delete(responseId, {
+	return await createResourceDispatcher(client).delete(responseId, {
 		requestContext: readCapiRequestContext(headers),
 		signal
 	});
@@ -53077,9 +53440,7 @@ async function runServer(options) {
 		baseDelayMs: secondsToMs(upstreamQueueBaseDelaySeconds),
 		maxDelayMs: secondsToMs(upstreamQueueMaxDelaySeconds)
 	});
-	authStore.gheDomain = cachedConfig.gheDomain;
-	if (options.gheDomain !== void 0) authStore.gheDomain = options.gheDomain ? normalizeGheDomain(options.gheDomain) : void 0;
-	if (authStore.gheDomain && authStore.accountType === "individual") authStore.accountType = "enterprise";
+	applyGheDomain(authStore, cachedConfig.gheDomain, options.gheDomain);
 	await cacheVSCodeVersion();
 	if (!options.githubToken) await setupGitHubToken();
 	const tokenCleanup = await setupCopilotToken();
@@ -53194,15 +53555,15 @@ const start = defineCommand({
 		},
 		"upstream-queue-retries": {
 			type: "string",
-			description: "Maximum retries for upstream 429 responses (default: 5)"
+			description: "Maximum retries for transient upstream responses (default: 5)"
 		},
 		"upstream-queue-base-delay": {
 			type: "string",
-			description: "Base delay in seconds for upstream 429 backoff when Retry-After is absent (default: 2)"
+			description: "Base delay in seconds for upstream retry backoff when Retry-After is absent (default: 2)"
 		},
 		"upstream-queue-max-delay": {
 			type: "string",
-			description: "Maximum delay in seconds for upstream 429 backoff (default: 60)"
+			description: "Maximum delay in seconds for upstream retry backoff (default: 60)"
 		},
 		"ghe-domain": {
 			alias: "ghe",