ompchamber 1.0.0 → 1.1.0

package/src/server/routes/models/root.ts

@@ -3,190 +3,28 @@ import type { ActionFunctionArgs, LoaderFunctionArgs } from '@/server/lib/remix-
 import { getDb } from '@/server/db.server';
 import { INITIAL_MODELS_CATALOG } from '@/client/data/models/catalog';
 import { isMockMode } from '@/server/mock.server';
-import type { AIModelOption, ModelEntry, ModelsData, ProviderItem } from '@/shared/types';
+import type { AIModelOption, ModelsData, ProviderItem } from '@/shared/types';
 import { readSettingsJson, writeSettingsJson } from '@/server/lib/db/settings-store';
-import { runUtilityCommand, type OmpModel } from '@/server/lib/omp/rpc/utility';
-import { readDisabledProviders } from '@/server/lib/omp/config/roles';
-import { invalidateModelsCaches } from '@/shared/lib/models/server-cache';
+import { modelKey } from '@/shared/lib/models/identity';
+import {
+  EMPTY_MODELS,
+  SAFE_MODEL_LOAD_FAILURE_MESSAGE,
+  invalidateModelsCache,
+  loadModelsWithCache,
+  readStoredProvidersForModels,
+} from '@/server/lib/models/registry.server';
+import {
+  readModelPreferencesFor,
+  recordRecentPreference,
+  toggleFavoritePreference,
+} from '@/server/lib/models/preferences.server';
 
 const MODELS_CATALOG_KEY = 'omp_models_catalog';
 const SELECTED_MODEL_KEY = 'omp_selected_model';
-const PROVIDERS_CONFIG_KEY = 'omp_providers_config';
 
-const MODELS_CACHE_TTL_MS = 60_000;
-const SAFE_MODEL_LOAD_FAILURE_MESSAGE = 'Model list is temporarily unavailable. Check your configuration and try again.';
-
-const modelNameCollator = new Intl.Collator(undefined, { numeric: true, sensitivity: 'base' });
-
-function compareModelEntries(a: { id: string; name: string; provider: string }, b: { id: string; name: string; provider: string }): number {
-  return modelNameCollator.compare(a.name || a.id, b.name || b.id)
-    || modelNameCollator.compare(a.provider, b.provider)
-    || modelNameCollator.compare(a.id, b.id);
-}
-
-// "off" is always a valid selector; the concrete efforts come from the model's
-// baked thinking metadata (omp: getSupportedEfforts = reasoning ? efforts : []).
-function thinkingLevelsFor(model: OmpModel): string[] {
-  if (!model.reasoning) return ['off'];
-  return ['off', ...(model.thinking?.efforts ?? [])];
-}
-
-function supportsFastMode(model: OmpModel): boolean {
-  return model.provider === 'anthropic' || model.provider === 'openai' || model.provider === 'google';
-}
-
-/**
- * Disabled providers recorded in the chamber's own provider overlay. Used only
- * by the MOCK path of `/api/models`, which has no config.yml `disabledProviders`
- * to read — real mode gets the same answer natively.
- */
-async function readStoredProvidersForModels(): Promise<ProviderItem[]> {
-  try {
-    const db = await getDb();
-    const parsed = await readSettingsJson<unknown>(db, PROVIDERS_CONFIG_KEY, null);
-    if (!Array.isArray(parsed)) return [];
-    return parsed.filter((provider): provider is ProviderItem => (
-      typeof provider === 'object' && provider !== null
-      && typeof (provider as ProviderItem).slug === 'string'
-      && (provider as ProviderItem).disabled === true
-    ));
-  } catch {
-    return [];
-  }
-}
-
-function hiddenModelKey(provider: string, modelId: string): string {
-  return `${provider.trim().toLowerCase()}:${modelId}`;
-}
-
-async function readHiddenModelKeys(): Promise<Set<string>> {
-  try {
-    const db = await getDb();
-    const parsed = await readSettingsJson<unknown>(db, PROVIDERS_CONFIG_KEY, null);
-    if (!Array.isArray(parsed)) return new Set();
-    const hidden = new Set<string>();
-    for (const provider of parsed) {
-      if (typeof provider?.slug !== 'string' || !Array.isArray(provider.models)) continue;
-      for (const model of provider.models) {
-        if (typeof model?.id === 'string' && model.isVisible === false) {
-          hidden.add(hiddenModelKey(provider.slug, model.id));
-        }
-      }
-    }
-    return hidden;
-  } catch {
-    return new Set();
-  }
-}
-
-/**
- * A model is offered only when its provider is neither disabled in omp's
- * config.yml (`disabledProviders`) nor carrying a per-model hide in the
- * chamber overlay. Disabling the provider is the coarse switch — Settings →
- * Providers flips it so the whole provider leaves the chat picker.
- */
-function filterSelectableModels(
-  available: OmpModel[],
-  disabledProviders: Set<string>,
-  hiddenModelKeys: Set<string>,
-): OmpModel[] {
-  return available.filter((model) => (
-    !disabledProviders.has(model.provider)
-    && !hiddenModelKeys.has(hiddenModelKey(model.provider, model.id))
-  ));
-}
-
-async function loadModels(): Promise<ModelsData> {
-  const availableResponse = await runUtilityCommand<{ models?: unknown }>(
-    { type: 'get_available_models' },
-    120_000,
-  );
-  const available = Array.isArray(availableResponse.models)
-    ? availableResponse.models
-        .filter((model): model is OmpModel => (
-          typeof model === 'object' && model !== null
-          && typeof (model as OmpModel).id === 'string'
-          && typeof (model as OmpModel).provider === 'string'
-        ))
-        .map((model) => ({
-          ...model,
-          name: typeof model.name === 'string' && model.name.trim().length > 0 ? model.name : model.id,
-        }))
-    : [];
-
-  const disabledProviders = await readDisabledProviders();
-  const hiddenModelKeys = await readHiddenModelKeys();
-  const nameMap: Record<string, string> = {};
-  const thinkingLevels: Record<string, string[]> = {};
-  const modelList: ModelEntry[] = filterSelectableModels(available, disabledProviders, hiddenModelKeys)
-    .map((m) => ({
-      id: m.id,
-      name: m.name,
-      provider: m.provider,
-      thinkingLevels: thinkingLevelsFor(m),
-      supportsFastMode: supportsFastMode(m),
-      contextWindow: m.contextWindow ?? undefined,
-      maxTokens: m.maxTokens ?? undefined,
-      cost: m.cost,
-    }))
-    .sort(compareModelEntries);
-
-  const loginResponse = await runUtilityCommand<{ providers?: unknown }>(
-    { type: 'get_login_providers' },
-    30_000,
-  );
-  const loginProviders = Array.isArray(loginResponse.providers)
-    ? loginResponse.providers.filter((provider): provider is { id: string; name: string; authenticated: boolean } => (
-      typeof provider === 'object' && provider !== null
-      && typeof (provider as { id?: unknown }).id === 'string'
-      && typeof (provider as { name?: unknown }).name === 'string'
-      && typeof (provider as { authenticated?: unknown }).authenticated === 'boolean'
-    ))
-    : [];
-  const connectedProviders = loginProviders
-    .filter((provider) => provider.authenticated)
-    .map((provider) => ({ id: provider.id, name: provider.name, disabled: disabledProviders.has(provider.id) }));
-  for (const m of available) {
-    const key = `${m.provider}:${m.id}`;
-    nameMap[key] = m.name;
-    thinkingLevels[key] = thinkingLevelsFor(m);
-  }
-
-  let defaultModel: { provider: string; modelId: string } | null = null;
-  try {
-    const state = await runUtilityCommand<{ model?: { provider?: string; id?: string } }>(
-      { type: 'get_state' },
-      30_000,
-    );
-    const provider = state.model?.provider;
-    const modelId = state.model?.id;
-    if (provider && modelId && available.some((m) => m.provider === provider && m.id === modelId)) {
-      defaultModel = { provider, modelId };
-    }
-  } catch {
-    // Default model is cosmetic — the models list is still useful without it.
-  }
-
-  return { models: nameMap, modelList, defaultModel, thinkingLevels, connectedProviders };
-}
-
-const EMPTY_MODELS: ModelsData = {
-  models: {},
-  modelList: [],
-  defaultModel: null,
-  thinkingLevels: {},
-};
-
-async function loadModelsWithCache(): Promise<ModelsData> {
-  const cached = globalThis.__ompChamberModelsCache;
-  if (cached && cached.expiresAt > Date.now()) return cached.data;
-  const data = await loadModels();
-  globalThis.__ompChamberModelsCache = { data, expiresAt: Date.now() + MODELS_CACHE_TTL_MS };
-  return data;
-}
-
-function invalidateModelsCache(): void {
-  invalidateModelsCaches();
+/** Error text for a 500 envelope without leaking a non-Error throw as `undefined`. */
+function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
 }
 
 /** Parse a persisted { provider, modelId|id } reference without trusting the JSON shape. */
@@ -200,7 +38,7 @@ function readSelectedModelRef(value: unknown): { provider: string; modelId: stri
 }
 
 /** The user's persisted pick resolved against the live registry; null when stale or unparseable. */
-async function loadPersistedModelOption(modelList: ModelEntry[]): Promise<AIModelOption | null> {
+async function loadPersistedModelOption(modelList: ModelsData['modelList']): Promise<AIModelOption | null> {
   try {
     const db = await getDb();
     const selected = readSelectedModelRef(await readSettingsJson<unknown>(db, SELECTED_MODEL_KEY, null));
@@ -220,37 +58,44 @@ async function loadPersistedModelOption(modelList: ModelEntry[]): Promise<AIMode
   }
 }
 
-export async function loader({ request }: LoaderFunctionArgs) {
-  const mock = isMockMode();
+/**
+ * MOCK mode keeps the SQLite-backed demo catalog, but the favorite/recent
+ * rails come from the same preference store as real mode — the catalog's own
+ * `isFavorite`/`isRecent` flags are only its seed.
+ */
+async function loadMockModels() {
+  const db = await getDb();
+  const catalog = await readSettingsJson<unknown>(db, MODELS_CATALOG_KEY, null);
+  const stored: AIModelOption[] = Array.isArray(catalog) && catalog.length > 0 ? catalog : INITIAL_MODELS_CATALOG;
+  // Demo mode has no config.yml to read, so the disable flag lives on the
+  // stored provider overlay. Filtering here keeps the model picker honest
+  // in MOCK=true too — the settings page must be able to prove the switch.
+  const disabledSlugs = new Set(
+    (await readStoredProvidersForModels()).map((provider: ProviderItem) => provider.slug.trim().toLowerCase()),
+  );
+  const models = stored.filter((model) => !disabledSlugs.has(model.provider.trim().toLowerCase()));
+  const persisted = await readSettingsJson<AIModelOption | null>(db, SELECTED_MODEL_KEY, null);
+  // Every provider disabled ⇒ empty list and no selection; the composer must
+  // see that honestly instead of holding on to a hidden provider's model.
+  let selectedModel: AIModelOption | null = models[5] || models[0] || null;
+  if (persisted && persisted.id && persisted.provider) {
+    const match = models.find(m => m.id === persisted.id && m.provider === persisted.provider);
+    if (match) selectedModel = match;
+  }
+  return { models, selectedModel, modelPreferences: await readModelPreferencesFor(models), isMock: true };
+}
 
+export async function loader({ request }: LoaderFunctionArgs) {
   // MOCK mode keeps the SQLite-backed catalog (chamber demo behavior).
-  if (mock) {
+  if (isMockMode()) {
     try {
-      const db = await getDb();
-      const catalog = await readSettingsJson<unknown>(db, MODELS_CATALOG_KEY, null);
-      const stored: AIModelOption[] = Array.isArray(catalog) && catalog.length > 0 ? catalog : INITIAL_MODELS_CATALOG;
-      // Demo mode has no config.yml to read, so the disable flag lives on the
-      // stored provider overlay. Filtering here keeps the model picker honest
-      // in MOCK=true too — the settings page must be able to prove the switch.
-      const disabledSlugs = new Set(
-        (await readStoredProvidersForModels()).map((provider) => provider.slug.trim().toLowerCase()),
-      );
-      const models = stored.filter((model) => !disabledSlugs.has(model.provider.trim().toLowerCase()));
-      const persisted = await readSettingsJson<AIModelOption | null>(db, SELECTED_MODEL_KEY, null);
-      // Every provider disabled ⇒ empty list and no selection; the composer must
-      // see that honestly instead of holding on to a hidden provider's model.
-      let selectedModel: AIModelOption | null = models[5] || models[0] || null;
-      if (persisted && persisted.id && persisted.provider) {
-        const match = models.find(m => m.id === persisted.id && m.provider === persisted.provider);
-        if (match) selectedModel = match;
-      }
-      return json({ models, selectedModel, isMock: mock });
-    } catch (error: any) {
+      return json(await loadMockModels());
+    } catch (error: unknown) {
       return json({
-        error: error.message,
+        error: errorMessage(error),
         models: INITIAL_MODELS_CATALOG,
         selectedModel: INITIAL_MODELS_CATALOG[5] || INITIAL_MODELS_CATALOG[0] || null,
-        isMock: mock,
+        isMock: true,
       }, { status: 500 });
     }
   }
@@ -261,8 +106,13 @@ export async function loader({ request }: LoaderFunctionArgs) {
   void request;
   try {
     const data = await loadModelsWithCache();
-    // The selection changes independently of the 60s registry cache.
-    return json({ ...data, selectedModel: await loadPersistedModelOption(data.modelList) });
+    // The selection and the preferences change independently of the 60s
+    // registry cache, so both are read fresh on every request.
+    return json({
+      ...data,
+      selectedModel: await loadPersistedModelOption(data.modelList),
+      modelPreferences: await readModelPreferencesFor(data.modelList),
+    });
   } catch {
     return json({ ...EMPTY_MODELS, modelError: SAFE_MODEL_LOAD_FAILURE_MESSAGE });
   }
@@ -272,23 +122,42 @@ export async function action({ request }: ActionFunctionArgs) {
   try {
     const db = await getDb();
     const body = await request.json();
+    const mock = isMockMode();
 
     const catalog = await readSettingsJson<unknown>(db, MODELS_CATALOG_KEY, null);
     // The shipped demo catalog is MOCK-only: a real install starts from an empty
     // list, so a demo model can never be persisted into its stored catalog.
     let models: AIModelOption[] = Array.isArray(catalog)
       ? catalog
-      : (isMockMode() ? INITIAL_MODELS_CATALOG : []);
+      : (mock ? INITIAL_MODELS_CATALOG : []);
 
     const { actionType, modelId, provider, thinkingLevel, model, models: newModels } = body;
 
+    /**
+     * Composite keys the registry currently serves. Preference writes prune
+     * against it so a model that left models.yml — or whose provider was
+     * disconnected — cannot hold one of the five recent slots. Real mode reads
+     * the same 60s-cached registry the loader serves; MOCK uses its demo list.
+     */
+    const knownModelKeys = async (): Promise<Set<string>> => {
+      const live = mock ? models : (await loadModelsWithCache()).modelList;
+      return new Set(live.map((entry) => modelKey(entry)));
+    };
+
     // Model-scoped mutations must match provider + id: the registry serves the
     // same model id from several providers, so an id-only match rewrites the
     // first provider's entry instead of the one the user acted on.
     if (actionType === 'toggleFavorite' && modelId && provider) {
-      models = models.map(m => m.id === modelId && m.provider === provider ? { ...m, isFavorite: !m.isFavorite } : m);
-      await writeSettingsJson(db, MODELS_CATALOG_KEY, models);
-      return json({ success: true, models });
+      // Favorites live in the preference store, NOT in the model catalog: the
+      // catalog is a MOCK-only demo list that real mode never reads back, so a
+      // star written there vanished on the next render.
+      const preferences = await toggleFavoritePreference(modelKey({ provider, id: modelId }), await knownModelKeys());
+      // Keep the demo catalog's flag in step so MOCK mode's own views agree.
+      if (mock) {
+        models = models.map(m => m.id === modelId && m.provider === provider ? { ...m, isFavorite: !m.isFavorite } : m);
+        await writeSettingsJson(db, MODELS_CATALOG_KEY, models);
+      }
+      return json({ success: true, models, modelPreferences: preferences });
     }
 
     if (actionType === 'setThinking' && modelId && provider && thinkingLevel) {
@@ -308,8 +177,12 @@ export async function action({ request }: ActionFunctionArgs) {
       const parsedModel = readSelectedModelRef(model);
       if (parsedModel) {
         invalidateModelsCache();
-        // Live set_model against the current session is handled by the agent
-        // RPC bridge; here we only persist the selection for session spawn.
+        // "The user picked this model" is one event: recording the recent here
+        // keeps a second request from ever disagreeing with the selection.
+        await recordRecentPreference(
+          modelKey({ provider: parsedModel.provider, id: parsedModel.modelId }),
+          await knownModelKeys(),
+        );
       }
       return json({ success: true, selectedModel: model });
     }
@@ -326,7 +199,7 @@ export async function action({ request }: ActionFunctionArgs) {
     }
 
     return json({ error: 'Invalid action or parameters' }, { status: 400 });
-  } catch (error: any) {
-    return json({ error: error.message }, { status: 500 });
+  } catch (error: unknown) {
+    return json({ error: errorMessage(error) }, { status: 500 });
   }
 }

package/src/server/routes/settings/commands.ts

@@ -5,6 +5,7 @@ import { getDb } from '@/server/db.server';
 import { DEFAULT_COMMANDS_LIST } from '@/client/data/settings/command';
 import { isMockMode } from '@/server/mock.server';
 import type { CommandItem } from '@/shared/types';
+import { isRecord } from '@/shared/lib/util/guards';
 import { createSettingsListStore } from '@/server/lib/db/settings-store';
 import { runUtilityCommand } from '@/server/lib/omp/rpc/utility';
 
@@ -16,27 +17,67 @@ const commandsStore = createSettingsListStore<CommandItem>({
   plural: 'commands',
 });
 
-/** Read live agent commands (skill/custom/extension/file sources) via RPC. */
+/** Command sources the chamber surfaces in the composer (mcp_prompt is not user-typable). */
+const AGENT_COMMAND_SOURCES: Record<string, true> = {
+  builtin: true,
+  skill: true,
+  custom: true,
+  extension: true,
+  file: true,
+};
+
+/**
+ * Live slash commands from the agent's `get_available_commands`, mapped into
+ * the chamber's CommandItem. Aliases, subcommands and the argument hint ride
+ * along: they are what the composer's `/` popup needs to behave like omp's own
+ * editor (`/models` completing to the alias, `/fast ` offering on|off|status).
+ * Anything malformed is dropped rather than trusted.
+ */
+function toLiveCommandItem(value: unknown): CommandItem | null {
+  if (!isRecord(value)) return null;
+  const name = typeof value.name === 'string' ? value.name : '';
+  if (!name) return null;
+  if (typeof value.source !== 'string' || !AGENT_COMMAND_SOURCES[value.source]) return null;
+
+  const aliases = Array.isArray(value.aliases)
+    ? value.aliases.filter((alias): alias is string => typeof alias === 'string' && alias.length > 0)
+    : [];
+
+  const hint = isRecord(value.input) && typeof value.input.hint === 'string' ? value.input.hint : undefined;
+
+  const subcommands = Array.isArray(value.subcommands)
+    ? value.subcommands.flatMap((sub) => {
+        if (!isRecord(sub) || typeof sub.name !== 'string' || !sub.name) return [];
+        return [{
+          name: sub.name,
+          ...(typeof sub.description === 'string' ? { description: sub.description } : {}),
+          ...(typeof sub.usage === 'string' ? { usage: sub.usage } : {}),
+        }];
+      })
+    : [];
+
+  return {
+    id: `omp-live-${name}`,
+    name,
+    description: typeof value.description === 'string' ? value.description : '',
+    scope: 'user',
+    template: `/${name}`,
+    isBuiltIn: true,
+    ...(aliases.length ? { aliases } : {}),
+    ...(subcommands.length ? { subcommands } : {}),
+    ...(hint ? { inputHint: hint } : {}),
+  };
+}
+
+/** Read live agent commands (builtin/skill/custom/extension/file sources) via RPC. */
 async function loadAgentCommands(): Promise<CommandItem[]> {
   try {
     const data = await runUtilityCommand<{ commands?: unknown }>({ type: 'get_available_commands' }, 30_000);
-    const available = Array.isArray(data.commands) ? data.commands : [];
-    const agentSources = new Set(['builtin', 'skill', 'custom', 'extension', 'file']);
-    return available
-      .filter((c) => agentSources.has((c as { source?: string })?.source ?? ''))
-      .map((c) => {
-        const command = c as { name?: string; description?: string; source?: string };
-        const name = typeof command.name === 'string' ? command.name : '';
-        return {
-          id: `omp-live-${name}`,
-          name,
-          description: typeof command.description === 'string' ? command.description : '',
-          scope: 'user' as const,
-          template: `/${name}`,
-          isBuiltIn: true,
-        };
-      })
-      .filter((c) => c.name.length > 0);
+    if (!Array.isArray(data.commands)) return [];
+    return data.commands.flatMap((command) => {
+      const item = toLiveCommandItem(command);
+      return item ? [item] : [];
+    });
   } catch {
     return [];
   }

package/src/shared/lib/chat/composer/client.ts

@@ -56,8 +56,13 @@ export function toFilePickItems(files: FsFileEntry[]): ComposerPickItem[] {
 }
 
 /**
- * Combine commands (`/name`) then skills (`/skill:name`). A skill is skipped
- * when a command already covers its plain name or `skill:<name>`; commands win.
+ * Combine live command items (`/name`, including omp's own `skill:<name>`
+ * entries) with the chamber's skill list. Commands win: a skill whose plain or
+ * `skill:`-namespaced name a command already covers is skipped, so the two
+ * sources never double-list the same skill.
+ *
+ * The description carries the argument hint exactly as oh-my-pi renders it
+ * (`[on|off|status] - Toggle fast mode`) so the popup matches the CLI.
  */
 export function mergeCommandAndSkillItems(commands: CommandItem[], skills: SkillItem[]): ComposerPickItem[] {
   const result: ComposerPickItem[] = [];
@@ -67,13 +72,17 @@ export function mergeCommandAndSkillItems(commands: CommandItem[], skills: Skill
     const key = command.name.toLowerCase();
     if (seen.has(key)) continue;
     seen.add(key);
+    const description = command.description ?? '';
     result.push({
       id: `command-${command.name}`,
       name: command.name,
-      description: command.description,
-      kind: 'command',
-      source: 'command',
+      description: command.inputHint ? (description ? `${command.inputHint} - ${description}` : command.inputHint) : description,
+      kind: command.name.toLowerCase().startsWith('skill:') ? 'skill' : 'command',
+      source: command.name.toLowerCase().startsWith('skill:') ? 'skill' : 'command',
       token: `/${command.name}`,
+      ...(command.aliases?.length ? { aliases: command.aliases } : {}),
+      ...(command.subcommands?.length ? { subcommands: command.subcommands } : {}),
+      ...(command.inputHint ? { inputHint: command.inputHint } : {}),
     });
   }
 
@@ -84,11 +93,11 @@ export function mergeCommandAndSkillItems(commands: CommandItem[], skills: Skill
     seen.add(prefixed);
     result.push({
       id: `skill-${skill.name}`,
-      name: skill.name,
+      name: prefixed,
       description: skill.description,
-      kind: 'command',
+      kind: 'skill',
       source: 'skill',
-      token: `/skill:${skill.name}`,
+      token: `/${prefixed}`,
     });
   }