ompchamber 1.0.0 → 1.1.0

package/src/server/lib/models/registry.server.ts

@@ -0,0 +1,206 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Assembly of the chat model registry that `GET /api/models` serves: the omp
+ * registry (auth providers + models.yml) narrowed by the provider/model hides
+ * the operator set, plus the live session's default model.
+ *
+ * Extracted from `routes/models/root.ts` so the route keeps only its loader and
+ * action, and so the preference store can share the same model list.
+ */
+
+import { getDb } from '@/server/db.server';
+import { PROVIDERS_SETTINGS_KEY } from '@/server/lib/models/provider-registry.server';
+import { readSettingsJson } from '@/server/lib/db/settings-store';
+import { readDisabledProviders } from '@/server/lib/omp/config/roles';
+import { runUtilityCommand, type OmpModel } from '@/server/lib/omp/rpc/utility';
+import { invalidateModelsCaches } from '@/shared/lib/models/server-cache';
+import type { ModelsData, ProviderItem } from '@/shared/types';
+
+const MODELS_CACHE_TTL_MS = 60_000;
+export 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.
+ */
+function isDisabledStoredProvider(value: unknown): value is ProviderItem {
+  if (typeof value !== 'object' || value === null) return false;
+  const candidate = value as ProviderItem;
+  return typeof candidate.slug === 'string' && candidate.disabled === true;
+}
+
+export async function readStoredProvidersForModels(): Promise<ProviderItem[]> {
+  try {
+    const db = await getDb();
+    const parsed = await readSettingsJson<unknown>(db, PROVIDERS_SETTINGS_KEY, null);
+    if (!Array.isArray(parsed)) return [];
+    return parsed.filter(isDisabledStoredProvider);
+  } 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_SETTINGS_KEY, null);
+    if (!Array.isArray(parsed)) return new Set();
+    const hidden = new Set<string>();
+    for (const provider of parsed) {
+      if (typeof provider !== 'object' || provider === null) continue;
+      const { slug, models } = provider as { slug?: unknown; models?: unknown };
+      if (typeof slug !== 'string' || !Array.isArray(models)) continue;
+      for (const model of models) {
+        if (typeof model !== 'object' || model === null) continue;
+        const { id, isVisible } = model as { id?: unknown; isVisible?: unknown };
+        if (typeof id === 'string' && isVisible === false) hidden.add(hiddenModelKey(slug, 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))
+  ));
+}
+
+function isOmpModelEntry(value: unknown): value is OmpModel {
+  if (typeof value !== 'object' || value === null) return false;
+  const candidate = value as OmpModel;
+  return typeof candidate.id === 'string' && typeof candidate.provider === 'string';
+}
+
+function isLoginProvider(value: unknown): value is { id: string; name: string; authenticated: boolean } {
+  if (typeof value !== 'object' || value === null) return false;
+  const candidate = value as { id?: unknown; name?: unknown; authenticated?: unknown };
+  return typeof candidate.id === 'string'
+    && typeof candidate.name === 'string'
+    && typeof candidate.authenticated === 'boolean';
+}
+
+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(isOmpModelEntry)
+        .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 = 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(isLoginProvider)
+    : [];
+  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 };
+}
+
+export const EMPTY_MODELS: ModelsData = {
+  models: {},
+  modelList: [],
+  defaultModel: null,
+  thinkingLevels: {},
+};
+
+export 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;
+}
+
+export function invalidateModelsCache(): void {
+  invalidateModelsCaches();
+}

package/src/server/lib/omp/rpc/utility.ts

@@ -22,7 +22,13 @@ import { RpcProcess } from '@/server/lib/omp/rpc/process';
 
 // Extensions stay ENABLED: they can register models and login providers, and
 // omitting them made the web UI's model/provider lists disagree with the CLI's.
-const UTILITY_EXTRA_ARGS = ['--no-session', '--no-skills', '--no-lsp'];
+//
+// Skills stay ENABLED too. `--no-skills` made `get_available_commands` omit
+// every `skill:<name>` entry (measured: 45 commands without, 52 with), so the
+// composer's `/` popup could not offer the skills omp happily executes — and
+// the chamber's own disk scan missed provider roots omp reads (`~/.agents/skills`).
+// Cost is nil: the ready frame lands at the same ~420ms either way.
+const UTILITY_EXTRA_ARGS = ['--no-session', '--no-lsp'];
 const READY_TIMEOUT_MS = 60_000;
 // Longer than the 60s models-cache TTL on purpose: with idle-kill == TTL every
 // pause past a minute paid a cold multi-second respawn on top of the stale

package/src/server/lib/queue/delivery.server.test.ts

@@ -0,0 +1,203 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The follow-up queue must never wedge.
+ *
+ * A scheduled delivery whose timer never runs (a `bun --hot` module
+ * re-evaluation discards the pending closure; a wedged event loop drops the
+ * callback) used to poison the session permanently: the in-flight guard
+ * early-returned on the leftover entry, so no later trigger — another
+ * agent_end, a tab's mount nudge — could ever schedule again. The queue simply
+ * stopped draining, with no error anywhere. Observed live: a dev server whose
+ * `setTimeout` from request handlers had stopped firing left every queued
+ * follow-up stranded, while a freshly started server delivered the identical
+ * item correctly.
+ *
+ * The store is mocked so the contract under test is delivery's own: which RPCs
+ * a claimed item produces, and that a lost timer is superseded rather than
+ * allowed to wedge the session. Time is driven by fake timers, so nothing here
+ * waits on the wall clock.
+ */
+
+import { afterAll, afterEach, beforeEach, describe, expect, jest, mock, test } from 'bun:test';
+import type { QueuedMessage } from '@/shared/types/chat';
+import type { QueueDeliveryHost } from '@/server/lib/queue/delivery.server';
+
+/** In-memory stand-in for the SQLite-backed queue. */
+const queue = new Map<string, QueuedMessage[]>();
+
+mock.module('@/server/lib/queue/store.server', () => ({
+  claimHeadQueueItem: (sessionId: string): QueuedMessage | null => {
+    const items = queue.get(sessionId);
+    return items?.shift() ?? null;
+  },
+  requeueHeadQueueItem: async (sessionId: string, item: QueuedMessage): Promise<void> => {
+    const items = queue.get(sessionId) ?? [];
+    items.unshift(item);
+    queue.set(sessionId, items);
+  },
+}));
+
+const { scheduleQueueDelivery } = await import('@/server/lib/queue/delivery.server');
+
+const MODEL = { provider: 'kenari', modelId: 'deepseek-v4-pro', thinkingLevel: 'max', accessMode: 'yolo' as const };
+
+function queueItem(text: string, model: QueuedMessage['model'] = MODEL): QueuedMessage {
+  return { id: `item-${text}`, text, attachments: [], model };
+}
+
+/** Records the RPCs a delivery pushes at the session. */
+function makeHost(sessionId: string) {
+  const sent: Record<string, unknown>[] = [];
+  const host: QueueDeliveryHost = {
+    sessionId,
+    isAlive: () => true,
+    isBusy: () => false,
+    send: async (command) => {
+      sent.push(command);
+      return {};
+    },
+  };
+  return { host, sent };
+}
+
+/** Let the delivery's promise chain settle without advancing the clock. */
+async function flush(): Promise<void> {
+  for (let i = 0; i < 20; i++) await Promise.resolve();
+}
+
+let sessionId = '';
+let counter = 0;
+
+beforeEach(() => {
+  sessionId = `queue-test-${counter++}`;
+  queue.clear();
+  jest.useFakeTimers();
+});
+
+afterEach(() => {
+  jest.useRealTimers();
+});
+
+afterAll(() => {
+  mock.restore();
+});
+
+describe('queue delivery', () => {
+  test('delivers the head with the model snapshot it was queued with', async () => {
+    queue.set(sessionId, [queueItem('queued hello')]);
+    const { host, sent } = makeHost(sessionId);
+
+    scheduleQueueDelivery(host);
+    jest.advanceTimersByTime(600);
+    await flush();
+
+    expect(sent).toEqual([
+      { type: 'set_model', provider: 'kenari', modelId: 'deepseek-v4-pro' },
+      { type: 'set_thinking_level', level: 'max' },
+      { type: 'prompt', message: 'queued hello', accessMode: 'yolo' },
+    ]);
+    expect(queue.get(sessionId)).toEqual([]);
+  });
+
+  test("an 'auto' thinking level is left to the session", async () => {
+    queue.set(sessionId, [queueItem('no level', { ...MODEL, thinkingLevel: 'auto' })]);
+    const { host, sent } = makeHost(sessionId);
+
+    scheduleQueueDelivery(host);
+    jest.advanceTimersByTime(600);
+    await flush();
+
+    expect(sent).toEqual([
+      { type: 'set_model', provider: 'kenari', modelId: 'deepseek-v4-pro' },
+      { type: 'prompt', message: 'no level', accessMode: 'yolo' },
+    ]);
+  });
+
+  test('an item with no model snapshot is sent without touching the model', async () => {
+    queue.set(sessionId, [queueItem('session model', null)]);
+    const { host, sent } = makeHost(sessionId);
+
+    scheduleQueueDelivery(host);
+    jest.advanceTimersByTime(600);
+    await flush();
+
+    expect(sent).toEqual([{ type: 'prompt', message: 'session model' }]);
+  });
+
+  test('a busy session holds the item instead of sending it', async () => {
+    queue.set(sessionId, [queueItem('held')]);
+    const { host, sent } = makeHost(sessionId);
+    host.isBusy = () => true;
+
+    scheduleQueueDelivery(host);
+    jest.advanceTimersByTime(600);
+    await flush();
+
+    expect(sent).toEqual([]);
+    expect(queue.get(sessionId)?.length).toBe(1);
+  });
+
+  test('a failed dispatch returns the item to the head', async () => {
+    queue.set(sessionId, [queueItem('retry me')]);
+    const { host } = makeHost(sessionId);
+    host.send = async () => {
+      throw new Error('rpc down');
+    };
+
+    scheduleQueueDelivery(host);
+    jest.advanceTimersByTime(600);
+    await flush();
+
+    expect(queue.get(sessionId)?.map((i) => i.text)).toEqual(['retry me']);
+  });
+
+  test('repeated triggers deliver the head exactly once', async () => {
+    queue.set(sessionId, [queueItem('once')]);
+    const { host, sent } = makeHost(sessionId);
+
+    scheduleQueueDelivery(host);
+    scheduleQueueDelivery(host);
+    scheduleQueueDelivery(host);
+    jest.advanceTimersByTime(600);
+    await flush();
+
+    expect(sent.filter((c) => c.type === 'prompt').length).toBe(1);
+    expect(queue.get(sessionId)).toEqual([]);
+  });
+
+  test('a lost timer delays the queue instead of wedging it', async () => {
+    queue.set(sessionId, [queueItem('recovered')]);
+    const { host, sent } = makeHost(sessionId);
+
+    // A delivery was scheduled but its callback never ran — the entry is left
+    // behind, which is exactly what a hot-reloaded module or a wedged event
+    // loop leaves. `clearAllTimers` drops the pending callback WITHOUT running
+    // it, so the bookkeeping outlives the timer.
+    scheduleQueueDelivery(host);
+    jest.clearAllTimers();
+    jest.advanceTimersByTime(600);
+    await flush();
+    expect(sent).toEqual([]);
+
+    // Inside the staleness bound a new trigger still defers to the pending
+    // entry: the head must not be double-booked.
+    jest.advanceTimersByTime(1000);
+    scheduleQueueDelivery(host);
+    jest.advanceTimersByTime(600);
+    await flush();
+    expect(sent).toEqual([]);
+
+    // Past it, a later trigger recovers the queue rather than giving up.
+    jest.advanceTimersByTime(5000);
+    scheduleQueueDelivery(host);
+    jest.advanceTimersByTime(600);
+    await flush();
+
+    expect(sent.filter((c) => c.type === 'prompt').length).toBe(1);
+    expect(queue.get(sessionId)).toEqual([]);
+  });
+});

package/src/server/lib/queue/delivery.server.ts

@@ -28,16 +28,36 @@ import type { QueuedMessage } from '@/shared/types/chat';
  *  the same child, and an instant dispatch races it. */
 const DELIVERY_DELAY_MS = 500;
 
+/**
+ * How long a scheduled-but-not-yet-run delivery may sit before the next
+ * trigger supersedes it.
+ *
+ * Without this, one lost timer wedges the session's queue FOREVER: the guard
+ * below early-returns on any existing entry, so nothing would ever schedule
+ * again. A timer can be lost without the process dying — `bun --hot`
+ * re-evaluating this module discards the pending closure, and a wedged event
+ * loop drops the callback — and the symptom is silent: the queue simply never
+ * drains and no error is reported. Past this bound the entry is presumed lost
+ * and rescheduled, so a client nudge (sent whenever a session with queued
+ * items mounts or regains focus) always recovers the queue.
+ */
+const DELIVERY_STALE_MS = 5_000;
+
+interface PendingDelivery {
+  timer: ReturnType<typeof setTimeout>;
+  /** Wall-clock after which this entry is presumed lost and superseded. */
+  expiresAt: number;
+}
+
 /** Per-session pending delivery timer, so a second agent_end while one is
  *  already scheduled cannot double-book the head. */
-const pendingTimers = new Map<string, ReturnType<typeof setTimeout>>();
+const pendingTimers = new Map<string, PendingDelivery>();
 
 function clearPendingTimer(sessionId: string): void {
-  const timer = pendingTimers.get(sessionId);
-  if (timer !== undefined) {
-    clearTimeout(timer);
-    pendingTimers.delete(sessionId);
-  }
+  const entry = pendingTimers.get(sessionId);
+  if (entry === undefined) return;
+  clearTimeout(entry.timer);
+  pendingTimers.delete(sessionId);
 }
 
 /** Send one queued item to the session as a normal prompt. The model snapshot
@@ -79,15 +99,25 @@ export interface QueueDeliveryHost {
  * Schedule the next queued delivery for this session. Called on terminal
  * agent_end and on a client's mount nudge. Idempotent: an in-flight timer is
  * reused, a claimed head can only be won by one caller.
+ *
+ * A pending entry older than {@link DELIVERY_STALE_MS} is presumed lost (see
+ * that constant) and replaced, so a dropped timer delays the queue instead of
+ * wedging it.
  */
 export function scheduleQueueDelivery(session: QueueDeliveryHost): void {
   const sessionId = session.sessionId;
-  if (!sessionId || pendingTimers.has(sessionId)) return;
+  if (!sessionId) return;
+  const pending = pendingTimers.get(sessionId);
+  if (pending !== undefined) {
+    if (Date.now() < pending.expiresAt) return;
+    // Lost timer: clear it so its callback cannot also fire and double-deliver.
+    clearTimeout(pending.timer);
+  }
   const timer = setTimeout(() => {
     pendingTimers.delete(sessionId);
     void deliverNext(session);
   }, DELIVERY_DELAY_MS);
-  pendingTimers.set(sessionId, timer);
+  pendingTimers.set(sessionId, { timer, expiresAt: Date.now() + DELIVERY_STALE_MS });
 }
 
 async function deliverNext(session: QueueDeliveryHost): Promise<void> {