@oh-my-pi/pi-coding-agent 15.5.15 → 15.7.0

package/src/cli-commands.ts

@@ -17,6 +17,8 @@ export const commands: CommandEntry[] = [
 	{ name: "auth-gateway", load: () => import("./commands/auth-gateway").then(m => m.default) },
 	{ name: "agents", load: () => import("./commands/agents").then(m => m.default) },
 	{ name: "commit", load: () => import("./commands/commit").then(m => m.default) },
+	{ name: "completions", load: () => import("./commands/completions").then(m => m.default) },
+	{ name: "__complete", load: () => import("./commands/complete").then(m => m.default) },
 	{ name: "config", load: () => import("./commands/config").then(m => m.default) },
 	{ name: "grep", load: () => import("./commands/grep").then(m => m.default) },
 	{ name: "grievances", load: () => import("./commands/grievances").then(m => m.default) },
@@ -28,6 +30,7 @@ export const commands: CommandEntry[] = [
 	{ name: "ssh", load: () => import("./commands/ssh").then(m => m.default) },
 	{ name: "stats", load: () => import("./commands/stats").then(m => m.default) },
 	{ name: "update", load: () => import("./commands/update").then(m => m.default) },
+	{ name: "tiny-models", load: () => import("./commands/tiny-models").then(m => m.default) },
 	{ name: "worktree", load: () => import("./commands/worktree").then(m => m.default), aliases: ["wt"] },
 	{ name: "search", load: () => import("./commands/web-search").then(m => m.default), aliases: ["q"] },
 ];

package/src/cli.ts

@@ -1,16 +1,10 @@
 #!/usr/bin/env bun
-import { APP_NAME, MIN_BUN_VERSION, procmgr, VERSION } from "@oh-my-pi/pi-utils";
-
-// Strip macOS malloc-stack-logging env vars before any subprocess is spawned.
-// Otherwise every child bun process (subagents, plugin installs, ptree spawns,
-// etc.) prints a `MallocStackLogging: can't turn off …` warning to stderr.
-procmgr.scrubProcessEnv();
-
 /**
  * CLI entry point — registers all commands explicitly and delegates to the
  * lightweight CLI runner from pi-utils.
  */
 import { type CliConfig, run } from "@oh-my-pi/pi-utils/cli";
+import { APP_NAME, MIN_BUN_VERSION, VERSION } from "@oh-my-pi/pi-utils/dirs";
 import { commands, isSubcommand } from "./cli-commands";
 
 if (Bun.semver.order(Bun.version, MIN_BUN_VERSION) < 0) {
@@ -32,20 +26,20 @@ async function showHelp(config: CliConfig): Promise<void> {
 	}
 }
 /**
- * Smoke-test entry. Spawns the stats sync worker, pings it, exits.
+ * Smoke-test entry. Spawns bundled workers, pings them, exits.
  *
  * Purpose: catch the silent worker-load regressions that hit compiled
- * binaries (issues #1011 and #1027). Neither `--version` nor
- * `stats --summary` actually spawns a Worker on a fresh install — the
- * sync path early-returns when no session files exist. This probe is the
- * minimal end-to-end test that proves `new Worker(...)` resolves and the
- * bundled worker module evaluates successfully. Wired into
- * `scripts/install-tests/run-ci.sh` so binary / source-link / tarball
- * installs all exercise it on every CI run.
+ * binaries (issues #1011 and #1027). Version/help paths do not spawn worker
+ * modules on a fresh install, so this probe is the minimal end-to-end test
+ * that proves `new Worker(...)` resolves and bundled worker modules evaluate.
+ * Wired into `scripts/install-tests/run-ci.sh` so binary / source-link /
+ * tarball installs all exercise it on every CI run.
  */
 async function runSmokeTest(): Promise<void> {
 	const { smokeTestSyncWorker } = await import("@oh-my-pi/omp-stats");
+	const { smokeTestTinyTitleWorker } = await import("./tiny/title-client");
 	await smokeTestSyncWorker();
+	await smokeTestTinyTitleWorker();
 	process.stdout.write("smoke-test: ok\n");
 }
 

package/src/commands/complete.ts

@@ -0,0 +1,66 @@
+/**
+ * `omp __complete <kind> [-- <prefix>]` — dynamic completion candidates.
+ *
+ * Hidden helper invoked by the generated shell completion scripts to resolve
+ * values that can't be baked into the script: the live model catalog and
+ * on-disk sessions. Output is one `value\tdescription` line per candidate
+ * (tab-separated); shells that show descriptions parse the tab, bash uses the
+ * first field. The import surface is kept deliberately narrow so a TAB press
+ * doesn't pay for the full agent boot.
+ */
+import { type GeneratedProvider, getBundledModels, getBundledProviders } from "@oh-my-pi/pi-ai/models";
+import { Command } from "@oh-my-pi/pi-utils/cli";
+import { SessionManager } from "../session/session-manager";
+
+export default class Complete extends Command {
+	static hidden = true;
+	static strict = false;
+
+	async run(): Promise<void> {
+		const argv = this.argv.filter(token => token !== "--");
+		const kind = argv[0];
+		const prefix = argv.length > 1 ? argv[argv.length - 1] : "";
+		if (kind === "models") {
+			completeModels(prefix);
+		} else if (kind === "sessions") {
+			await completeSessions(prefix);
+		}
+	}
+}
+
+/** Strip control chars that would corrupt the tab-separated line protocol. */
+function clean(text: string): string {
+	return text.replace(/[\t\r\n]+/g, " ").trim();
+}
+
+function completeModels(prefix: string): void {
+	const needle = prefix.toLowerCase();
+	const seen = new Set<string>();
+	const lines: string[] = [];
+	for (const provider of getBundledProviders()) {
+		for (const model of getBundledModels(provider as GeneratedProvider)) {
+			// Offer both the fully-qualified `provider/id` and the bare `id`
+			// (matches the fuzzy resolution `--model` accepts).
+			const candidates = [`${model.provider}/${model.id}`, model.id];
+			for (const candidate of candidates) {
+				if (seen.has(candidate)) continue;
+				seen.add(candidate);
+				if (needle && !candidate.toLowerCase().includes(needle)) continue;
+				lines.push(`${candidate}\t${model.provider}`);
+			}
+		}
+	}
+	lines.sort();
+	if (lines.length > 0) process.stdout.write(`${lines.join("\n")}\n`);
+}
+
+async function completeSessions(prefix: string): Promise<void> {
+	const sessions = await SessionManager.list(process.cwd());
+	const lines: string[] = [];
+	for (const session of sessions) {
+		if (prefix && !session.id.startsWith(prefix)) continue;
+		const label = clean(session.title ?? session.firstMessage ?? "").slice(0, 72);
+		lines.push(`${session.id}\t${label}`);
+	}
+	if (lines.length > 0) process.stdout.write(`${lines.join("\n")}\n`);
+}

package/src/commands/completions.ts

@@ -0,0 +1,60 @@
+/**
+ * `omp completions <bash|zsh|fish>` — print a shell completion script.
+ *
+ * The script is derived entirely from the declarative command/flag metadata
+ * (see `cli/completion-gen.ts`), so it never drifts from the actual CLI surface.
+ */
+import { APP_NAME, VERSION } from "@oh-my-pi/pi-utils";
+import { Args, type CliConfig, Command, type CommandCtor } from "@oh-my-pi/pi-utils/cli";
+import { buildSpec, generateCompletion, type Shell } from "../cli/completion-gen";
+import { commands } from "../cli-commands";
+
+/** Entry name of the default command whose flags become top-level completions. */
+const ROOT_COMMAND = "launch";
+const SHELLS = ["bash", "zsh", "fish"] as const;
+
+export default class Completions extends Command {
+	static description = "Print a shell completion script (bash, zsh, or fish)";
+
+	static args = {
+		shell: Args.string({
+			description: "Target shell",
+			required: true,
+			options: SHELLS,
+		}),
+	};
+
+	static examples = [
+		`# zsh — eval at startup, or write to a file in $fpath\n  eval "$(${APP_NAME} completions zsh)"`,
+		`# bash\n  eval "$(${APP_NAME} completions bash)"`,
+		`# fish\n  ${APP_NAME} completions fish > ~/.config/fish/completions/${APP_NAME}.fish`,
+	];
+
+	async run(): Promise<void> {
+		const shell = this.argv[0];
+		if (!isShell(shell)) {
+			process.stderr.write(`Usage: ${APP_NAME} completions <${SHELLS.join("|")}>\n`);
+			process.exitCode = 1;
+			return;
+		}
+
+		// Load every command class so we can read its static flag/arg descriptors,
+		// and collect aliases from both the registration table and the class.
+		const loaded = await Promise.all(commands.map(async entry => ({ entry, Cmd: await entry.load() })));
+		const map = new Map<string, CommandCtor>();
+		const aliasMap = new Map<string, readonly string[]>();
+		for (const { entry, Cmd } of loaded) {
+			map.set(entry.name, Cmd);
+			const merged = new Set<string>([...(Cmd.aliases ?? []), ...(entry.aliases ?? [])]);
+			aliasMap.set(entry.name, [...merged]);
+		}
+
+		const config: CliConfig = { bin: APP_NAME, version: VERSION, commands: map };
+		const spec = buildSpec(config, ROOT_COMMAND, aliasMap);
+		process.stdout.write(generateCompletion(shell, spec));
+	}
+}
+
+function isShell(value: string | undefined): value is Shell {
+	return value === "bash" || value === "zsh" || value === "fish";
+}

package/src/commands/setup.ts

@@ -1,18 +1,39 @@
 /**
- * Install dependencies for optional features.
+ * Run onboarding setup or install dependencies for optional features.
  */
 import { Args, Command, Flags, renderCommandHelp } from "@oh-my-pi/pi-utils/cli";
+import { parseArgs } from "../cli/args";
 import { runSetupCommand, type SetupCommandArgs, type SetupComponent } from "../cli/setup-cli";
+import { runRootCommand } from "../main";
 import { initTheme } from "../modes/theme/theme";
 
 const COMPONENTS: SetupComponent[] = ["python", "stt"];
 
+export interface OnboardingSetupDependencies {
+	runRoot?: typeof runRootCommand;
+	stdinIsTTY?: boolean;
+	stdoutIsTTY?: boolean;
+	writeStderr?: (text: string) => void;
+	exit?: (code: number) => never;
+}
+
+export async function runOnboardingSetup(deps: OnboardingSetupDependencies = {}): Promise<void> {
+	const stdinIsTTY = deps.stdinIsTTY ?? process.stdin.isTTY;
+	const stdoutIsTTY = deps.stdoutIsTTY ?? process.stdout.isTTY;
+	if (!stdinIsTTY || !stdoutIsTTY) {
+		(deps.writeStderr ?? (text => process.stderr.write(text)))("omp setup requires an interactive TTY.\n");
+		(deps.exit ?? process.exit)(1);
+		return;
+	}
+	await (deps.runRoot ?? runRootCommand)(parseArgs([]), [], { forceSetupWizard: true });
+}
+
 export default class Setup extends Command {
-	static description = "Install dependencies for optional features";
+	static description = "Run onboarding setup or install dependencies for optional features";
 
 	static args = {
 		component: Args.string({
-			description: "Component to install",
+			description: "Optional component to install",
 			required: false,
 			options: COMPONENTS,
 		}),
@@ -26,7 +47,11 @@ export default class Setup extends Command {
 	async run(): Promise<void> {
 		const { args, flags } = await this.parse(Setup);
 		if (!args.component) {
-			renderCommandHelp("omp", "setup", Setup);
+			if (flags.check || flags.json) {
+				renderCommandHelp("omp", "setup", Setup);
+				return;
+			}
+			await runOnboardingSetup();
 			return;
 		}
 		const cmd: SetupCommandArgs = {

package/src/commands/tiny-models.ts

@@ -0,0 +1,36 @@
+import { Args, Command, Flags } from "@oh-my-pi/pi-utils/cli";
+import { runTinyModelsCommand, type TinyModelsAction, type TinyModelsCommandArgs } from "../cli/tiny-models-cli";
+
+const ACTIONS: TinyModelsAction[] = ["download", "list"];
+
+export default class TinyModels extends Command {
+	static description = "Download tiny local models (session titles + memory)";
+
+	static args = {
+		action: Args.string({
+			description: "Action to perform",
+			required: false,
+			options: ACTIONS,
+		}),
+		model: Args.string({
+			description: "Model key, or all",
+			required: false,
+		}),
+	};
+
+	static flags = {
+		json: Flags.boolean({ description: "Output JSON" }),
+	};
+
+	async run(): Promise<void> {
+		const { args, flags } = await this.parse(TinyModels);
+		const command: TinyModelsCommandArgs = {
+			action: (args.action ?? "download") as TinyModelsAction,
+			model: args.model,
+			flags: {
+				json: flags.json,
+			},
+		};
+		await runTinyModelsCommand(command);
+	}
+}

package/src/config/model-equivalence.ts

@@ -1,4 +1,9 @@
 import { type Api, getBundledModels, getBundledProviders, type Model } from "@oh-my-pi/pi-ai";
+import {
+	getBracketStrippedModelIdCandidates,
+	getLongestModelLikeIdSegment,
+	getModelLikeIdSegments,
+} from "./model-id-affixes";
 
 export type CanonicalModelSource = "override" | "bundled" | "heuristic" | "fallback";
 
@@ -29,6 +34,7 @@ export interface CanonicalModelIndex {
 interface CanonicalReferenceData {
 	references: Map<string, Model<Api>>;
 	officialIds: Set<string>;
+	suffixAliases: Map<string, string>;
 }
 
 interface CompiledEquivalenceConfig {
@@ -70,6 +76,26 @@ function shouldReplaceReference(existing: Model<Api> | undefined, candidate: Mod
 	return existing.provider !== "openai" && candidate.provider === "openai";
 }
 
+function buildCanonicalSuffixAliasMap(references: ReadonlyMap<string, Model<Api>>): Map<string, string> {
+	const aliases = new Map<string, string>();
+	for (const reference of references.values()) {
+		const slashIndex = reference.id.lastIndexOf("/");
+		if (slashIndex === -1) {
+			continue;
+		}
+		const suffix = reference.id.slice(slashIndex + 1);
+		const alias = getLongestModelLikeIdSegment(suffix);
+		if (!alias) {
+			continue;
+		}
+		const existing = aliases.get(alias);
+		if (!existing || compareCandidatePreference(reference.id, existing) < 0) {
+			aliases.set(alias, reference.id);
+		}
+	}
+	return new Map([...aliases.entries()].map(([alias, referenceId]) => [normalizeCanonicalIdKey(alias), referenceId]));
+}
+
 function createCanonicalReferenceData(): CanonicalReferenceData {
 	if (referenceDataCache) {
 		return referenceDataCache;
@@ -85,9 +111,11 @@ function createCanonicalReferenceData(): CanonicalReferenceData {
 		}
 	}
 	const officialIds = new Set(references.keys());
+	const suffixAliases = buildCanonicalSuffixAliasMap(references);
 	referenceDataCache = {
 		references: Object.freeze(references) as Map<string, Model<Api>>,
 		officialIds: Object.freeze(officialIds) as Set<string>,
+		suffixAliases: Object.freeze(suffixAliases) as Map<string, string>,
 	};
 	return referenceDataCache;
 }
@@ -590,6 +618,13 @@ function expandHeavyCanonicalCandidates(normalized: string, queue: string[]): vo
 		queue.push(wrapperCandidate);
 	}
 
+	for (const strippedAffixCandidate of getBracketStrippedModelIdCandidates(normalized)) {
+		queue.push(strippedAffixCandidate);
+	}
+	for (const segment of getModelLikeIdSegments(normalized)) {
+		queue.push(segment);
+	}
+
 	const strippedSyntheticPrefix = stripSyntheticPrefix(normalized);
 	if (strippedSyntheticPrefix) {
 		queue.push(strippedSyntheticPrefix);
@@ -718,9 +753,15 @@ function resolveCanonicalIdForModel(
 	}
 
 	const heuristicCandidates = getHeuristicCanonicalCandidates(model.id, referenceData.officialIds);
-	const officialMatches = heuristicCandidates.filter(candidate => referenceData.officialIds.has(candidate));
+	const officialMatches = new Set(heuristicCandidates.filter(candidate => referenceData.officialIds.has(candidate)));
+	for (const candidate of heuristicCandidates) {
+		const aliased = referenceData.suffixAliases.get(normalizeCanonicalIdKey(candidate));
+		if (aliased) {
+			officialMatches.add(aliased);
+		}
+	}
 	const preferredFallback = getPreferredFallbackCanonicalCandidate(model.id, heuristicCandidates);
-	const match = selectBestOfficialCandidate(officialMatches);
+	const match = selectBestOfficialCandidate([...officialMatches]);
 	if (match) {
 		if (
 			preferredFallback &&

package/src/config/model-id-affixes.ts

@@ -0,0 +1,64 @@
+const LEADING_BRACKETED_AFFIX_PATTERN = /^(?:\s*(?:\[|【)[^\]】]+(?:\]|】)\s*)+/u;
+const TRAILING_BRACKETED_AFFIX_PATTERN = /(?:\s*(?:\[|【)[^\]】]+(?:\]|】)\s*)+$/u;
+const MODEL_ID_SEGMENT_PATTERN = /[a-z0-9.:-]+/g;
+const MODEL_FAMILY_PREFIX_PATTERN =
+	/^(claude|gemini|gpt|grok|glm|qwen|deepseek|kimi|mimo|doubao|ernie|gpt-oss|gemma|minimax|step|command|jamba|llama|o[1345])/i;
+
+function hasDigit(value: string): boolean {
+	return /\d/.test(value);
+}
+
+function compareSegmentPreference(left: string, right: string): number {
+	if (left.length !== right.length) {
+		return right.length - left.length;
+	}
+	return left.localeCompare(right);
+}
+
+export function getModelLikeIdSegments(modelId: string): string[] {
+	const normalized = normalizeModelIdWhitespace(modelId).toLowerCase();
+	if (!normalized) return [];
+	const segments = (normalized.match(MODEL_ID_SEGMENT_PATTERN) ?? []).filter(
+		segment => MODEL_FAMILY_PREFIX_PATTERN.test(segment) && hasDigit(segment),
+	);
+	const unique = [...new Set(segments)];
+	unique.sort(compareSegmentPreference);
+	return unique;
+}
+
+export function getLongestModelLikeIdSegment(modelId: string): string | undefined {
+	return getModelLikeIdSegments(modelId)[0];
+}
+
+function normalizeModelIdWhitespace(value: string): string {
+	return value.trim().replace(/\s+/g, " ");
+}
+
+/**
+ * Strip reseller / wrapper tags that are injected as bracketed affixes around an
+ * upstream model id, e.g.
+ *   "[Kiro] claude-opus-4-8"                -> "claude-opus-4-8"
+ *   "[gcli转] gemini-3.1-pro-preview [假流]" -> "gemini-3.1-pro-preview"
+ */
+export function getBracketStrippedModelIdCandidates(modelId: string): string[] {
+	const normalized = normalizeModelIdWhitespace(modelId);
+	if (!normalized) return [];
+
+	const candidates = new Set<string>();
+	const withoutLeading = normalizeModelIdWhitespace(normalized.replace(LEADING_BRACKETED_AFFIX_PATTERN, ""));
+	const withoutTrailing = normalizeModelIdWhitespace(normalized.replace(TRAILING_BRACKETED_AFFIX_PATTERN, ""));
+	const withoutBoth = normalizeModelIdWhitespace(
+		normalized.replace(LEADING_BRACKETED_AFFIX_PATTERN, "").replace(TRAILING_BRACKETED_AFFIX_PATTERN, ""),
+	);
+
+	for (const candidate of [withoutBoth, withoutLeading, withoutTrailing]) {
+		if (candidate && candidate !== normalized) {
+			candidates.add(candidate);
+		}
+	}
+	return [...candidates];
+}
+
+export function stripBracketedModelIdAffixes(modelId: string): string | undefined {
+	return getBracketStrippedModelIdCandidates(modelId)[0];
+}

package/src/config/model-registry.ts

@@ -42,6 +42,12 @@ import {
 	formatCanonicalVariantSelector,
 	type ModelEquivalenceConfig,
 } from "./model-equivalence";
+import {
+	getBracketStrippedModelIdCandidates,
+	getLongestModelLikeIdSegment,
+	getModelLikeIdSegments,
+	stripBracketedModelIdAffixes,
+} from "./model-id-affixes";
 import {
 	type ModelOverride,
 	type ModelsConfig,
@@ -650,20 +656,53 @@ function shouldReplaceCustomReference(existing: Model<Api> | undefined, candidat
 	return existing.provider !== "openai" && candidate.provider === "openai";
 }
 
+function normalizeCustomReferenceKey(value: string): string {
+	return value.trim().toLowerCase();
+}
+
 function buildCustomReferenceMap(): Map<string, Model<Api>> {
 	const references = new Map<string, Model<Api>>();
 	for (const provider of getBundledProviders()) {
 		for (const model of getBundledModels(provider as Parameters<typeof getBundledModels>[0])) {
 			const candidate = model as Model<Api>;
-			if (shouldReplaceCustomReference(references.get(candidate.id), candidate)) {
-				references.set(candidate.id, candidate);
+			const key = normalizeCustomReferenceKey(candidate.id);
+			if (shouldReplaceCustomReference(references.get(key), candidate)) {
+				references.set(key, candidate);
 			}
 		}
 	}
 	return references;
 }
 
+function buildCustomReferenceSuffixAliasMap(exactReferences: ReadonlyMap<string, Model<Api>>): Map<string, Model<Api>> {
+	const aliases = new Map<string, Model<Api>>();
+	for (const reference of exactReferences.values()) {
+		const slashIndex = reference.id.lastIndexOf("/");
+		if (slashIndex === -1) {
+			continue;
+		}
+		const suffix = reference.id.slice(slashIndex + 1);
+		const alias = getLongestModelLikeIdSegment(suffix);
+		if (!alias) {
+			continue;
+		}
+		if (shouldReplaceCustomReference(aliases.get(alias), reference)) {
+			aliases.set(alias, reference);
+		}
+	}
+	return aliases;
+}
+
 const customReferenceMap = buildCustomReferenceMap();
+const customReferenceSuffixAliasMap = buildCustomReferenceSuffixAliasMap(customReferenceMap);
+
+const CUSTOM_REFERENCE_TRAILING_MARKER_PATTERN =
+	/[-:](?:thinking|customtools|high|low|medium|minimal|xhigh|free|cloud|exacto|nitro|original|optimized|nvfp4|fp8|fp4|bf16|int8|int4|search)$/i;
+
+function stripCustomReferenceTrailingMarker(candidate: string): string | undefined {
+	const match = CUSTOM_REFERENCE_TRAILING_MARKER_PATTERN.exec(candidate);
+	return match ? candidate.slice(0, match.index) : undefined;
+}
 
 function getCustomReferenceCandidateIds(modelId: string): string[] {
 	const candidates = new Set<string>();
@@ -673,23 +712,46 @@ function getCustomReferenceCandidateIds(modelId: string): string[] {
 		if (!candidate || candidates.has(candidate)) continue;
 		candidates.add(candidate);
 
+		for (const stripped of getBracketStrippedModelIdCandidates(candidate)) {
+			queue.push(stripped);
+		}
+		for (const segment of getModelLikeIdSegments(candidate)) {
+			queue.push(segment);
+		}
+
 		for (const suffix of [":cloud", "-cloud"] as const) {
 			if (candidate.toLowerCase().endsWith(suffix)) {
 				queue.push(candidate.slice(0, -suffix.length));
 			}
 		}
 
+		const slashIndex = candidate.lastIndexOf("/");
+		if (slashIndex !== -1) {
+			queue.push(candidate.slice(slashIndex + 1));
+		}
+
 		const colonToDash = candidate.replace(/:/g, "-");
 		if (colonToDash !== candidate) {
 			queue.push(colonToDash);
 		}
+
+		const lowercased = candidate.toLowerCase();
+		if (lowercased !== candidate) {
+			queue.push(lowercased);
+		}
+
+		const strippedMarker = stripCustomReferenceTrailingMarker(candidate);
+		if (strippedMarker) {
+			queue.push(strippedMarker);
+		}
 	}
 	return [...candidates];
 }
 
 function resolveCustomModelReference(modelId: string): Model<Api> | undefined {
 	for (const candidate of getCustomReferenceCandidateIds(modelId)) {
-		const reference = customReferenceMap.get(candidate);
+		const key = normalizeCustomReferenceKey(candidate);
+		const reference = customReferenceMap.get(key) ?? customReferenceSuffixAliasMap.get(key);
 		if (reference) return reference;
 	}
 	return undefined;
@@ -1785,7 +1847,7 @@ export class ModelRegistry {
 			throw new Error(`HTTP ${response.status} from ${modelsUrl}`);
 		}
 		const payload = (await response.json()) as {
-			data?: Array<{ id?: string; supported_endpoint_types?: string[] }>;
+			data?: Array<{ id?: string; name?: string; supported_endpoint_types?: string[] }>;
 		};
 		const items = payload.data ?? [];
 		const discovered: Model<Api>[] = [];
@@ -1800,23 +1862,35 @@ export class ModelRegistry {
 					: providerConfig.api;
 			if (!api) continue;
 			const isAnthropic = api === "anthropic-messages";
+			const reference = resolveCustomModelReference(id);
+			const discoveryName = typeof item.name === "string" ? item.name.trim() : "";
+			const displayName =
+				reference?.name ??
+				(discoveryName && discoveryName !== id ? discoveryName : undefined) ??
+				stripBracketedModelIdAffixes(id) ??
+				id;
 			discovered.push(
 				enrichModelThinking({
 					id,
-					name: id,
+					name: displayName,
 					api,
 					provider: providerConfig.provider,
 					baseUrl,
-					reasoning: false,
-					input: ["text"],
+					reasoning: reference?.reasoning ?? false,
+					thinking: reference?.thinking,
+					input: reference?.input ?? ["text"],
+					// Proxy pricing is provider-specific and usually does not match
+					// upstream bundled catalogs, so keep costs local-unknown even when
+					// we successfully recover the upstream model identity.
 					cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-					contextWindow: 128000,
-					maxTokens: 8192,
+					contextWindow: reference?.contextWindow ?? 128000,
+					maxTokens: reference?.maxTokens ?? 8192,
 					headers,
 					// OpenAI-compat fields are no-ops on anthropic models; the
 					// Anthropic SDK ignores them. Provider-level disableStrictTools
 					// flows in via #applyProviderCompat for the third-party-Anthropic
-					// path.
+					// path. Cross-wire bundled compat is intentionally not copied:
+					// request-shaping fields are provider-wire specific.
 					compat: isAnthropic
 						? undefined
 						: {