ompchamber 0.3.0

package/src/shared/lib/models/remote-list.ts

@@ -0,0 +1,125 @@
+/**
+ * Normalization of raw provider model-listing entries (/v1/models) into
+ * ProviderModel shapes. Covers the field spellings seen in the wild:
+ * OpenAI (data[].context_window), Gemini (models[].displayName, "models/"
+ * prefixed ids), Anthropic (display_name), and Kenari (context_length,
+ * modalities, tool_call, micro-IDR pricing).
+ */
+
+import { formatContextWindow } from '@/shared/lib/code/format';
+import type { ProviderModel } from '@/shared/types';
+
+export interface RemoteModelEntry {
+  id?: string;
+  name?: string;
+  display_name?: string;
+  displayName?: string;
+  context_window?: number;
+  contextWindow?: number;
+  context_length?: number;
+  contextLength?: number;
+  max_output_tokens?: number;
+  maxOutputTokens?: number;
+  inputTokenLimit?: number;
+  max_context_length?: number;
+  reasoning?: boolean;
+  reasoning_toggle?: boolean;
+  tool_call?: boolean;
+  modalities?: { input?: string[]; output?: string[] };
+  pricing?: {
+    input?: number;
+    output?: number;
+    currency?: string;
+    unit?: string;
+  };
+}
+
+export interface RemoteCapabilities {
+  hasVision?: boolean;
+  hasReasoning?: boolean;
+  hasTools?: boolean;
+  priceInput?: number;
+  priceOutput?: number;
+  maxOutputTokens?: number;
+}
+
+const MICRO_IDR_PER_USD = 16_500 * 1_000_000;
+
+function normalizePricing(pricing: RemoteModelEntry['pricing']): { input?: number; output?: number } {
+  if (!pricing || typeof pricing.input !== 'number' || typeof pricing.output !== 'number') return {};
+  if (pricing.unit === 'micro_idr_per_1m_tokens') {
+    return {
+      input: Number((pricing.input / MICRO_IDR_PER_USD).toFixed(4)),
+      output: Number((pricing.output / MICRO_IDR_PER_USD).toFixed(4)),
+    };
+  }
+  if (pricing.currency === 'USD') return { input: pricing.input, output: pricing.output };
+  return {};
+}
+
+export function entryCapabilities(entry: RemoteModelEntry): RemoteCapabilities {
+  const pricing = normalizePricing(entry.pricing);
+  const inputModalities = entry.modalities?.input;
+  const outTokens = [entry.max_output_tokens, entry.maxOutputTokens]
+    .find((v): v is number => typeof v === 'number' && Number.isFinite(v) && v > 0);
+  return {
+    hasVision: inputModalities ? inputModalities.includes('image') : undefined,
+    hasReasoning: entry.reasoning === true || entry.reasoning_toggle === true || undefined,
+    hasTools: entry.tool_call === false ? false : entry.tool_call === true ? true : undefined,
+    priceInput: pricing.input,
+    priceOutput: pricing.output,
+    maxOutputTokens: outTokens,
+  };
+}
+
+function toProviderModel(entry: RemoteModelEntry, capabilities: RemoteCapabilities): ProviderModel | null {
+  const rawId = typeof entry.id === 'string' && entry.id.trim().length > 0
+    ? entry.id
+    : (typeof entry.name === 'string' ? entry.name : '');
+  // Gemini lists ids as "models/<id>" — strip the prefix.
+  const id = rawId.replace(/^models\//, '').trim();
+  if (!id) return null;
+  const displayName = typeof entry.display_name === 'string' && entry.display_name.trim().length > 0
+    ? entry.display_name.trim()
+    : undefined;
+  const geminiName = typeof entry.displayName === 'string' && entry.displayName.trim().length > 0
+    ? entry.displayName.trim()
+    : undefined;
+  const ctx = [entry.context_window, entry.contextWindow, entry.context_length, entry.contextLength, entry.inputTokenLimit, entry.max_context_length]
+    .find((value): value is number => typeof value === 'number' && Number.isFinite(value) && value > 0);
+  const out = capabilities.maxOutputTokens;
+  const ctxLabel = ctx ? formatContextWindow(ctx) : null;
+  const outLabel = out ? formatContextWindow(out) : null;
+  const contextWindow = ctxLabel
+    ? (outLabel ? `${ctxLabel} ctx · ${outLabel} out` : `${ctxLabel} ctx`)
+    : '';
+  return {
+    id,
+    name: displayName ?? geminiName ?? id,
+    contextWindow,
+    hasTools: capabilities.hasTools ?? true,
+    hasVision: capabilities.hasVision ?? false,
+    hasReasoning: capabilities.hasReasoning,
+    priceInput: capabilities.priceInput,
+    priceOutput: capabilities.priceOutput,
+    isVisible: true,
+  };
+}
+
+export function extractModels(payload: unknown): ProviderModel[] | null {
+  if (!payload || typeof payload !== 'object') return null;
+  const obj = payload as Record<string, unknown>;
+  const list = Array.isArray(obj.data) ? obj.data : Array.isArray(obj.models) ? obj.models : null;
+  if (!list) return null;
+  const models: ProviderModel[] = [];
+  const seen = new Set<string>();
+  for (const raw of list) {
+    if (!raw || typeof raw !== 'object') continue;
+    const model = toProviderModel(raw as RemoteModelEntry, entryCapabilities(raw as RemoteModelEntry));
+    if (model && !seen.has(model.id)) {
+      seen.add(model.id);
+      models.push(model);
+    }
+  }
+  return models;
+}

package/src/shared/lib/models/server-cache.ts

@@ -0,0 +1,27 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Process-wide registry caches shared by `GET /api/models` and the provider
+ * settings routes. Both snapshot the omp registry for 60s, so every provider
+ * mutation — connect, disconnect, model visibility, models.yml registration —
+ * must drop them together. Otherwise the chat model picker keeps serving the
+ * list from before the change until the TTL expires.
+ */
+
+import type { ModelsData, ProviderItem } from '@/shared/types';
+
+declare global {
+  // eslint-disable-next-line no-var
+  var __ompChamberModelsCache: { data: ModelsData; expiresAt: number } | undefined;
+  // eslint-disable-next-line no-var
+  var __ompChamberProvidersRpcCache: { data: ProviderItem[]; expiresAt: number } | undefined;
+}
+
+/** Drops every cached model + provider registry snapshot. */
+export function invalidateModelsCaches(): void {
+  globalThis.__ompChamberModelsCache = undefined;
+  globalThis.__ompChamberProvidersRpcCache = undefined;
+}

package/src/shared/lib/models/thinking-levels.ts

@@ -0,0 +1,68 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Thinking-level resolution for the CURRENT model in the composer. Faithful
+ * port of omp-web/lib/thinking-levels.ts.
+ *
+ * `/api/models` carries each pickable model's baked effort ladder as
+ * `["off", ...efforts]`. A running session's `get_state` resolves the model
+ * omp is ACTUALLY using — which can differ from the session file's model
+ * entry (a disabled/renamed provider falls back to the default model, and the
+ * catalog only lists enabled providers). When the catalog misses the current
+ * model, the live metadata is the authoritative fallback, so the dropdown
+ * never falls back to the generic ladder and lists unsupported efforts.
+ */
+
+import type { ThinkingModelMeta } from '@/shared/types';
+
+const DEFAULT_THINKING_LEVELS = ['auto', 'off', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'] as const;
+
+/**
+ * Order the model's own ladder by the familiar sequence while preserving
+ * provider-defined additions. Returns an EMPTY list when the model provides no
+ * ladder — no generic fallback, no injected 'auto'. Callers must treat an empty
+ * result as "this model exposes no thinking levels" and disable the selector.
+ */
+export function selectableThinkingLevels(available: readonly string[] | null | undefined): string[] {
+  if (!available || available.length === 0) return [];
+
+  const remaining = new Set(available.filter((level) => level && level !== 'auto'));
+  const ordered = DEFAULT_THINKING_LEVELS.filter((level) => remaining.delete(level));
+  return [...ordered, ...remaining];
+}
+
+/** "off" is always a valid selector; concrete efforts come from the model. */
+export function thinkingLevelsForMeta(meta: ThinkingModelMeta): string[] {
+  if (!meta.reasoning) return ['off'];
+  return ['off', ...(meta.thinking?.efforts ?? [])];
+}
+
+/**
+ * Normalize an omp `thinking_level_change` value for display: a concrete
+ * level string passes through trimmed; null/undefined/empty collapse to
+ * `off`. Callers only invoke this when a change record actually exists, so
+ * "no record" (undefined return upstream) stays distinct from "off".
+ */
+export function normalizeThinkingLevel(level: unknown): string {
+  return typeof level === 'string' && level.trim() ? level.trim() : 'off';
+}
+
+/**
+ * Levels offered for the current model: the catalog's baked ladder wins; the
+ * live session model backs non-catalog models. Returns null when neither
+ * source knows the model — callers then fall back to the generic ladder.
+ */
+export function resolveAvailableThinkingLevels(
+  catalogLevels: string[] | undefined,
+  model: { provider: string; modelId: string } | null,
+  liveModel: ThinkingModelMeta | null,
+): string[] | null {
+  if (catalogLevels && catalogLevels.length > 0) return catalogLevels;
+  if (model && liveModel && liveModel.provider === model.provider && liveModel.modelId === model.modelId) {
+    return thinkingLevelsForMeta(liveModel);
+  }
+  return null;
+}

package/src/shared/lib/omp/config/access-mode.server.ts

@@ -0,0 +1,27 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Server-only reader for the persisted tool-approval ("access") mode. Split
+ * from access-mode.ts so the client bundle never pulls in `@/db.server`.
+ */
+
+import { getDb } from '@/server/db.server';
+import { ACCESS_MODE_SETTING_KEY, DEFAULT_APPROVAL_MODE, isApprovalMode, type ApprovalMode } from '@/shared/lib/omp/config/access-mode';
+
+/** Read the persisted access mode, defaulting on a missing row or any error.
+ *  The generic settings writer stores non-object values with String(value), so
+ *  the row holds the bare mode (`always-ask`, not `"always-ask"`) — validate it
+ *  raw rather than assuming JSON.parse succeeds. */
+export async function loadPersistedAccessMode(): Promise<ApprovalMode> {
+  try {
+    const db = await getDb();
+    const row = await db.get('SELECT value FROM app_settings WHERE key = ?', [ACCESS_MODE_SETTING_KEY]);
+    const value: unknown = row?.value;
+    return isApprovalMode(value) ? value : DEFAULT_APPROVAL_MODE;
+  } catch {
+    return DEFAULT_APPROVAL_MODE;
+  }
+}

package/src/shared/lib/omp/config/access-mode.ts

@@ -0,0 +1,31 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Tool-approval ("access") mode for a spawned omp process. Client-safe: this
+ * module must not import anything server-only, because the composer reads the
+ * type/constants in the browser while the route reads them server-side.
+ *
+ * omp's contract (pi-coding-agent ApprovalMode): `always-ask` auto-runs
+ * read-tier tools and prompts for write+exec, `write` auto-runs read+write and
+ * prompts for exec, `yolo` auto-runs everything.
+ */
+
+export type ApprovalMode = 'always-ask' | 'write' | 'yolo';
+
+export const DEFAULT_APPROVAL_MODE: ApprovalMode = 'always-ask';
+
+export const APPROVAL_MODES: readonly ApprovalMode[] = ['always-ask', 'write', 'yolo'];
+
+/** `app_settings` key the composer persists its pick under. */
+export const ACCESS_MODE_SETTING_KEY = 'omp_access_mode';
+
+export function isApprovalMode(value: unknown): value is ApprovalMode {
+  return typeof value === 'string' && APPROVAL_MODES.some((mode) => mode === value);
+}
+
+export function normalizeApprovalMode(value: unknown): ApprovalMode {
+  return isApprovalMode(value) ? value : DEFAULT_APPROVAL_MODE;
+}

package/src/shared/lib/omp/config/schema-extras.ts

@@ -0,0 +1,230 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Chamber-side UI metadata for settings that oh-my-pi's docs catalog
+ * documents but that upstream's settings schema gives no `ui` block —
+ * upstream's own panel hides them. These rows restore the documented
+ * surface: they render in the same tab/group layout, edit through the same
+ * editors, and write through `omp config set`/`reset` like every other row.
+ *
+ * Deliberately still hidden (matching upstream intent):
+ *  - `auth.broker.url` / `auth.broker.token` — "Hidden from the UI; populate
+ *    via env vars" (upstream schema comment); env takes precedence anyway.
+ *  - `searxng.token` / `searxng.basicPassword` — credential markers with no
+ *    UI upstream; the SearXNG endpoint row remains editable.
+ *  - `modelRoles` — has a dedicated role editor in this panel instead.
+ */
+
+import type { SchemaEntry } from '@/shared/lib/omp/config/schema-types';
+
+export const SCHEMA_EXTRAS: Record<string, SchemaEntry> = {
+  // ── Retry & Fallback ─────────────────────────────────────────────────────
+  'retry.enabled': {
+    type: 'boolean',
+    default: true,
+    ui: {
+      tab: 'model',
+      group: 'Retry & Fallback',
+      label: 'Retry Enabled',
+      description: 'Retry transient provider errors (rate limits, outages, quota walls).',
+    },
+  },
+  'retry.baseDelayMs': {
+    type: 'number',
+    default: 500,
+    ui: {
+      tab: 'model',
+      group: 'Retry & Fallback',
+      label: 'Retry Base Delay (ms)',
+      description: 'Initial backoff before the first retry.',
+    },
+  },
+
+  // ── Thinking budgets ─────────────────────────────────────────────────────
+  'thinkingBudgets.minimal': {
+    type: 'number',
+    default: 1024,
+    ui: { tab: 'model', group: 'Thinking', label: 'Minimal Thinking Budget', description: 'Token budget for the minimal thinking level.' },
+  },
+  'thinkingBudgets.low': {
+    type: 'number',
+    default: 2048,
+    ui: { tab: 'model', group: 'Thinking', label: 'Low Thinking Budget', description: 'Token budget for the low thinking level.' },
+  },
+  'thinkingBudgets.medium': {
+    type: 'number',
+    default: 8192,
+    ui: { tab: 'model', group: 'Thinking', label: 'Medium Thinking Budget', description: 'Token budget for the medium thinking level.' },
+  },
+  'thinkingBudgets.high': {
+    type: 'number',
+    default: 16384,
+    ui: { tab: 'model', group: 'Thinking', label: 'High Thinking Budget', description: 'Token budget for the high thinking level.' },
+  },
+  'thinkingBudgets.xhigh': {
+    type: 'number',
+    default: 32768,
+    ui: { tab: 'model', group: 'Thinking', label: 'XHigh Thinking Budget', description: 'Token budget for the xhigh thinking level.' },
+  },
+  'thinkingBudgets.max': {
+    type: 'number',
+    default: 32768,
+    ui: { tab: 'model', group: 'Thinking', label: 'Max Thinking Budget', description: 'Token budget for the max thinking level.' },
+  },
+
+  // ── Model roles / tags / cycles ──────────────────────────────────────────
+  modelTags: {
+    type: 'record',
+    default: {},
+    ui: {
+      tab: 'model',
+      group: 'Prompt',
+      label: 'Model Tags',
+      description: 'Custom role/tag metadata; can introduce additional roles. JSON record.',
+    },
+  },
+  modelProviderOrder: {
+    type: 'array',
+    default: [],
+    ui: {
+      tab: 'model',
+      group: 'Prompt',
+      label: 'Model Provider Order',
+      description: 'Preferred provider order when a model id is ambiguous. JSON array.',
+    },
+  },
+  cycleOrder: {
+    type: 'array',
+    default: ['smol', 'default', 'slow'],
+    ui: {
+      tab: 'model',
+      group: 'Prompt',
+      label: 'Model Cycle Order',
+      description: 'Roles cycled by the model switcher. JSON array.',
+    },
+  },
+  enabledModels: {
+    type: 'array',
+    default: [],
+    ui: {
+      tab: 'model',
+      group: 'Prompt',
+      label: 'Enabled Models',
+      description: 'Allow-list of models; supports path-scoped entries. Empty means all available models. JSON array.',
+    },
+  },
+
+  // ── Sampling (per-agent tier overrides) ──────────────────────────────────
+  'task.agentServiceTierOverrides': {
+    type: 'record',
+    default: {},
+    ui: {
+      tab: 'model',
+      group: 'Sampling',
+      label: 'Agent Service Tier Overrides',
+      description: 'Sparse exact-name service-tier overrides for agents spawned by task/eval dispatch. JSON record.',
+    },
+  },
+
+  // ── Compaction ───────────────────────────────────────────────────────────
+  'compaction.reserveTokens': {
+    type: 'number',
+    ui: {
+      tab: 'context',
+      group: 'Compaction',
+      label: 'Compaction Reserve Tokens',
+      description: 'Absolute reserve floor. Unset = larger of 16384 and 15% of the context window.',
+    },
+  },
+  'compaction.keepRecentTokens': {
+    type: 'number',
+    default: 20000,
+    ui: {
+      tab: 'context',
+      group: 'Compaction',
+      label: 'Keep Recent Tokens',
+      description: 'Recent tokens always preserved through compaction.',
+    },
+  },
+  'compaction.autoContinue': {
+    type: 'boolean',
+    default: true,
+    ui: {
+      tab: 'context',
+      group: 'Compaction',
+      label: 'Auto-Continue',
+      description: 'Continue automatically after compaction.',
+    },
+  },
+
+  // ── Memory / auto-learn ──────────────────────────────────────────────────
+  'autolearn.minToolCalls': {
+    type: 'number',
+    default: 5,
+    ui: {
+      tab: 'memory',
+      group: 'Auto-Learn',
+      label: 'Min Tool Calls',
+      description: 'Only nudge after a turn that used at least this many tools.',
+      condition: 'autolearnActive',
+    },
+  },
+
+  // ── Shell ────────────────────────────────────────────────────────────────
+  shellPath: {
+    type: 'string',
+    ui: {
+      tab: 'shell',
+      group: 'Bash',
+      label: 'Shell Path',
+      description: 'Override the shell binary used by bash.',
+    },
+  },
+  'bash.autoBackground.thresholdMs': {
+    type: 'number',
+    default: 60000,
+    ui: {
+      tab: 'shell',
+      group: 'Bash',
+      label: 'Auto-Background Threshold (ms)',
+      description: 'Threshold before auto-backgrounding long-running commands.',
+    },
+  },
+
+  // ── Tasks / subagents ────────────────────────────────────────────────────
+  'task.agentAdvisor': {
+    type: 'record',
+    default: {},
+    ui: {
+      tab: 'tasks',
+      group: 'Subagents',
+      label: 'Agent Advisor Overrides',
+      description: 'Per-agent subagent advisor: agent name → "on" / "off" / advisor model pattern. JSON record.',
+    },
+  },
+
+  // ── Providers ────────────────────────────────────────────────────────────
+  enabledProviders: {
+    type: 'array',
+    default: [],
+    ui: {
+      tab: 'providers',
+      group: 'Services',
+      label: 'Enabled Providers',
+      description: 'Foreign user-level discovery sources to load; supports path-scoped entries. JSON array.',
+    },
+  },
+  disabledProviders: {
+    type: 'array',
+    default: [],
+    ui: {
+      tab: 'providers',
+      group: 'Services',
+      label: 'Disabled Providers',
+      description: 'Disabled model/discovery providers; supports path-scoped entries. JSON array.',
+    },
+  },
+};

package/src/shared/lib/omp/config/schema-types.ts

@@ -0,0 +1,49 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Static schema metadata for the native `omp` settings panel, extracted from
+ * oh-my-pi's `packages/coding-agent/src/config/settings-schema.ts` (the
+ * single source of truth for every setting: type, default, enum values, and
+ * UI placement in tab/group). The JSON mirror lives in
+ * `app/data/settings/omp-schema.json`; this module types it for the UI.
+ */
+
+export interface SchemaOption {
+  value: string;
+  label: string;
+  description: string;
+}
+
+export interface SchemaUi {
+  tab: string;
+  group?: string;
+  label: string;
+  description: string;
+  warning?: string;
+  condition?: string;
+  options?: SchemaOption[] | 'runtime';
+  ordered?: boolean;
+}
+
+export interface SchemaEntry {
+  type: 'boolean' | 'string' | 'number' | 'enum' | 'array' | 'record';
+  default?: unknown;
+  values?: string[];
+  credential?: boolean;
+  ui: SchemaUi;
+}
+
+export interface SchemaTab {
+  id: string;
+  label: string;
+  groups: string[];
+}
+
+export interface OmpSchema {
+  source: string;
+  tabs: SchemaTab[];
+  entries: Record<string, SchemaEntry>;
+}

package/src/shared/lib/omp/config/schema.ts

@@ -0,0 +1,81 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Runtime schema access for the OMP Engine settings panel. The static
+ * schema JSON (extracted from oh-my-pi's settings-schema.ts) drives tab,
+ * group, label, and editor shape; live values come from the omp config CLI
+ * bridge. Condition names mirror upstream's `CONDITIONS` map in
+ * packages/coding-agent/src/modes/components/settings-defs.ts — entries with
+ * a `ui.condition` render only when the condition holds.
+ */
+
+import schemaJson from '@/client/data/settings/omp-schema.json';
+import type { OmpSchema, SchemaEntry } from '@/shared/lib/omp/config/schema-types';
+import type { ConfigEntry } from '@/server/lib/omp/config/config-cli';
+import { SCHEMA_EXTRAS } from '@/shared/lib/omp/config/schema-extras';
+
+export const OMP_SCHEMA = schemaJson as unknown as OmpSchema;
+
+/** All UI entries: upstream schema plus chamber-documented extras. */
+export const ALL_SCHEMA_ENTRIES: Record<string, SchemaEntry> = {
+  ...OMP_SCHEMA.entries,
+  ...SCHEMA_EXTRAS,
+};
+
+/** Live value for a key from the config snapshot; undefined when unset. */
+export function configValue(entries: Record<string, ConfigEntry>, key: string): unknown {
+  return entries[key]?.value;
+}
+
+/**
+ * Evaluate a `ui.condition` against the live config snapshot. Conditions
+ * that describe the host terminal (macOS, image protocol) always hold in
+ * the chamber web view, which has neither platform limitation.
+ */
+export function isConditionMet(condition: string | undefined, entries: Record<string, ConfigEntry>): boolean {
+  switch (condition) {
+    case undefined:
+      return true;
+    case 'advisorEnabled':
+      return configValue(entries, 'advisor.enabled') === true;
+    case 'vimModeEnabled':
+      return configValue(entries, 'tui.vimMode') === true;
+    case 'hindsightActive':
+      return configValue(entries, 'memory.backend') === 'hindsight';
+    case 'mnemopiActive':
+      return configValue(entries, 'memory.backend') === 'mnemopi';
+    case 'autolearnActive':
+      return configValue(entries, 'autolearn.enabled') === true;
+    case 'autoThinkingActive':
+      return configValue(entries, 'defaultThinkingLevel') === 'auto';
+    case 'usageAwareFallbackEnabled':
+      return configValue(entries, 'retry.usageAwareFallback') === true;
+    case 'planModeEnabled':
+      return configValue(entries, 'plan.enabled') === true;
+    case 'planAutosaveEnabled':
+      return configValue(entries, 'plan.enabled') === true && configValue(entries, 'plan.autosave') === true;
+    case 'unexpectedStopSmart':
+      return configValue(entries, 'features.unexpectedStopDetection') === 'smart';
+    case 'macOS':
+    case 'hasImageProtocol':
+      return true;
+    default:
+      return true;
+  }
+}
+
+/** Entries for one tab, in schema declaration order (extras last). */
+export function entriesForTab(tabId: string): Array<[string, SchemaEntry]> {
+  return Object.entries(ALL_SCHEMA_ENTRIES).filter(([, entry]) => entry.ui.tab === tabId);
+}
+
+/** True when the row matches the search query (key, label, or description). */
+export function matchesSearch(key: string, entry: SchemaEntry, query: string): boolean {
+  if (!query) return true;
+  return key.toLowerCase().includes(query)
+    || entry.ui.label.toLowerCase().includes(query)
+    || entry.ui.description.toLowerCase().includes(query);
+}