oma-coding-agent 1.1.4

package/src/thinking.ts

@@ -0,0 +1,187 @@
+import { type ResolvedThinkingLevel, ThinkingLevel } from "@oh-my-pi/pi-agent-core";
+import { Effort, type Model, THINKING_EFFORTS } from "@oh-my-pi/pi-ai";
+import { clampThinkingLevelForModel, getSupportedEfforts } from "@oh-my-pi/pi-catalog/model-thinking";
+
+/**
+ * Metadata used to render thinking selector values in the coding-agent UI.
+ */
+export interface ThinkingLevelMetadata {
+	value: ThinkingLevel;
+	label: string;
+	description: string;
+}
+
+const THINKING_LEVEL_METADATA: Record<ThinkingLevel, ThinkingLevelMetadata> = {
+	[ThinkingLevel.Inherit]: {
+		value: ThinkingLevel.Inherit,
+		label: "inherit",
+		description: "Inherit session default",
+	},
+	[ThinkingLevel.Off]: { value: ThinkingLevel.Off, label: "off", description: "No reasoning" },
+	[ThinkingLevel.Minimal]: {
+		value: ThinkingLevel.Minimal,
+		label: "min",
+		description: "Very brief reasoning (~1k tokens)",
+	},
+	[ThinkingLevel.Low]: { value: ThinkingLevel.Low, label: "low", description: "Light reasoning (~2k tokens)" },
+	[ThinkingLevel.Medium]: {
+		value: ThinkingLevel.Medium,
+		label: "medium",
+		description: "Moderate reasoning (~8k tokens)",
+	},
+	[ThinkingLevel.High]: { value: ThinkingLevel.High, label: "high", description: "Deep reasoning (~16k tokens)" },
+	[ThinkingLevel.XHigh]: {
+		value: ThinkingLevel.XHigh,
+		label: "max",
+		description: "Maximum reasoning (~32k tokens)",
+	},
+};
+
+const EFFORT_BY_SELECTOR: Readonly<Record<string, Effort>> = {
+	[Effort.Minimal]: Effort.Minimal,
+	[Effort.Low]: Effort.Low,
+	[Effort.Medium]: Effort.Medium,
+	[Effort.High]: Effort.High,
+	[Effort.XHigh]: Effort.XHigh,
+	max: Effort.XHigh,
+};
+const THINKING_LEVEL_BY_SELECTOR: Readonly<Record<string, ThinkingLevel>> = {
+	[ThinkingLevel.Inherit]: ThinkingLevel.Inherit,
+	[ThinkingLevel.Off]: ThinkingLevel.Off,
+	[ThinkingLevel.Minimal]: ThinkingLevel.Minimal,
+	[ThinkingLevel.Low]: ThinkingLevel.Low,
+	[ThinkingLevel.Medium]: ThinkingLevel.Medium,
+	[ThinkingLevel.High]: ThinkingLevel.High,
+	[ThinkingLevel.XHigh]: ThinkingLevel.XHigh,
+};
+
+function getOwnSelector<T>(selectors: Readonly<Record<string, T>>, value: string | null | undefined): T | undefined {
+	return value === undefined || value === null || !Object.hasOwn(selectors, value) ? undefined : selectors[value];
+}
+
+/**
+ * Parses a provider-facing effort value.
+ */
+export function parseEffort(value: string | null | undefined): Effort | undefined {
+	return getOwnSelector(EFFORT_BY_SELECTOR, value);
+}
+
+/**
+ * Parses an agent-local thinking selector.
+ */
+export function parseThinkingLevel(value: string | null | undefined): ThinkingLevel | undefined {
+	return getOwnSelector(THINKING_LEVEL_BY_SELECTOR, value);
+}
+
+/**
+ * Returns display metadata for a thinking selector.
+ */
+export function getThinkingLevelMetadata(level: ThinkingLevel): ThinkingLevelMetadata {
+	return THINKING_LEVEL_METADATA[level];
+}
+
+/**
+ * Converts an agent-local selector into the effort sent to providers.
+ */
+export function toReasoningEffort(level: ThinkingLevel | undefined): Effort | undefined {
+	if (level === undefined || level === ThinkingLevel.Off || level === ThinkingLevel.Inherit) {
+		return undefined;
+	}
+	return level;
+}
+
+/**
+ * True when a selector explicitly requests provider-side reasoning disablement.
+ */
+export function shouldDisableReasoning(level: ThinkingLevel | undefined): boolean {
+	return level === ThinkingLevel.Off;
+}
+
+/**
+ * Resolves a selector against the current model while preserving explicit "off".
+ */
+export function resolveThinkingLevelForModel(
+	model: Model | undefined,
+	level: ThinkingLevel | undefined,
+): ResolvedThinkingLevel | undefined {
+	if (level === undefined || level === ThinkingLevel.Inherit) {
+		return undefined;
+	}
+	if (level === ThinkingLevel.Off) {
+		return ThinkingLevel.Off;
+	}
+	return clampThinkingLevelForModel(model, level);
+}
+
+/**
+ * Sentinel selector for the coding-agent "auto" thinking mode. Kept entirely
+ * inside the coding-agent layer: it is never an {@link Effort} or
+ * {@link ThinkingLevel}, so provider mapping/clamping keeps seeing concrete
+ * efforts. The session resolves `auto` to a concrete effort each turn.
+ */
+export const AUTO_THINKING = "auto" as const;
+
+/** A thinking selector as configured by the user — a concrete level or `auto`. */
+export type ConfiguredThinkingLevel = ThinkingLevel | typeof AUTO_THINKING;
+
+/** Metadata used to render the `auto` selector value alongside concrete levels. */
+export interface ConfiguredThinkingLevelMetadata {
+	value: ConfiguredThinkingLevel;
+	label: string;
+	description: string;
+}
+
+const AUTO_THINKING_METADATA: ConfiguredThinkingLevelMetadata = {
+	value: AUTO_THINKING,
+	label: "auto",
+	description: "Auto-detect per prompt (low–xhigh)",
+};
+
+/**
+ * Parses a configured thinking selector, accepting `auto` in addition to every
+ * value {@link parseThinkingLevel} accepts. {@link parseThinkingLevel} itself
+ * stays strict so model-suffix parsing (`model:high`) keeps rejecting `auto`.
+ */
+export function parseConfiguredThinkingLevel(value: string | null | undefined): ConfiguredThinkingLevel | undefined {
+	if (value === AUTO_THINKING) return AUTO_THINKING;
+	if (value === "max") return ThinkingLevel.XHigh;
+	return parseThinkingLevel(value);
+}
+
+/** Returns display metadata for a configured selector, including `auto`. */
+export function getConfiguredThinkingLevelMetadata(level: ConfiguredThinkingLevel): ConfiguredThinkingLevelMetadata {
+	return level === AUTO_THINKING ? AUTO_THINKING_METADATA : getThinkingLevelMetadata(level);
+}
+
+/**
+ * Resolves an auto-classified effort against the active model's supported
+ * range. Unlike {@link clampThinkingLevelForModel}, `auto` never resolves below
+ * {@link Effort.Low}: the eligible pool is the model's supported efforts at or
+ * above Low (falling back to the full supported set only when the model maxes
+ * out below Low). Within that pool the request snaps to the highest level not
+ * exceeding it, or the pool minimum when the request is below the pool.
+ */
+export function clampAutoThinkingEffort(model: Model | undefined, effort: Effort): Effort {
+	const supported = model ? getSupportedEfforts(model) : THINKING_EFFORTS;
+	if (supported.length === 0) return effort;
+	const lowIndex = THINKING_EFFORTS.indexOf(Effort.Low);
+	const eligible = supported.filter(level => THINKING_EFFORTS.indexOf(level) >= lowIndex);
+	const pool = eligible.length > 0 ? eligible : supported;
+	const requestedIndex = THINKING_EFFORTS.indexOf(effort);
+	let chosen = pool[0];
+	for (const candidate of pool) {
+		if (THINKING_EFFORTS.indexOf(candidate) > requestedIndex) break;
+		chosen = candidate;
+	}
+	return chosen;
+}
+
+/**
+ * The provisional concrete level shown while `auto` is configured but before a
+ * turn has been classified. Prefers the model's `defaultLevel`, otherwise High,
+ * clamped into the auto range. Returns `undefined` for non-reasoning models.
+ */
+export function resolveProvisionalAutoLevel(model: Model | undefined): Effort | undefined {
+	if (!model?.reasoning) return undefined;
+	return clampAutoThinkingEffort(model, model.thinking?.defaultLevel ?? Effort.High);
+}

package/src/tiny/device.ts

@@ -0,0 +1,111 @@
+import type { DeviceType } from "@huggingface/transformers";
+import { $env } from "@oh-my-pi/pi-utils";
+
+export type TinyModelDevice = DeviceType;
+
+export interface TinyModelDevicePreference {
+	device: TinyModelDevice;
+	raw: string | undefined;
+}
+
+const CPU_DEVICE: TinyModelDevice = "cpu";
+const CPU_ONLY_ORDER: readonly TinyModelDevice[] = [CPU_DEVICE];
+const DARWIN_WEBGPU_UNSAFE_ORDER: readonly TinyModelDevice[] = [CPU_DEVICE];
+
+const DEVICE_VALUES: Record<TinyModelDevice, true> = {
+	auto: true,
+	gpu: true,
+	cpu: true,
+	wasm: true,
+	webgpu: true,
+	cuda: true,
+	dml: true,
+	coreml: true,
+	webnn: true,
+	"webnn-npu": true,
+	"webnn-gpu": true,
+	"webnn-cpu": true,
+};
+
+function usesDarwinWorkerWebGpu(device: TinyModelDevice): boolean {
+	return process.platform === "darwin" && (device === "gpu" || device === "webgpu" || device === "auto");
+}
+
+export function normalizeTinyModelDevice(value: string | undefined): TinyModelDevice | undefined {
+	const raw = value?.trim().toLowerCase();
+	if (!raw) return undefined;
+	if (raw === "metal") return "webgpu";
+	if (raw in DEVICE_VALUES) return raw as TinyModelDevice;
+	throw new Error(
+		`Unsupported PI_TINY_DEVICE=${JSON.stringify(value)}. Use cpu, gpu, metal, webgpu, auto, cuda, dml, coreml, wasm, webnn, webnn-gpu, webnn-cpu, or webnn-npu.`,
+	);
+}
+
+export function resolveTinyModelDevicePreference(
+	value: string | undefined = $env.PI_TINY_DEVICE,
+): TinyModelDevicePreference {
+	return {
+		device: normalizeTinyModelDevice(value) ?? CPU_DEVICE,
+		raw: value,
+	};
+}
+
+export function tinyModelDeviceLoadOrder(preference: TinyModelDevicePreference): readonly TinyModelDevice[] {
+	if (preference.device === CPU_DEVICE) return CPU_ONLY_ORDER;
+	if (usesDarwinWorkerWebGpu(preference.device)) return DARWIN_WEBGPU_UNSAFE_ORDER;
+	return [preference.device, CPU_DEVICE];
+}
+
+/** Sentinel `providers.tinyModelDevice` value meaning "use the built-in CPU default". */
+export const TINY_MODEL_DEVICE_DEFAULT = "default";
+
+/** Accepted values for the `providers.tinyModelDevice` setting (validation + UI). */
+export const TINY_MODEL_DEVICE_SETTING_VALUES = [
+	TINY_MODEL_DEVICE_DEFAULT,
+	"gpu",
+	"cpu",
+	"metal",
+	"webgpu",
+	"cuda",
+	"dml",
+	"coreml",
+	"auto",
+	"wasm",
+	"webnn",
+	"webnn-gpu",
+	"webnn-cpu",
+	"webnn-npu",
+] as const;
+
+/** Submenu metadata for the `providers.tinyModelDevice` setting. */
+export const TINY_MODEL_DEVICE_SETTING_OPTIONS = [
+	{ value: "default", label: "Default", description: "CPU-only inference" },
+	{ value: "gpu", label: "GPU", description: "Accelerated provider (WebGPU/Metal, CUDA, or DirectML)" },
+	{ value: "cpu", label: "CPU", description: "CPU-only inference" },
+	{ value: "metal", label: "Metal", description: "WebGPU alias for Apple GPUs" },
+	{ value: "webgpu", label: "WebGPU", description: "WebGPU/Metal backend" },
+	{ value: "cuda", label: "CUDA", description: "NVIDIA CUDA (Linux x64)" },
+	{ value: "dml", label: "DirectML", description: "DirectML backend (Windows)" },
+	{ value: "coreml", label: "CoreML", description: "Apple CoreML (opt-in; can fail to load)" },
+	{ value: "auto", label: "Auto", description: "Let ONNX Runtime choose a provider" },
+	{ value: "wasm", label: "WASM", description: "WebAssembly backend" },
+	{ value: "webnn", label: "WebNN", description: "WebNN backend" },
+	{ value: "webnn-gpu", label: "WebNN GPU", description: "WebNN GPU device" },
+	{ value: "webnn-cpu", label: "WebNN CPU", description: "WebNN CPU device" },
+	{ value: "webnn-npu", label: "WebNN NPU", description: "WebNN NPU device" },
+] as const satisfies ReadonlyArray<{
+	value: (typeof TINY_MODEL_DEVICE_SETTING_VALUES)[number];
+	label: string;
+	description: string;
+}>;
+
+/**
+ * Map a `providers.tinyModelDevice` setting value onto a `PI_TINY_DEVICE` env
+ * value for the worker. Returns `undefined` for the default sentinel so the
+ * worker keeps its built-in CPU default; the worker still validates the
+ * forwarded value via {@link normalizeTinyModelDevice}.
+ */
+export function tinyModelDeviceSettingToEnv(value: string | undefined): string | undefined {
+	if (!value || value === TINY_MODEL_DEVICE_DEFAULT) return undefined;
+	return value;
+}

package/src/tiny/dtype.ts

@@ -0,0 +1,101 @@
+import type { DataType } from "@huggingface/transformers";
+import { $env } from "@oh-my-pi/pi-utils";
+
+/** ONNX quantization / precision for local tiny models (transformers.js `dtype`). */
+export type TinyModelDtype = DataType;
+
+const DTYPE_VALUES: Record<TinyModelDtype, true> = {
+	auto: true,
+	fp32: true,
+	fp16: true,
+	q8: true,
+	int8: true,
+	uint8: true,
+	q4: true,
+	bnb4: true,
+	q4f16: true,
+	q2: true,
+	q2f16: true,
+	q1: true,
+	q1f16: true,
+};
+
+/**
+ * Validate and canonicalize a `PI_TINY_DTYPE` value. Returns `undefined` when
+ * unset/blank so callers fall back to the per-model spec dtype, and throws on an
+ * unrecognized value so a misconfiguration fails loudly instead of silently
+ * loading a different precision than requested.
+ */
+export function normalizeTinyModelDtype(value: string | undefined): TinyModelDtype | undefined {
+	const raw = value?.trim().toLowerCase();
+	if (!raw) return undefined;
+	if (raw in DTYPE_VALUES) return raw as TinyModelDtype;
+	throw new Error(
+		`Unsupported PI_TINY_DTYPE=${JSON.stringify(value)}. Use auto, fp32, fp16, q8, int8, uint8, q4, bnb4, q4f16, q2, q2f16, q1, or q1f16.`,
+	);
+}
+
+/**
+ * Resolve the `PI_TINY_DTYPE` override. `undefined` means "use the per-model spec
+ * dtype" (currently `q4` for every shipped model); a concrete value overrides the
+ * precision for whichever local tiny model loads.
+ */
+export function resolveTinyModelDtypeOverride(
+	value: string | undefined = $env.PI_TINY_DTYPE,
+): TinyModelDtype | undefined {
+	return normalizeTinyModelDtype(value);
+}
+
+/** Sentinel `providers.tinyModelDtype` value meaning "use each model's shipped dtype". */
+export const TINY_MODEL_DTYPE_DEFAULT = "default";
+
+/** Accepted values for the `providers.tinyModelDtype` setting (validation + UI). */
+export const TINY_MODEL_DTYPE_SETTING_VALUES = [
+	TINY_MODEL_DTYPE_DEFAULT,
+	"q4",
+	"q4f16",
+	"q8",
+	"fp16",
+	"fp32",
+	"int8",
+	"uint8",
+	"bnb4",
+	"q2",
+	"q2f16",
+	"q1",
+	"q1f16",
+	"auto",
+] as const;
+
+/** Submenu metadata for the `providers.tinyModelDtype` setting. */
+export const TINY_MODEL_DTYPE_SETTING_OPTIONS = [
+	{ value: "default", label: "Default", description: "Each model's shipped dtype (currently q4)" },
+	{ value: "q4", label: "q4", description: "4-bit weights; smallest and fastest" },
+	{ value: "q4f16", label: "q4f16", description: "4-bit weights with fp16 activations" },
+	{ value: "q8", label: "q8", description: "8-bit quantization" },
+	{ value: "fp16", label: "fp16", description: "16-bit float; higher fidelity, larger" },
+	{ value: "fp32", label: "fp32", description: "Full precision; largest and slowest" },
+	{ value: "int8", label: "int8", description: "Signed 8-bit integer" },
+	{ value: "uint8", label: "uint8", description: "Unsigned 8-bit integer" },
+	{ value: "bnb4", label: "bnb4", description: "bitsandbytes 4-bit" },
+	{ value: "q2", label: "q2", description: "2-bit weights" },
+	{ value: "q2f16", label: "q2f16", description: "2-bit weights with fp16 activations" },
+	{ value: "q1", label: "q1", description: "1-bit weights" },
+	{ value: "q1f16", label: "q1f16", description: "1-bit weights with fp16 activations" },
+	{ value: "auto", label: "Auto", description: "Let transformers.js choose per device" },
+] as const satisfies ReadonlyArray<{
+	value: (typeof TINY_MODEL_DTYPE_SETTING_VALUES)[number];
+	label: string;
+	description: string;
+}>;
+
+/**
+ * Map a `providers.tinyModelDtype` setting value onto a `PI_TINY_DTYPE` env value
+ * for the worker. Returns `undefined` for the default sentinel so the worker keeps
+ * each model's shipped dtype; the worker still validates the forwarded value via
+ * {@link normalizeTinyModelDtype}.
+ */
+export function tinyModelDtypeSettingToEnv(value: string | undefined): string | undefined {
+	if (!value || value === TINY_MODEL_DTYPE_DEFAULT) return undefined;
+	return value;
+}

package/src/tiny/models.ts

@@ -0,0 +1,252 @@
+/** Default session-title model: the online pi/smol path (no local download / on-device inference). */
+export const ONLINE_TINY_TITLE_MODEL_KEY = "online";
+/** Local model the `tiny-models` CLI downloads when none is named. Not the session-title default — that is {@link ONLINE_TINY_TITLE_MODEL_KEY}. */
+export const DEFAULT_TINY_TITLE_LOCAL_MODEL_KEY = "lfm2-700m";
+
+export interface TinyTitleLocalModelSpec {
+	key: string;
+	repo: string;
+	dtype: "q4";
+	label: string;
+	description: string;
+	contextNote: string;
+	/** Model family emits hidden reasoning unless the chat template disables it. */
+	reasoning?: boolean;
+}
+
+export const TINY_TITLE_LOCAL_MODELS = [
+	{
+		key: "lfm2-350m",
+		repo: "onnx-community/LFM2-350M-ONNX",
+		dtype: "q4",
+		label: "LFM2 350M",
+		description: "Recommended local model; best speed/quality balance, about 212 MB cached.",
+		contextNote: "Best local default from the title-generation spike.",
+	},
+	{
+		key: "qwen3-0.6b",
+		repo: "onnx-community/Qwen3-0.6B-ONNX",
+		dtype: "q4",
+		label: "Qwen3 0.6B",
+		description: "Most robust local option; slower first load, about 500 MB cached.",
+		contextNote: "Use when title quality matters more than local startup cost.",
+		reasoning: true,
+	},
+	{
+		key: "gemma-270m",
+		repo: "onnx-community/gemma-3-270m-it-ONNX",
+		dtype: "q4",
+		label: "Gemma 270M",
+		description: "Smallest viable local option; lower quality, lowest cache footprint.",
+		contextNote: "Use on constrained machines that still need local titles.",
+	},
+	{
+		key: "qwen2.5-0.5b",
+		repo: "onnx-community/Qwen2.5-0.5B-Instruct",
+		dtype: "q4",
+		label: "Qwen2.5 0.5B",
+		description: "Balanced local fallback; moderate quality and cache footprint.",
+		contextNote: "Useful when Qwen3 is too heavy but Gemma quality is insufficient.",
+	},
+	{
+		key: "lfm2-700m",
+		repo: "onnx-community/LFM2-700M-ONNX",
+		dtype: "q4",
+		label: "LFM2 700M",
+		description: "Highest-quality local option; larger and slower than LFM2 350M.",
+		contextNote: "Use when local title quality is preferred over startup cost.",
+	},
+] as const satisfies readonly TinyTitleLocalModelSpec[];
+
+export const TINY_TITLE_MODEL_VALUES = [
+	ONLINE_TINY_TITLE_MODEL_KEY,
+	"lfm2-350m",
+	"qwen3-0.6b",
+	"gemma-270m",
+	"qwen2.5-0.5b",
+	"lfm2-700m",
+] as const;
+
+export type TinyTitleModelKey = (typeof TINY_TITLE_MODEL_VALUES)[number];
+export type TinyTitleLocalModelKey = (typeof TINY_TITLE_LOCAL_MODELS)[number]["key"];
+
+type MissingTinyTitleModelValue = Exclude<
+	typeof ONLINE_TINY_TITLE_MODEL_KEY | TinyTitleLocalModelKey,
+	TinyTitleModelKey
+>;
+type ExtraTinyTitleModelValue = Exclude<TinyTitleModelKey, typeof ONLINE_TINY_TITLE_MODEL_KEY | TinyTitleLocalModelKey>;
+const TINY_TITLE_MODEL_VALUES_MATCH_REGISTRY: MissingTinyTitleModelValue extends never
+	? ExtraTinyTitleModelValue extends never
+		? true
+		: never
+	: never = true;
+void TINY_TITLE_MODEL_VALUES_MATCH_REGISTRY;
+
+export const TINY_TITLE_MODEL_OPTIONS = [
+	{
+		value: ONLINE_TINY_TITLE_MODEL_KEY,
+		label: "Online (pi/smol)",
+		description: "Current online title generation path; no local model download or on-device inference.",
+	},
+	...TINY_TITLE_LOCAL_MODELS.map(model => ({
+		value: model.key,
+		label: model.label,
+		description: model.description,
+	})),
+] satisfies ReadonlyArray<{ value: TinyTitleModelKey; label: string; description: string }>;
+
+export function isTinyTitleLocalModelKey(value: string): value is TinyTitleLocalModelKey {
+	return TINY_TITLE_LOCAL_MODELS.some(model => model.key === value);
+}
+
+export function getTinyTitleModelSpec(key: TinyTitleLocalModelKey): (typeof TINY_TITLE_LOCAL_MODELS)[number] {
+	const spec = TINY_TITLE_LOCAL_MODELS.find(model => model.key === key);
+	if (!spec) throw new Error(`Unknown tiny title model: ${key}`);
+	return spec;
+}
+
+/** Default memory model: the online path (the configured smol / remote LLM; no local download). */
+export const ONLINE_MEMORY_MODEL_KEY = "online";
+/** Recommended local model for memory tasks when none is named. */
+export const DEFAULT_MEMORY_LOCAL_MODEL_KEY = "qwen3-1.7b";
+
+/**
+ * Local models for Mnemopi memory tasks (fact extraction + consolidation).
+ * These are larger (1B-1.7B) than the title models: structured extraction and
+ * faithful summarization need more capacity than 3-6 word titles. All q4.
+ * Ranking/recipe rationale lives in docs/local-models.md.
+ */
+export const TINY_MEMORY_LOCAL_MODELS = [
+	{
+		key: "qwen3-1.7b",
+		repo: "onnx-community/Qwen3-1.7B-ONNX",
+		dtype: "q4",
+		label: "Qwen3 1.7B",
+		description:
+			"Recommended; most disciplined extraction (ignores chit-chat), good consolidation, about 1.1 GB cached.",
+		contextNote: "Best single-model pick for memory from the local experiment.",
+		reasoning: true,
+	},
+	{
+		key: "gemma-3-1b",
+		repo: "onnx-community/gemma-3-1b-it-ONNX",
+		dtype: "q4",
+		label: "Gemma 3 1B",
+		description: "Best consolidation/dedup; lighter footprint, but leaks small talk during extraction.",
+		contextNote: "Use when consolidation quality and size matter most.",
+	},
+	{
+		key: "qwen2.5-1.5b",
+		repo: "onnx-community/Qwen2.5-1.5B-Instruct",
+		dtype: "q4",
+		label: "Qwen2.5 1.5B",
+		description: "Best extraction granularity (atomic facts); weaker consolidation.",
+		contextNote: "Use when fine-grained, deduplicatable facts matter more than summaries.",
+	},
+	{
+		key: "lfm2-1.2b",
+		repo: "onnx-community/LFM2-1.2B-ONNX",
+		dtype: "q4",
+		label: "LFM2 1.2B",
+		description: "Fastest load; solid all-rounder, slightly noisier extraction labels.",
+		contextNote: "Use when local startup cost is the priority.",
+	},
+] as const satisfies readonly TinyTitleLocalModelSpec[];
+
+export const TINY_MEMORY_MODEL_VALUES = [
+	ONLINE_MEMORY_MODEL_KEY,
+	"qwen3-1.7b",
+	"gemma-3-1b",
+	"qwen2.5-1.5b",
+	"lfm2-1.2b",
+] as const;
+
+export type TinyMemoryModelKey = (typeof TINY_MEMORY_MODEL_VALUES)[number];
+export type TinyMemoryLocalModelKey = (typeof TINY_MEMORY_LOCAL_MODELS)[number]["key"];
+
+type MissingTinyMemoryModelValue = Exclude<
+	typeof ONLINE_MEMORY_MODEL_KEY | TinyMemoryLocalModelKey,
+	TinyMemoryModelKey
+>;
+type ExtraTinyMemoryModelValue = Exclude<TinyMemoryModelKey, typeof ONLINE_MEMORY_MODEL_KEY | TinyMemoryLocalModelKey>;
+const TINY_MEMORY_MODEL_VALUES_MATCH_REGISTRY: MissingTinyMemoryModelValue extends never
+	? ExtraTinyMemoryModelValue extends never
+		? true
+		: never
+	: never = true;
+void TINY_MEMORY_MODEL_VALUES_MATCH_REGISTRY;
+
+export const TINY_MEMORY_MODEL_OPTIONS = [
+	{
+		value: ONLINE_MEMORY_MODEL_KEY,
+		label: "Online (smol/remote)",
+		description:
+			"Use the configured Mnemopi LLM mode (smol or remote); no local model download or on-device inference.",
+	},
+	...TINY_MEMORY_LOCAL_MODELS.map(model => ({
+		value: model.key,
+		label: model.label,
+		description: model.description,
+	})),
+] satisfies ReadonlyArray<{ value: TinyMemoryModelKey; label: string; description: string }>;
+
+export function isTinyMemoryLocalModelKey(value: string): value is TinyMemoryLocalModelKey {
+	return TINY_MEMORY_LOCAL_MODELS.some(model => model.key === value);
+}
+
+export function getTinyMemoryModelSpec(key: TinyMemoryLocalModelKey): (typeof TINY_MEMORY_LOCAL_MODELS)[number] {
+	const spec = TINY_MEMORY_LOCAL_MODELS.find(model => model.key === key);
+	if (!spec) throw new Error(`Unknown tiny memory model: ${key}`);
+	return spec;
+}
+
+/** Return whether a memory local model may emit reasoning tokens before answers. */
+export function isTinyMemoryReasoningModelKey(key: TinyMemoryLocalModelKey): boolean {
+	const spec = getTinyMemoryModelSpec(key);
+	return "reasoning" in spec && spec.reasoning === true;
+}
+
+/** Any local model key (title or memory), used by the shared inference worker. */
+export type TinyLocalModelKey = TinyTitleLocalModelKey | TinyMemoryLocalModelKey;
+
+/** Resolve a local model spec by key across both the title and memory registries. */
+export function getTinyLocalModelSpec(key: string): TinyTitleLocalModelSpec | undefined {
+	return (
+		TINY_TITLE_LOCAL_MODELS.find(model => model.key === key) ??
+		TINY_MEMORY_LOCAL_MODELS.find(model => model.key === key)
+	);
+}
+
+export function isTinyLocalModelKey(value: string): value is TinyLocalModelKey {
+	return getTinyLocalModelSpec(value) !== undefined;
+}
+
+/** Combined local model registry (title + memory) for the shared tiny-models CLI. */
+export const TINY_LOCAL_MODELS = [
+	...TINY_TITLE_LOCAL_MODELS,
+	...TINY_MEMORY_LOCAL_MODELS,
+] as const satisfies readonly TinyTitleLocalModelSpec[];
+
+/**
+ * Difficulty-classifier model for the `auto` thinking level. Defaults to the
+ * online smol path; the local options reuse the memory-model registry because
+ * the shared worker's `complete()` only accepts memory local keys, and the
+ * 1B+ memory models classify coding difficulty far more reliably than the
+ * sub-1B title models.
+ */
+export const ONLINE_AUTO_THINKING_MODEL_KEY = ONLINE_MEMORY_MODEL_KEY;
+export const AUTO_THINKING_MODEL_VALUES = TINY_MEMORY_MODEL_VALUES;
+export type AutoThinkingModelKey = TinyMemoryModelKey;
+
+export const AUTO_THINKING_MODEL_OPTIONS = [
+	{
+		value: ONLINE_AUTO_THINKING_MODEL_KEY,
+		label: "Online (smol)",
+		description: "Classify prompt difficulty with the online smol model; no local download or on-device inference.",
+	},
+	...TINY_MEMORY_LOCAL_MODELS.map(model => ({
+		value: model.key,
+		label: model.label,
+		description: model.description,
+	})),
+] satisfies ReadonlyArray<{ value: AutoThinkingModelKey; label: string; description: string }>;