@oh-my-pi/pi-coding-agent 17.2.10 → 17.2.12

package/src/commit/agentic/index.ts

@@ -11,6 +11,7 @@ import { ModelRegistry } from "../../config/model-registry";
 import { Settings } from "../../config/settings";
 import { discoverAuthStorage, discoverContextFiles, loadCliExtensionProviders } from "../../sdk";
 import * as git from "../../utils/git";
+import { abortOnGitFailure, pushOrAbort } from "../execute";
 import { type ExistingChangelogEntries, runCommitAgentSession } from "./agent";
 import { generateFallbackProposal } from "./fallback";
 import { assignLockFilesToPlan } from "./lock-files";
@@ -25,7 +26,7 @@ interface CommitExecutionContext {
 	push: boolean;
 }
 
-export async function runAgenticCommit(args: CommitCommandArgs): Promise<void> {
+export async function runAgenticCommit(args: CommitCommandArgs): Promise<{ usedFallback: boolean }> {
 	const cwd = getProjectDir();
 	const [settings, authStorage] = await Promise.all([Settings.init({ cwd }), discoverAuthStorage()]);
 
@@ -56,8 +57,13 @@ export async function runAgenticCommit(args: CommitCommandArgs): Promise<void> {
 	);
 
 	if (stagedFiles.length === 0) {
+		if (args.push) {
+			process.stdout.write("No changes to commit; pushing existing commits...\n");
+			await pushOrAbort(cwd);
+			return { usedFallback: false };
+		}
 		process.stderr.write("No changes to commit.\n");
-		return;
+		return { usedFallback: false };
 	}
 
 	if (!args.noChangelog) {
@@ -94,7 +100,7 @@ export async function runAgenticCommit(args: CommitCommandArgs): Promise<void> {
 		process.stdout.write("● Forcing fallback commit generation...\n");
 		const fallbackProposal = generateFallbackProposal(numstat);
 		await runSingleCommit(fallbackProposal, { cwd, dryRun: args.dryRun, push: args.push });
-		return;
+		return { usedFallback: true };
 	}
 
 	const trivialChange = detectTrivialChange(diff);
@@ -111,7 +117,7 @@ export async function runAgenticCommit(args: CommitCommandArgs): Promise<void> {
 			warnings: [],
 		};
 		await runSingleCommit(trivialProposal, { cwd, dryRun: args.dryRun, push: args.push });
-		return;
+		return { usedFallback: false };
 	}
 
 	let existingChangelogEntries: ExistingChangelogEntries[] | undefined;
@@ -124,6 +130,7 @@ export async function runAgenticCommit(args: CommitCommandArgs): Promise<void> {
 
 	process.stdout.write("● Starting commit agent...\n");
 	let agentSessionCompleted = false;
+	let usedFallback = false;
 
 	try {
 		await runCommitAgentSession({
@@ -141,7 +148,7 @@ export async function runAgenticCommit(args: CommitCommandArgs): Promise<void> {
 			existingChangelogEntries,
 			onComplete: async commitState => {
 				agentSessionCompleted = true;
-				await completeAgentCommitState(commitState, {
+				usedFallback = await completeAgentCommitState(commitState, {
 					cwd,
 					dryRun: args.dryRun,
 					push: args.push,
@@ -151,7 +158,7 @@ export async function runAgenticCommit(args: CommitCommandArgs): Promise<void> {
 				});
 			},
 		});
-		return;
+		return { usedFallback };
 	} catch (error) {
 		if (agentSessionCompleted) {
 			throw error;
@@ -164,7 +171,7 @@ export async function runAgenticCommit(args: CommitCommandArgs): Promise<void> {
 		process.stdout.write("● Using fallback commit generation...\n");
 		const fallbackProposal = generateFallbackProposal(numstat);
 		await runSingleCommit(fallbackProposal, { cwd, dryRun: args.dryRun, push: args.push });
-		return;
+		return { usedFallback: true };
 	}
 }
 
@@ -175,7 +182,7 @@ async function completeAgentCommitState(
 		changelogTargets: string[];
 		numstat: NumstatEntry[];
 	},
-): Promise<void> {
+): Promise<boolean> {
 	let usedFallback = false;
 	if (!commitState.proposal && !commitState.splitProposal) {
 		if ($env.PI_COMMIT_NO_FALLBACK?.toLowerCase() !== "true") {
@@ -211,7 +218,7 @@ async function completeAgentCommitState(
 
 	if (commitState.proposal) {
 		await runSingleCommit(commitState.proposal, ctx);
-		return;
+		return usedFallback;
 	}
 
 	if (commitState.splitProposal) {
@@ -221,7 +228,7 @@ async function completeAgentCommitState(
 			push: ctx.push,
 			additionalFiles: updatedChangelogFiles,
 		});
-		return;
+		return usedFallback;
 	}
 
 	throw new Error("Commit agent did not provide a proposal.");
@@ -238,12 +245,14 @@ async function runSingleCommit(proposal: CommitProposal, ctx: CommitExecutionCon
 		return;
 	}
 	process.stdout.write("● Creating commit...\n");
-	await git.commit(ctx.cwd, commitMessage);
-	process.stdout.write("Commit created.\n");
-	if (ctx.push) {
-		await git.push(ctx.cwd);
-		process.stdout.write("Pushed to remote.\n");
+	try {
+		await git.commit(ctx.cwd, commitMessage);
+	} catch (error) {
+		if (error instanceof git.GitCommandError) abortOnGitFailure("Commit failed", error);
+		throw error;
 	}
+	process.stdout.write("Commit created.\n");
+	if (ctx.push) await pushOrAbort(ctx.cwd);
 }
 
 async function runSplitCommit(
@@ -296,7 +305,7 @@ async function runSplitCommit(
 	process.stdout.write("● Creating split commits...\n");
 	const stagedDiff = await git.diff(ctx.cwd, { cached: true, binary: true });
 	await git.stage.reset(ctx.cwd);
-	for (const commitIndex of order) {
+	for (const [position, commitIndex] of order.entries()) {
 		const commit = plan.commits[commitIndex];
 		await git.stage.hunks(ctx.cwd, commit.changes, { rawDiff: stagedDiff, diffCached: true });
 		const analysis: ConventionalAnalysis = {
@@ -306,14 +315,23 @@ async function runSplitCommit(
 			issueRefs: commit.issueRefs,
 		};
 		const message = formatCommitMessage(analysis, commit.summary);
-		await git.commit(ctx.cwd, message);
+		try {
+			await git.commit(ctx.cwd, message);
+		} catch (error) {
+			if (error instanceof git.GitCommandError) {
+				const stagedNow = await git.diff.changedFiles(ctx.cwd, { cached: true });
+				abortOnGitFailure(
+					`Commit ${position + 1} of ${order.length} failed`,
+					error,
+					`${position} of ${order.length} commits created; ${stagedNow.length} file(s) remain staged. No changes were lost.`,
+				);
+			}
+			throw error;
+		}
 		await git.stage.reset(ctx.cwd);
 	}
 	process.stdout.write("Split commits created.\n");
-	if (ctx.push) {
-		await git.push(ctx.cwd);
-		process.stdout.write("Pushed to remote.\n");
-	}
+	if (ctx.push) await pushOrAbort(ctx.cwd);
 }
 
 function appendFilesToLastCommit(plan: SplitCommitPlan, files: string[]): void {

package/src/commit/execute.ts

@@ -0,0 +1,56 @@
+/**
+ * Shared commit-execution helpers for the agentic and legacy `omp commit`
+ * pipelines: readable failure reporting for refusing git hooks and a push
+ * wrapper that keeps a requested `--push` honest.
+ */
+
+import * as git from "../utils/git";
+
+/**
+ * A commit or push failure that has already been reported to the user with a
+ * readable message. It is thrown so the CLI exits non-zero without the runtime
+ * dumping a stack trace — in a bundled build that trace is several kilobytes of
+ * minified source, which buries the one line the user needs (issue #7834).
+ *
+ * `runCommitCommand`'s caller (`commands/commit.ts`) maps this to exit code 1.
+ */
+export class CommitAbortedError extends Error {
+	constructor() {
+		super("commit aborted");
+		this.name = "CommitAbortedError";
+	}
+}
+
+/**
+ * Print a git-command failure — most often a `pre-commit`/`commit-msg` hook
+ * that exited non-zero — as an indented message under `context`, then abort.
+ *
+ * @param context Label for the failed step, e.g. `"Commit 1 of 2 failed"`.
+ * @param error The failure to surface; its captured stderr/stdout is shown.
+ * @param note Optional trailing status line (split-plan progress, recovery).
+ */
+export function abortOnGitFailure(context: string, error: git.GitCommandError, note?: string): never {
+	const detail = error.result.stderr.trim() || error.result.stdout.trim() || error.message;
+	const body = detail
+		.split("\n")
+		.map(line => `    ${line}`)
+		.join("\n");
+	process.stderr.write(`✗ ${context}:\n${body}\n`);
+	if (note) process.stderr.write(`  ${note}\n`);
+	throw new CommitAbortedError();
+}
+
+/**
+ * Push the current branch, reporting a refused push (missing upstream, rejected
+ * ref) through {@link abortOnGitFailure} instead of letting the raw
+ * `GitCommandError` escape. Prints the success line on completion.
+ */
+export async function pushOrAbort(cwd: string): Promise<void> {
+	try {
+		await git.push(cwd);
+	} catch (error) {
+		if (error instanceof git.GitCommandError) abortOnGitFailure("Push failed", error);
+		throw error;
+	}
+	process.stdout.write("Pushed to remote.\n");
+}

package/src/commit/index.ts

@@ -2,4 +2,5 @@
  * Entry points for the omp commit command.
  */
 
-export { runCommitCommand } from "./pipeline";
+export * from "./execute";
+export * from "./pipeline";

package/src/commit/pipeline.ts

@@ -16,6 +16,7 @@ import {
 	validateSummary,
 } from "./analysis";
 import { runChangelogFlow } from "./changelog";
+import { abortOnGitFailure, pushOrAbort } from "./execute";
 import { runMapReduceAnalysis, shouldUseMapReduce } from "./map-reduce";
 import { formatCommitMessage } from "./message";
 import { resolvePrimaryModel, resolveSmolModel } from "./model-selection";
@@ -30,10 +31,15 @@ const TYPES_DESCRIPTION = (): string => (typesDescription ??= prompt.render(type
 
 /**
  * Execute the omp commit pipeline for staged changes.
+ *
+ * Returns whether the commit was generated by the mechanical fallback rather
+ * than by the commit agent, so callers can signal a degraded outcome (issue
+ * #7835). The legacy pipeline has no fallback: model failures throw.
  */
-export async function runCommitCommand(args: CommitCommandArgs): Promise<void> {
+export async function runCommitCommand(args: CommitCommandArgs): Promise<{ usedFallback: boolean }> {
 	if (args.legacy) {
-		return runLegacyCommitCommand(args);
+		await runLegacyCommitCommand(args);
+		return { usedFallback: false };
 	}
 	return runAgenticCommit(args);
 }
@@ -65,6 +71,11 @@ async function runLegacyCommitCommand(args: CommitCommandArgs): Promise<void> {
 		stagedFiles = await git.diff.changedFiles(cwd, { cached: true });
 	}
 	if (stagedFiles.length === 0) {
+		if (args.push) {
+			process.stdout.write("No changes to commit; pushing existing commits...\n");
+			await pushOrAbort(cwd);
+			return;
+		}
 		process.stderr.write("No changes to commit.\n");
 		return;
 	}
@@ -130,12 +141,14 @@ async function runLegacyCommitCommand(args: CommitCommandArgs): Promise<void> {
 		return;
 	}
 
-	await git.commit(cwd, commitMessage);
-	process.stdout.write("Commit created.\n");
-	if (args.push) {
-		await git.push(cwd);
-		process.stdout.write("Pushed to remote.\n");
+	try {
+		await git.commit(cwd, commitMessage);
+	} catch (error) {
+		if (error instanceof git.GitCommandError) abortOnGitFailure("Commit failed", error);
+		throw error;
 	}
+	process.stdout.write("Commit created.\n");
+	if (args.push) await pushOrAbort(cwd);
 }
 
 async function generateAnalysis(input: {

package/src/config/custom-models.ts

@@ -0,0 +1,188 @@
+import type { Api, Model, ModelSpec, RemoteCompactionConfig } from "@oh-my-pi/pi-ai/types";
+import { buildModel } from "@oh-my-pi/pi-catalog/build";
+import {
+	getBundledModelReferenceIndex,
+	inheritReferenceThinking,
+	resolveModelReference,
+} from "@oh-my-pi/pi-catalog/identity";
+import { getVariantAliasSources, resolveVariantAlias } from "@oh-my-pi/pi-catalog/variant-collapse";
+import { logger } from "@oh-my-pi/pi-utils";
+import { createLiveConfigHeaders, type HeaderSource } from "./model-config-values";
+import { type ModelPatch, mergeCompat, mergeRemoteCompactionConfig } from "./model-patch";
+import { parseModelString } from "./model-resolver";
+import type { ModelOverride, ProviderAuthMode } from "./models-config-schema";
+export interface CustomModelDefinitionLike extends ModelPatch {
+	id: string;
+	api?: Api;
+	baseUrl?: string;
+	cost?: Model<Api>["cost"];
+}
+
+export interface CustomModelBuildOptions {
+	useDefaults: boolean;
+}
+
+export interface CustomModelOverlay extends ModelPatch {
+	id: string;
+	provider: string;
+	api: Api;
+	baseUrl: string;
+	cost?: Model<Api>["cost"];
+	isOAuth?: boolean;
+}
+
+function mergeCustomModelHeaders(
+	providerHeaders: Record<string, string> | undefined,
+	modelHeaders: Record<string, string> | undefined,
+	authHeader: boolean | undefined,
+	apiKeyConfig: string | undefined,
+): Record<string, string> | undefined {
+	return createLiveConfigHeaders([providerHeaders, modelHeaders], { authHeader, apiKeyConfig });
+}
+
+export function mergeAuthHeaderSources(
+	sources: readonly HeaderSource[],
+	authHeader: boolean | undefined,
+	apiKeyConfig: string | undefined,
+): Record<string, string> | undefined {
+	return createLiveConfigHeaders(sources, { authHeader, apiKeyConfig });
+}
+
+/**
+ * Decide whether a custom-yaml model should force OAuth-style request shaping.
+ * - Explicit `auth: oauth` → force on.
+ *   endpoints are typically Claude-Code-style proxies (e.g. CLIProxyAPI) that expect
+ *   the cloaked request shape regardless of how the proxy itself is authenticated.
+ * - Otherwise → unset.
+ */
+function resolveCustomModelIsOAuth(api: Api, providerAuth: ProviderAuthMode | undefined): boolean | undefined {
+	if (providerAuth === "oauth") return true;
+	if (providerAuth !== undefined) return undefined;
+	if (api === "anthropic-messages") return true;
+	return undefined;
+}
+
+export function buildCustomModelOverlay(
+	providerName: string,
+	providerBaseUrl: string,
+	providerApi: Api | undefined,
+	providerHeaders: Record<string, string> | undefined,
+	providerApiKey: string | undefined,
+	authHeader: boolean | undefined,
+	providerCompat: ModelSpec<Api>["compat"] | undefined,
+	providerAuth: ProviderAuthMode | undefined,
+	providerRemoteCompaction: RemoteCompactionConfig<Api> | undefined,
+	modelDef: CustomModelDefinitionLike,
+): CustomModelOverlay | undefined {
+	const api = modelDef.api ?? providerApi;
+	if (!api) return undefined;
+	return {
+		id: modelDef.id,
+		provider: providerName,
+		api,
+		baseUrl: modelDef.baseUrl ?? providerBaseUrl,
+		name: modelDef.name,
+		reasoning: modelDef.reasoning,
+		thinking: modelDef.thinking,
+		input: modelDef.input,
+		supportsTools: modelDef.supportsTools,
+		cost: modelDef.cost,
+		contextWindow: modelDef.contextWindow,
+		maxTokens: modelDef.maxTokens,
+		omitMaxOutputTokens: modelDef.omitMaxOutputTokens,
+		headers: mergeCustomModelHeaders(providerHeaders, modelDef.headers, authHeader, providerApiKey),
+		compat: mergeCompat(providerCompat, modelDef.compat),
+		contextPromotionTarget: modelDef.contextPromotionTarget,
+		compactionModel: modelDef.compactionModel,
+		remoteCompaction: mergeRemoteCompactionConfig(providerRemoteCompaction, modelDef.remoteCompaction),
+		premiumMultiplier: modelDef.premiumMultiplier,
+		isOAuth: resolveCustomModelIsOAuth(api, providerAuth),
+	};
+}
+
+function applyStandaloneCustomModelPolicies(model: CustomModelOverlay): CustomModelOverlay {
+	if (model.id !== "gpt-5.4" || model.provider === "github-copilot" || model.contextWindow !== undefined) {
+		return model;
+	}
+	return { ...model, contextWindow: 1_000_000 };
+}
+
+export function finalizeCustomModel(model: CustomModelOverlay, options: CustomModelBuildOptions): Model<Api> {
+	const resolvedModel = options.useDefaults ? applyStandaloneCustomModelPolicies(model) : model;
+	const reference = options.useDefaults
+		? resolveModelReference(resolvedModel.id, getBundledModelReferenceIndex())
+		: undefined;
+	const cost =
+		resolvedModel.cost ??
+		reference?.cost ??
+		(options.useDefaults ? { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 } : undefined);
+	const input = resolvedModel.input ?? reference?.input ?? (options.useDefaults ? ["text"] : undefined);
+	const supportsTools = resolvedModel.supportsTools ?? reference?.supportsTools;
+	return buildModel({
+		id: resolvedModel.id,
+		name: resolvedModel.name ?? (options.useDefaults ? resolvedModel.id : undefined),
+		api: resolvedModel.api,
+		provider: resolvedModel.provider,
+		baseUrl: resolvedModel.baseUrl,
+		reasoning: resolvedModel.reasoning ?? reference?.reasoning ?? (options.useDefaults ? false : undefined),
+		thinking: inheritReferenceThinking(resolvedModel.thinking, reference, resolvedModel.provider),
+		input: input as ("text" | "image")[],
+		...(supportsTools !== undefined ? { supportsTools } : {}),
+		cost,
+		contextWindow: resolvedModel.contextWindow ?? reference?.contextWindow ?? (options.useDefaults ? 128000 : null),
+		maxTokens: resolvedModel.maxTokens ?? reference?.maxTokens ?? (options.useDefaults ? 16384 : null),
+		headers: resolvedModel.headers,
+		omitMaxOutputTokens: resolvedModel.omitMaxOutputTokens ?? reference?.omitMaxOutputTokens,
+		compat: mergeCompat(reference?.compatConfig, resolvedModel.compat),
+		contextPromotionTarget: resolvedModel.contextPromotionTarget,
+		compactionModel: resolvedModel.compactionModel,
+		remoteCompaction: resolvedModel.remoteCompaction,
+		premiumMultiplier: resolvedModel.premiumMultiplier,
+		isOAuth: resolvedModel.isOAuth,
+	} as ModelSpec<Api>);
+}
+
+export function normalizeSuppressedSelector(
+	selector: string,
+	hasLiveModel?: (provider: string, id: string) => boolean,
+): string {
+	const trimmed = selector.trim();
+	if (!trimmed) return trimmed;
+	const parsed = parseModelString(trimmed, {
+		allowMaxSuffix: true,
+		allowAutoAlias: true,
+		isLiteralModelId: (provider, id) => hasLiveModel?.(provider, id) === true,
+	});
+	if (!parsed) return trimmed;
+	// Retired effort-tier variant ids normalize to their collapsed logical id
+	// so persisted suppressions keyed by raw member ids still bind.
+	const aliasId = resolveVariantAlias(parsed.provider, parsed.id);
+	return `${parsed.provider}/${aliasId ?? parsed.id}`;
+}
+
+/**
+ * Look up a model's override, falling back to entries keyed by retired
+ * effort-tier variant ids (models.yml authored before collapsing). A raw key
+ * only re-binds when no live model holds that id.
+ */
+export function resolveModelOverrideWithAliases(
+	overrides: Map<string, ModelOverride>,
+	model: Model<Api>,
+	hasLiveModel: (provider: string, id: string) => boolean,
+): ModelOverride | undefined {
+	const direct = overrides.get(model.id);
+	if (direct) return direct;
+	for (const rawId of getVariantAliasSources(model.provider, model.id)) {
+		if (hasLiveModel(model.provider, rawId)) continue;
+		const remapped = overrides.get(rawId);
+		if (remapped) {
+			logger.debug("model override re-keyed through variant alias", {
+				provider: model.provider,
+				from: rawId,
+				to: model.id,
+			});
+			return remapped;
+		}
+	}
+	return undefined;
+}

package/src/config/model-config-values.ts

@@ -0,0 +1,128 @@
+import { execSync } from "node:child_process";
+import { $envExact } from "@oh-my-pi/pi-utils";
+
+const commandValueCache = new Map<string, string>();
+// Failed `!command` resolutions (non-zero exit, empty stdout) are negative-cached
+// with a TTL instead of forever: a transient failure (locked password manager,
+// network hiccup) must not disable the key until process restart, but re-running
+// the command on every resolution would restore the execSync storm this cache
+// exists to prevent. One probe per TTL window bounds both.
+const COMMAND_FAILURE_RETRY_MS = 30_000;
+const commandFailureRetryAt = new Map<string, number>();
+
+export function isCommandConfigValue(valueConfig: string | undefined): valueConfig is string {
+	return valueConfig?.startsWith("!") === true;
+}
+
+function resolveCommandConfig(command: string): string | undefined {
+	const cached = commandValueCache.get(command);
+	if (cached !== undefined) return cached;
+	const retryAt = commandFailureRetryAt.get(command);
+	if (retryAt !== undefined && Date.now() < retryAt) return undefined;
+	try {
+		const stdout = execSync(command, { encoding: "utf8", timeout: 10_000, windowsHide: true });
+		const trimmed = stdout.trim();
+		if (trimmed.length === 0) {
+			commandFailureRetryAt.set(command, Date.now() + COMMAND_FAILURE_RETRY_MS);
+			return undefined;
+		}
+		commandFailureRetryAt.delete(command);
+		commandValueCache.set(command, trimmed);
+		return trimmed;
+	} catch {
+		commandFailureRetryAt.set(command, Date.now() + COMMAND_FAILURE_RETRY_MS);
+		return undefined;
+	}
+}
+
+export interface CommandApiKeyResolution {
+	configured: boolean;
+	value?: string;
+}
+/**
+ * Resolve a models.yml/models.yaml secret/config value to an actual value.
+ * `!cmd` runs a shell command and returns trimmed stdout, otherwise env vars are
+ * checked first and the input falls back to a literal value.
+ */
+export function resolveConfigValue(valueConfig: string): string | undefined {
+	if (valueConfig.startsWith("!")) return resolveCommandConfig(valueConfig.slice(1).trim());
+	const envValue = $envExact(valueConfig);
+	if (envValue) return envValue;
+	return valueConfig;
+}
+
+export type HeaderSource = Record<string, string> | undefined;
+
+interface HeaderResolutionOptions {
+	authHeader?: boolean;
+	apiKeyConfig?: string;
+}
+
+function materializeConfigHeaderSources(
+	sources: readonly HeaderSource[],
+	options?: HeaderResolutionOptions,
+): Record<string, string> | undefined {
+	const resolved: Record<string, string> = {};
+	for (const source of sources) {
+		if (!source) continue;
+		for (const [key, value] of Object.entries(source)) {
+			const next = resolveConfigValue(value);
+			if (next) resolved[key] = next;
+		}
+	}
+	if (options?.authHeader && options.apiKeyConfig) {
+		const resolvedKey = resolveConfigValue(options.apiKeyConfig);
+		if (resolvedKey) resolved.Authorization = `Bearer ${resolvedKey}`;
+	}
+	return Object.keys(resolved).length > 0 ? resolved : undefined;
+}
+
+export function createLiveConfigHeaders(
+	sources: readonly HeaderSource[],
+	options?: HeaderResolutionOptions,
+): Record<string, string> | undefined {
+	const liveSources = sources.filter((source): source is Record<string, string> => source !== undefined);
+	if (liveSources.length === 0 && (!options?.authHeader || !options.apiKeyConfig)) return undefined;
+
+	const localHeaders: Record<string, string> = {};
+	const allSources = [...liveSources, localHeaders];
+	const current = () => materializeConfigHeaderSources(allSources, options) ?? {};
+	return new Proxy(localHeaders, {
+		get(target, property, receiver) {
+			if (typeof property !== "string") return Reflect.get(target, property, receiver);
+			return current()[property];
+		},
+		set(target, property, value) {
+			if (typeof property !== "string" || typeof value !== "string") return false;
+			target[property] = value;
+			return true;
+		},
+		deleteProperty(target, property) {
+			if (typeof property !== "string") return false;
+			delete target[property];
+			return true;
+		},
+		has(_target, property) {
+			if (typeof property !== "string") return false;
+			return Object.hasOwn(current(), property);
+		},
+		ownKeys() {
+			return Reflect.ownKeys(current());
+		},
+		getOwnPropertyDescriptor(_target, property) {
+			if (typeof property !== "string") return undefined;
+			const headers = current();
+			if (!Object.hasOwn(headers, property)) return undefined;
+			return {
+				configurable: true,
+				enumerable: true,
+				value: headers[property],
+				writable: true,
+			};
+		},
+	});
+}
+
+export function resolveConfigHeaders(headers: Record<string, string> | undefined): Record<string, string> | undefined {
+	return materializeConfigHeaderSources([headers]);
+}

package/src/config/model-discovery.ts

@@ -974,8 +974,8 @@ export async function discoverProxyModels(
 		const reference = resolveModelReference(id, getBundledModelReferenceIndex());
 		const discoveryName = typeof item.name === "string" ? item.name.trim() : "";
 		const displayName =
-			reference?.name ??
 			(discoveryName && discoveryName !== id ? discoveryName : undefined) ??
+			reference?.name ??
 			stripBracketedModelIdAffixes(id) ??
 			id;
 		discovered.push(