@sayknow-cli/coding-agent 0.5.1 → 0.5.6

package/src/config/atomic-yaml-patch.ts

@@ -93,7 +93,31 @@ export class AtomicYamlReplaceError extends Error {
 		this.name = "AtomicYamlReplaceError";
 	}
 }
+/** Raised when the configured lexical route no longer resolves to its original target. */
+export class AtomicYamlRetargetError extends Error {
+	readonly code = "ATOMIC_YAML_RETARGETED";
 
+	constructor() {
+		super("Atomic YAML configuration target changed before publication.");
+		this.name = "AtomicYamlRetargetError";
+	}
+}
+
+/** Test-only coordination hooks for deterministic target-authority races. */
+export const AtomicYamlTestHooks: {
+	afterTargetBound?: (canonicalPath: string) => Promise<void> | void;
+} = {};
+
+type AtomicYamlTargetIdentity = {
+	device: bigint;
+	inode: bigint;
+};
+
+type AtomicYamlTarget = {
+	canonicalPath: string;
+	resolvedPath: string;
+	identity: AtomicYamlTargetIdentity | undefined;
+};
 type PathState = { exists: boolean; value: unknown };
 type ReceiptChange = {
 	path: string;
@@ -103,6 +127,7 @@ type ReceiptChange = {
 };
 
 const queues = new Map<string, Promise<void>>();
+const trustedQueuedTargets = new Map<string, AtomicYamlTarget>();
 let nextReceiptRevision = 0;
 /** Bounded Windows sharing-violation retries: 10, 25, 50, 100, then 200 ms. */
 const WINDOWS_RENAME_BACKOFF_MS = [10, 25, 50, 100, 200] as const;
@@ -112,6 +137,80 @@ function canonicalConfigPath(configPath: string): string {
 	return path.normalize(path.resolve(configPath));
 }
 
+async function resolveMissingAtomicYamlPath(inputPath: string): Promise<string> {
+	let unresolvedPath = inputPath;
+	const missingSegments: string[] = [];
+	for (;;) {
+		try {
+			return path.join(await fs.realpath(unresolvedPath), ...missingSegments.reverse());
+		} catch (error) {
+			if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+			const parent = path.dirname(unresolvedPath);
+			if (parent === unresolvedPath) throw error;
+			missingSegments.push(path.basename(unresolvedPath));
+			unresolvedPath = parent;
+		}
+	}
+}
+
+async function resolveAtomicYamlTargetPath(inputPath: string, depth = 0): Promise<string> {
+	const canonicalPath = canonicalConfigPath(inputPath);
+	try {
+		return await fs.realpath(canonicalPath);
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+	}
+	try {
+		const metadata = await fs.lstat(canonicalPath);
+		if (metadata.isSymbolicLink()) {
+			if (depth >= 32) throw new AtomicYamlRetargetError();
+			const linkedPath = await fs.readlink(canonicalPath);
+			const targetPath = path.isAbsolute(linkedPath)
+				? linkedPath
+				: path.resolve(path.dirname(canonicalPath), linkedPath);
+			return await resolveAtomicYamlTargetPath(targetPath, depth + 1);
+		}
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+	}
+	return await resolveMissingAtomicYamlPath(canonicalPath);
+}
+
+async function readAtomicYamlTargetIdentity(resolvedPath: string): Promise<AtomicYamlTargetIdentity | undefined> {
+	try {
+		const metadata = await fs.stat(resolvedPath, { bigint: true });
+		return { device: metadata.dev, inode: metadata.ino };
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException).code === "ENOENT") return undefined;
+		throw error;
+	}
+}
+
+async function resolveAtomicYamlTarget(configPath: string): Promise<AtomicYamlTarget> {
+	const canonicalPath = canonicalConfigPath(configPath);
+	const resolvedPath = await resolveAtomicYamlTargetPath(canonicalPath);
+	return {
+		canonicalPath,
+		resolvedPath,
+		identity: await readAtomicYamlTargetIdentity(resolvedPath),
+	};
+}
+
+function sameAtomicYamlIdentity(
+	left: AtomicYamlTargetIdentity | undefined,
+	right: AtomicYamlTargetIdentity | undefined,
+): boolean {
+	if (!left || !right) return left === right;
+	return left.device === right.device && left.inode === right.inode;
+}
+
+async function assertAtomicYamlTarget(target: AtomicYamlTarget): Promise<void> {
+	const current = await resolveAtomicYamlTarget(target.canonicalPath);
+	if (current.resolvedPath !== target.resolvedPath || !sameAtomicYamlIdentity(current.identity, target.identity)) {
+		throw new AtomicYamlRetargetError();
+	}
+}
+
 function assertPatch(patch: AtomicYamlPatch): void {
 	if (
 		!patch ||
@@ -266,12 +365,12 @@ async function replaceWithRetry(tempPath: string, configPath: string, options: A
 }
 
 async function writeAtomicYaml(
-	configPath: string,
+	target: AtomicYamlTarget,
 	value: Record<string, unknown>,
 	options: AtomicYamlPatchOptions,
 ): Promise<void> {
-	const directory = path.dirname(configPath);
-	const tempPath = path.join(directory, `.${path.basename(configPath)}.${process.pid}.${randomUUID()}.tmp`);
+	const directory = path.dirname(target.resolvedPath);
+	const tempPath = path.join(directory, `.${path.basename(target.resolvedPath)}.${process.pid}.${randomUUID()}.tmp`);
 	try {
 		const tempHandle = await fs.open(tempPath, "wx", 0o600);
 		try {
@@ -280,8 +379,12 @@ async function writeAtomicYaml(
 		} finally {
 			await tempHandle.close();
 		}
-		await replaceWithRetry(tempPath, configPath, options);
+		await assertAtomicYamlTarget(target);
+		await replaceWithRetry(tempPath, target.resolvedPath, options);
 		await syncParentDirectory(directory);
+		const publishedTarget = await resolveAtomicYamlTarget(target.canonicalPath);
+		if (publishedTarget.resolvedPath !== target.resolvedPath) throw new AtomicYamlRetargetError();
+		target.identity = publishedTarget.identity;
 	} finally {
 		await fs.rm(tempPath, { force: true }).catch(() => undefined);
 	}
@@ -302,10 +405,12 @@ function createReceipt(
 		},
 		async restore(): Promise<CasRestoreResult> {
 			if (discarded) return { status: "discarded" };
-			return await enqueueAtomicYamlOperation(configPath, async canonicalPath => {
+			return await enqueueAtomicYamlOperation(configPath, async (_canonicalPath, target) => {
 				if (discarded) return { status: "discarded" };
-				return await withFileLock(canonicalPath, async () => {
-					const { current, root } = await readYaml(canonicalPath);
+				await assertAtomicYamlTarget(target);
+				return await withFileLock(target.resolvedPath, async () => {
+					await assertAtomicYamlTarget(target);
+					const { current, root } = await readYaml(target.resolvedPath);
 					const conflicts = changes
 						.filter(
 							change =>
@@ -320,7 +425,7 @@ function createReceipt(
 							: { path: change.path, op: "unset" },
 					);
 					await options.validateRoot?.(root, restorePatches);
-					const receipt = await applyPatchesUnderLock(canonicalPath, current, restorePatches, options);
+					const receipt = await applyPatchesUnderLock(target, current, restorePatches, options);
 					await options.onRestored?.(restorePatches);
 					return { status: "restored", receipt };
 				});
@@ -330,12 +435,12 @@ function createReceipt(
 }
 
 async function applyPatchesUnderLock(
-	configPath: string,
+	target: AtomicYamlTarget,
 	current: Record<string, unknown>,
 	patches: readonly AtomicYamlPatch[],
 	options: AtomicYamlPatchOptions,
 ): Promise<CasReceipt> {
-	if (patches.length === 0) return createReceipt(configPath, [], options);
+	if (patches.length === 0) return createReceipt(target.canonicalPath, [], options);
 
 	for (const patch of patches) {
 		if (!patch.expected) continue;
@@ -373,8 +478,8 @@ async function applyPatchesUnderLock(
 	}
 	const changes = [...changesByPath.values()];
 
-	await writeAtomicYaml(configPath, current, options);
-	return createReceipt(configPath, changes, options);
+	await writeAtomicYaml(target, current, options);
+	return createReceipt(target.canonicalPath, changes, options);
 }
 
 /** Build patches from current durable YAML while holding the shared queue and file lock. */
@@ -385,14 +490,17 @@ export function applyAtomicYamlPatchesWithCurrent(
 	) => Promise<readonly AtomicYamlPatch[]> | readonly AtomicYamlPatch[],
 	options: AtomicYamlPatchOptions = {},
 ): Promise<CasReceipt> {
-	return enqueueAtomicYamlOperation(configPath, async canonicalPath => {
-		await fs.mkdir(path.dirname(canonicalPath), { recursive: true, mode: 0o700 });
-		return await withFileLock(canonicalPath, async () => {
-			const { current, root } = await readYaml(canonicalPath);
+	return enqueueAtomicYamlOperation(configPath, async (_canonicalPath, target) => {
+		await assertAtomicYamlTarget(target);
+		await fs.mkdir(path.dirname(target.resolvedPath), { recursive: true, mode: 0o700 });
+		await assertAtomicYamlTarget(target);
+		return await withFileLock(target.resolvedPath, async () => {
+			await assertAtomicYamlTarget(target);
+			const { current, root } = await readYaml(target.resolvedPath);
 			const patches = await buildPatches(current);
 			for (const patch of patches) assertPatch(patch);
 			await options.validateRoot?.(root, patches);
-			return await applyPatchesUnderLock(canonicalPath, current, patches, options);
+			return await applyPatchesUnderLock(target, current, patches, options);
 		});
 	});
 }
@@ -404,18 +512,41 @@ export function applyAtomicYamlPatchesWithCurrent(
  */
 export function enqueueAtomicYamlOperation<T>(
 	configPath: string,
-	operation: (canonicalConfigPath: string) => Promise<T>,
+	operation: (canonicalConfigPath: string, target: AtomicYamlTarget) => Promise<T>,
 ): Promise<T> {
 	const canonicalPath = canonicalConfigPath(configPath);
 	const prior = queues.get(canonicalPath) ?? Promise.resolve();
-	const result = prior.catch(() => undefined).then(() => operation(canonicalPath));
+	const targetAtEnqueue = resolveAtomicYamlTarget(canonicalPath).then(async target => {
+		await AtomicYamlTestHooks.afterTargetBound?.(canonicalPath);
+		return target;
+	});
+	const result = prior
+		.catch(() => undefined)
+		.then(async () => {
+			const target = await targetAtEnqueue;
+			const current = await resolveAtomicYamlTarget(canonicalPath);
+			if (
+				current.resolvedPath !== target.resolvedPath ||
+				(!sameAtomicYamlIdentity(current.identity, target.identity) &&
+					!sameAtomicYamlIdentity(trustedQueuedTargets.get(canonicalPath)?.identity, current.identity))
+			) {
+				throw new AtomicYamlRetargetError();
+			}
+			target.identity = current.identity;
+			const value = await operation(canonicalPath, target);
+			trustedQueuedTargets.set(canonicalPath, { ...target });
+			return value;
+		});
 	const completion = result.then(
 		() => undefined,
 		() => undefined,
 	);
 	queues.set(canonicalPath, completion);
 	void completion.finally(() => {
-		if (queues.get(canonicalPath) === completion) queues.delete(canonicalPath);
+		if (queues.get(canonicalPath) === completion) {
+			queues.delete(canonicalPath);
+			trustedQueuedTargets.delete(canonicalPath);
+		}
 	});
 	return result;
 }
@@ -429,14 +560,17 @@ export function reserveAtomicYamlPatchSlot(
 	patches: () => Promise<readonly AtomicYamlPatch[]> | readonly AtomicYamlPatch[],
 	options: AtomicYamlPatchOptions = {},
 ): Promise<CasReceipt> {
-	return enqueueAtomicYamlOperation(configPath, async canonicalPath => {
+	return enqueueAtomicYamlOperation(configPath, async (_canonicalPath, target) => {
 		const nextPatches = await patches();
 		for (const patch of nextPatches) assertPatch(patch);
-		await fs.mkdir(path.dirname(canonicalPath), { recursive: true, mode: 0o700 });
-		return await withFileLock(canonicalPath, async () => {
-			const { current, root } = await readYaml(canonicalPath);
+		await assertAtomicYamlTarget(target);
+		await fs.mkdir(path.dirname(target.resolvedPath), { recursive: true, mode: 0o700 });
+		await assertAtomicYamlTarget(target);
+		return await withFileLock(target.resolvedPath, async () => {
+			await assertAtomicYamlTarget(target);
+			const { current, root } = await readYaml(target.resolvedPath);
 			await options.validateRoot?.(root, nextPatches);
-			return await applyPatchesUnderLock(canonicalPath, current, nextPatches, options);
+			return await applyPatchesUnderLock(target, current, nextPatches, options);
 		});
 	});
 }
@@ -450,14 +584,17 @@ export function reserveAtomicYamlUpdateSlot<T>(
 	update: () => Promise<AtomicYamlUpdate<T>> | AtomicYamlUpdate<T>,
 	options: AtomicYamlPatchOptions = {},
 ): Promise<T> {
-	return enqueueAtomicYamlOperation(configPath, async canonicalPath => {
+	return enqueueAtomicYamlOperation(configPath, async (_canonicalPath, target) => {
 		const atomicUpdate = await update();
-		await fs.mkdir(path.dirname(canonicalPath), { recursive: true, mode: 0o700 });
-		return await withFileLock(canonicalPath, async () => {
-			const { current } = await readYaml(canonicalPath);
+		await assertAtomicYamlTarget(target);
+		await fs.mkdir(path.dirname(target.resolvedPath), { recursive: true, mode: 0o700 });
+		await assertAtomicYamlTarget(target);
+		return await withFileLock(target.resolvedPath, async () => {
+			await assertAtomicYamlTarget(target);
+			const { current } = await readYaml(target.resolvedPath);
 			const result = await atomicUpdate.apply(current);
 			if (atomicUpdate.shouldWrite?.(result) !== false) {
-				await writeAtomicYaml(canonicalPath, current, options);
+				await writeAtomicYaml(target, current, options);
 			}
 			await atomicUpdate.committed?.(current, result);
 			return result;

package/src/config/keybindings.ts

@@ -29,6 +29,7 @@ interface AppKeybindings {
 	"app.model.select": true;
 	"app.model.selectTemporary": true;
 	"app.tools.expand": true;
+	"app.todo.toggle": true;
 	"app.tool.backgroundFold": true;
 	"app.editor.external": true;
 	"app.message.followUp": true;
@@ -37,6 +38,7 @@ interface AppKeybindings {
 	"app.clipboard.pasteImage": true;
 	"app.clipboard.copyLine": true;
 	"app.clipboard.copyPrompt": true;
+	"app.oauth.copyUrl": true;
 	"app.session.new": true;
 	"app.session.tree": true;
 	"app.session.fork": true;
@@ -131,6 +133,10 @@ export const KEYBINDINGS = {
 		defaultKeys: "ctrl+o",
 		description: "Expand tools",
 	},
+	"app.todo.toggle": {
+		defaultKeys: "alt+shift+t",
+		description: "Toggle todo list expansion",
+	},
 	"app.tool.backgroundFold": {
 		defaultKeys: "ctrl+b",
 		description: "Fold/background supported foreground tool",
@@ -163,6 +169,10 @@ export const KEYBINDINGS = {
 		defaultKeys: "alt+shift+c",
 		description: "Copy prompt",
 	},
+	"app.oauth.copyUrl": {
+		defaultKeys: "alt+shift+u",
+		description: "Copy OAuth authorization URL",
+	},
 	"app.session.new": {
 		defaultKeys: "ctrl+n",
 		description: "Start a new session",

package/src/config/model-profiles.ts

@@ -92,6 +92,41 @@ export const BUILTIN_MODEL_PROFILES: readonly ModelProfileDefinition[] = [
 		critic: "openai-codex/gpt-5.6-sol:max",
 		architect: "openai-codex/gpt-5.6-sol:xhigh",
 	}),
+	profile("macos-omlx-fast", ["omlx"], {
+		default: "omlx/Qwen3.6-35B-A3B-4bit:low",
+		executor: "omlx/Qwen3.6-35B-A3B-4bit:low",
+		architect: "omlx/Qwen3.6-35B-A3B-4bit:high",
+		planner: "omlx/Qwen3.6-35B-A3B-4bit:medium",
+		critic: "omlx/Qwen3.6-35B-A3B-4bit:high",
+	}),
+	profile("macos-omlx-balanced", ["omlx"], {
+		default: "omlx/Qwen3.6-35B-A3B-8bit:low",
+		executor: "omlx/Qwen3.6-35B-A3B-8bit:low",
+		architect: "omlx/Qwen3.6-35B-A3B-8bit:high",
+		planner: "omlx/Qwen3.6-35B-A3B-8bit:medium",
+		critic: "omlx/Qwen3.6-35B-A3B-8bit:high",
+	}),
+	profile("macos-omlx-quality", ["omlx"], {
+		default: "omlx/Qwen3.6-35B-A3B-8bit:low",
+		executor: "omlx/Qwen3.6-35B-A3B-8bit:low",
+		architect: "omlx/Qwen3.6-35B-A3B-8bit:high",
+		planner: "omlx/Qwen3.6-35B-A3B-8bit:medium",
+		critic: "omlx/Qwen3.8-27B-8bit:high",
+	}),
+	profile("macos-omlx-abliterated-fast", ["omlx"], {
+		default: "omlx/Qwen3.8-27B-Uncensored-MLX-4bit:low",
+		executor: "omlx/Qwen3.8-27B-Uncensored-MLX-4bit:low",
+		architect: "omlx/Qwen3.8-27B-Uncensored-MLX-4bit:high",
+		planner: "omlx/Qwen3.8-27B-Uncensored-MLX-4bit:medium",
+		critic: "omlx/Qwen3.8-27B-Uncensored-MLX-4bit:high",
+	}),
+	profile("macos-omlx-abliterated-balanced", ["omlx"], {
+		default: "omlx/Qwen3.8-27B-Uncensored-MLX-4bit:low",
+		executor: "omlx/Qwen3.8-27B-Uncensored-MLX-4bit:low",
+		architect: "omlx/Qwen3.8-27B-Uncensored-MLX-4bit:high",
+		planner: "omlx/Qwen3.8-27B-Uncensored-MLX-4bit:medium",
+		critic: "omlx/Qwen3.8-27B-Uncensored-MLX-4bit:high",
+	}),
 	profile("opencodego", ["opencode-go"], {
 		default: "opencode-go/kimi-k2.6",
 		executor: "opencode-go/deepseek-v4-flash",
@@ -327,6 +362,23 @@ const PROFILE_PRESENTATION: Record<string, ModelProfilePresentation> = {
 	"codex-eco": { displayName: "Codex Eco", providerGroup: "CODEX" },
 	"codex-medium": { displayName: "Codex Medium", providerGroup: "CODEX" },
 	"codex-pro": { displayName: "Codex Pro", providerGroup: "CODEX" },
+	"macos-omlx-fast": { displayName: "4-bit Fast (MoE measured 93.5 tok/s)", providerGroup: "macOS Local (oMLX)" },
+	"macos-omlx-balanced": {
+		displayName: "8-bit Balanced (MoE measured 71.1 tok/s)",
+		providerGroup: "macOS Local (oMLX)",
+	},
+	"macos-omlx-quality": {
+		displayName: "Quality mix (8-bit MoE + 8-bit dense critic)",
+		providerGroup: "macOS Local (oMLX)",
+	},
+	"macos-omlx-abliterated-fast": {
+		displayName: "Uncensored 4-bit Fast (measured 19.8 tok/s)",
+		providerGroup: "macOS Local (oMLX)",
+	},
+	"macos-omlx-abliterated-balanced": {
+		displayName: "Uncensored 4-bit Balanced (same winner as fast)",
+		providerGroup: "macOS Local (oMLX)",
+	},
 	opencodego: { displayName: "OpenCodeGo", providerGroup: "OPENCODEGO" },
 	"claude-opus": { displayName: "Claude Opus", providerGroup: "CLAUDE" },
 	"claude-fable": { displayName: "Claude Fable", providerGroup: "CLAUDE" },
@@ -361,6 +413,7 @@ const PROFILE_PRESENTATION: Record<string, ModelProfilePresentation> = {
 
 const PROFILE_GROUP_ORDER = [
 	"CODEX",
+	"macOS Local (oMLX)",
 	"OPENCODEGO",
 	"CLAUDE",
 	"GLM",
@@ -372,6 +425,14 @@ const PROFILE_GROUP_ORDER = [
 	"ALIBABA TOKEN PLAN",
 	"COMBOS",
 ];
+const MACOS_OMLX_PROFILE_ORDER = [
+	"macos-omlx-fast",
+	"macos-omlx-balanced",
+	"macos-omlx-quality",
+	"macos-omlx-abliterated-fast",
+	"macos-omlx-abliterated-balanced",
+] as const;
+const MACOS_OMLX_PROFILE_RANK = new Map<string, number>(MACOS_OMLX_PROFILE_ORDER.map((name, index) => [name, index]));
 
 const PROFILE_RECOMMENDATIONS: Record<string, string> = {
 	"openai-codex": "codex-medium",
@@ -386,6 +447,7 @@ const PROFILE_RECOMMENDATIONS: Record<string, string> = {
 	xai: "grok-medium",
 	"grok-build": "grok-build-pro",
 	cursor: "cursor-medium",
+	omlx: "macos-omlx-balanced",
 	"minimax-code": "minimax-medium",
 	"alibaba-token-plan": "alibaba-token-plan-balanced",
 };
@@ -420,7 +482,13 @@ export function groupModelProfilesForPresetLanding(
 	}
 	for (const [group, entries] of groups) {
 		if (entries.length === 0) groups.delete(group);
-		else entries.sort((a, b) => a.name.localeCompare(b.name));
+		else if (group === "macOS Local (oMLX)") {
+			entries.sort(
+				(a, b) =>
+					(MACOS_OMLX_PROFILE_RANK.get(a.name) ?? Number.MAX_SAFE_INTEGER) -
+					(MACOS_OMLX_PROFILE_RANK.get(b.name) ?? Number.MAX_SAFE_INTEGER),
+			);
+		} else entries.sort((a, b) => a.name.localeCompare(b.name));
 	}
 	return groups;
 }

package/src/config/model-registry.ts

@@ -7,7 +7,9 @@ import {
 	type CacheRetention,
 	type Context,
 	createModelManager,
+	Effort,
 	enrichModelThinking,
+	fetchOpenAICompatibleModels,
 	getBundledModels,
 	getBundledProviders,
 	googleAntigravityModelManagerOptions,
@@ -18,6 +20,7 @@ import {
 	type ModelRequestTransform,
 	openaiCodexModelManagerOptions,
 	PROVIDER_DESCRIPTORS,
+	type Provider,
 	readModelCache,
 	registerCustomApi,
 	type SimpleStreamOptions,
@@ -597,6 +600,10 @@ function toPositiveNumberOrUndefined(value: unknown): number | undefined {
 	return undefined;
 }
 
+function toSafePositiveIntegerOrUndefined(value: unknown): number | undefined {
+	return typeof value === "number" && Number.isSafeInteger(value) && value > 0 ? value : undefined;
+}
+
 function extractOllamaContextWindow(payload: Record<string, unknown>): number | undefined {
 	const modelInfo = payload.model_info;
 	if (isRecord(modelInfo)) {
@@ -1032,6 +1039,13 @@ export class ModelRegistry {
 	#lastStaticLoadMtime: number | null = null;
 	#registeredProviderSources: Set<string> = new Set();
 	#providerDiscoveryStates: Map<string, ProviderDiscoveryState> = new Map();
+	/**
+	 * Monotonic per-provider discovery sequence. Overlapping refreshes for the
+	 * same provider can complete out of order; only the newest-started refresh
+	 * may publish discovery state or contribute models, so a slow stale fetch
+	 * never overwrites a fresher result.
+	 */
+	#providerDiscoverySequences: Map<string, number> = new Map();
 	#cacheDbPath?: string;
 	#suppressedSelectors: Map<string, number> = new Map();
 	#backgroundRefresh?: Promise<void>;
@@ -1815,11 +1829,15 @@ export class ModelRegistry {
 		providerConfig: DiscoveryProviderConfig,
 		strategy: ModelRefreshStrategy,
 	): Promise<Model<Api>[]> {
+		const sequence = (this.#providerDiscoverySequences.get(providerConfig.provider) ?? 0) + 1;
+		this.#providerDiscoverySequences.set(providerConfig.provider, sequence);
+		const isCurrentDiscovery = () => this.#providerDiscoverySequences.get(providerConfig.provider) === sequence;
 		const cached = readModelCache<Api>(providerConfig.provider, 24 * 60 * 60 * 1000, Date.now, this.#cacheDbPath);
 		const requiresAuth = !this.#keylessProviders.has(providerConfig.provider);
 		if (requiresAuth) {
 			const apiKey = await this.#peekApiKeyForProvider(providerConfig.provider);
 			if (!isAuthenticated(apiKey)) {
+				if (!isCurrentDiscovery()) return [];
 				this.#providerDiscoveryStates.set(providerConfig.provider, {
 					provider: providerConfig.provider,
 					status: "unauthenticated",
@@ -1865,6 +1883,7 @@ export class ModelRegistry {
 				: result.models.length > 0
 					? "ok"
 					: "empty";
+		if (!isCurrentDiscovery()) return [];
 		this.#providerDiscoveryStates.set(providerId, {
 			provider: providerId,
 			status,
@@ -1893,6 +1912,8 @@ export class ModelRegistry {
 			case "llama.cpp":
 				return this.#discoverLlamaCppModels(providerConfig);
 			case "lm-studio":
+			case "omlx":
+			case "sglang":
 			case "openai-models-list":
 				return this.#discoverOpenAIModelsList(providerConfig);
 		}
@@ -2198,48 +2219,61 @@ export class ModelRegistry {
 
 	async #discoverOpenAIModelsList(providerConfig: DiscoveryProviderConfig): Promise<Model<Api>[]> {
 		const baseUrl = this.#normalizeOpenAIModelsListBaseUrl(providerConfig.baseUrl);
-		const modelsUrl = `${baseUrl}/models`;
-
 		const headers: Record<string, string> = { ...(providerConfig.headers ?? {}) };
 		const apiKey = await this.authStorage.getApiKey(providerConfig.provider);
-		if (apiKey && apiKey !== DEFAULT_LOCAL_TOKEN && apiKey !== kNoAuth) {
-			headers.Authorization = `Bearer ${apiKey}`;
-		}
-
-		const response = await fetch(modelsUrl, {
+		const bearerToken = apiKey && apiKey !== DEFAULT_LOCAL_TOKEN && apiKey !== kNoAuth ? apiKey : undefined;
+		const isOmlx = providerConfig.provider === "omlx";
+		const parseDiscoveryLimit = isOmlx ? toSafePositiveIntegerOrUndefined : toPositiveNumberOrUndefined;
+		const discovered = await fetchOpenAICompatibleModels({
+			api: providerConfig.api,
+			provider: providerConfig.provider as Provider,
+			baseUrl,
+			apiKey: bearerToken,
 			headers,
-			signal: AbortSignal.timeout(250),
+			signal: AbortSignal.timeout(providerConfig.provider === "sglang" ? 500 : 250),
+			fetch: (input, init) => fetch(input, { ...init, redirect: "error" }),
+			throwOnStatus: response => new Error(`HTTP ${response.status} from ${baseUrl}/models`),
+			mapModel: (item, defaults) => ({
+				...defaults,
+				reasoning: isOmlx,
+				...(isOmlx
+					? {
+							thinking: {
+								mode: "effort" as const,
+								minLevel: Effort.Low,
+								maxLevel: Effort.High,
+								defaultLevel: Effort.Medium,
+								levels: [Effort.Low, Effort.Medium, Effort.High],
+							},
+						}
+					: {}),
+				contextWindow:
+					parseDiscoveryLimit(item.max_model_len) ??
+					parseDiscoveryLimit(item.context_length) ??
+					parseDiscoveryLimit(item.context_window) ??
+					parseDiscoveryLimit(item.max_context_length) ??
+					UNK_CONTEXT_WINDOW,
+				maxTokens:
+					parseDiscoveryLimit(item.max_completion_tokens) ??
+					parseDiscoveryLimit(item.max_tokens) ??
+					parseDiscoveryLimit(item.max_output_tokens) ??
+					UNK_MAX_TOKENS,
+				headers,
+				compat: {
+					...(providerConfig.compat ?? {}),
+					supportsStore: false,
+					supportsDeveloperRole: false,
+					supportsReasoningEffort: isOmlx,
+					...(isOmlx
+						? {
+								thinkingFormat: "qwen-chat-template" as const,
+								reasoningContentField: "reasoning_content" as const,
+							}
+						: {}),
+				},
+			}),
 		});
-		if (!response.ok) {
-			throw new Error(`HTTP ${response.status} from ${modelsUrl}`);
-		}
-		const payload = (await response.json()) as { data?: Array<{ id: string }> };
-		const models = payload.data ?? [];
-		const discovered: Model<Api>[] = [];
-		for (const item of models) {
-			const id = item.id;
-			if (!id) continue;
-			discovered.push(
-				enrichModelThinking({
-					id,
-					name: id,
-					api: providerConfig.api,
-					provider: providerConfig.provider,
-					baseUrl,
-					reasoning: false,
-					input: ["text"],
-					cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-					contextWindow: 128000,
-					maxTokens: 8192,
-					headers,
-					compat: {
-						supportsStore: false,
-						supportsDeveloperRole: false,
-						supportsReasoningEffort: false,
-					},
-				}),
-			);
-		}
+		if (discovered === null) throw new Error(`Invalid OpenAI-compatible model catalog from ${baseUrl}`);
 		return this.#applyProviderModelOverrides(providerConfig.provider, discovered);
 	}
 

package/src/config/models-config-schema.ts

@@ -184,7 +184,7 @@ export const ModelOverrideSchema = z
 export type ModelOverride = z.infer<typeof ModelOverrideSchema>;
 
 export const ProviderDiscoverySchema = z.object({
-	type: z.enum(["ollama", "llama.cpp", "lm-studio", "openai-models-list"]),
+	type: z.enum(["ollama", "llama.cpp", "lm-studio", "omlx", "sglang", "openai-models-list"]),
 });
 
 const LocalOpenAICompatSchema = z

package/src/config/settings-schema.ts

@@ -1417,6 +1417,15 @@ export const SETTINGS_SCHEMA = {
 			],
 		},
 	},
+	"startup.skipLogoAnimation": {
+		type: "boolean",
+		default: false,
+		ui: {
+			tab: "interaction",
+			label: "Skip Logo Animation",
+			description: "Show the final welcome logo immediately",
+		},
+	},
 
 	"startup.checkUpdate": {
 		type: "boolean",