ompchamber 0.8.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/sessions/index.ts

@@ -1,12 +1,11 @@
 import { actionBindings, bindingsFor, type HandlerBinding } from '@/server/lib/route-adapter';
 import * as sessionsList from '@/server/routes/sessions/list';
 import * as sessionsFolder from '@/server/routes/sessions/folder';
+import * as sessionsQueue from '@/server/routes/sessions/queue';
 import {
   archiveSession,
-  getQueue,
   getSessionState,
   markSeen,
-  putQueue,
   putSessionState,
   renameSession,
 } from '@/server/routes/sessions/session';
@@ -16,7 +15,16 @@ export const sessionsBindings: HandlerBinding[] = [
   ...bindingsFor(sessionsList, '/api/sessions/list'),
   ...bindingsFor(sessionsFolder, '/api/sessions/:sessionId'),
   ...actionBindings(archiveSession, '/api/sessions/:sessionId/archive'),
-  ...actionBindings(putQueue, '/api/sessions/:sessionId/queue', getQueue),
+  // Per-item queue routes. `actionBindings` mounts ALL four mutating verbs on
+  // one path, and Elysia lets a later registration override an earlier one —
+  // mounting reorder on the same `/queue` path that way would clobber the
+  // add/GET bindings with its 405 GET fallback. Only reorder gets an explicit
+  // PUT-only binding; add carries the shared GET loader.
+  ...actionBindings(sessionsQueue.addQueueItem, '/api/sessions/:sessionId/queue', sessionsQueue.getQueue),
+  ...actionBindings(sessionsQueue.editQueueItem, '/api/sessions/:sessionId/queue/:itemId'),
+  { method: 'PUT', path: '/api/sessions/:sessionId/queue', handler: sessionsQueue.reorderQueueItems },
+  { method: 'DELETE', path: '/api/sessions/:sessionId/queue/:itemId', handler: sessionsQueue.removeQueueItem },
+  ...actionBindings(sessionsQueue.nudgeQueueDelivery, '/api/sessions/:sessionId/queue/deliver'),
   ...actionBindings(renameSession, '/api/sessions/:sessionId/rename'),
   ...actionBindings(putSessionState, '/api/sessions/:sessionId/state', getSessionState),
   ...actionBindings(markSeen, '/api/sessions/:sessionId/stream-seen'),

package/src/server/routes/sessions/queue.ts

@@ -0,0 +1,121 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Per-item follow-up queue routes (`queued_messages` table). The client panel
+ * is a VIEW: every mutation goes through one of these endpoints and returns
+ * the canonical queue, so the client never ships a full-list replacement
+ * (that shape is what let a reload wipe the table and a session switch copy
+ * one session's queue into another).
+ */
+
+import { json } from '@/server/lib/remix-compat';
+import type { ActionFunctionArgs, LoaderFunctionArgs } from '@/server/lib/remix-compat';
+import { requireParam } from '@/server/lib/route-adapter';
+import {
+  appendQueueItem,
+  deleteQueueItem,
+  listQueue,
+  patchQueueItem,
+  reorderQueue,
+} from '@/server/lib/queue/store.server';
+import { getRpcSession } from '@/server/lib/omp/rpc/manager';
+import { scheduleQueueDelivery } from '@/server/lib/queue/delivery.server';
+
+/** GET — the session's queued follow-ups in delivery order. */
+export async function getQueue({ params }: LoaderFunctionArgs) {
+  const sessionId = requireParam(params, 'sessionId');
+  if (!sessionId) return json({ error: 'Session ID is required' }, { status: 400 });
+  return json({ queue: await listQueue(sessionId) });
+}
+
+/**
+ * POST — append one queued item. Body: `{ text, attachments?, model? }`.
+ * Returns the canonical queue.
+ */
+export async function addQueueItem({ request, params }: ActionFunctionArgs) {
+  const sessionId = requireParam(params, 'sessionId');
+  if (!sessionId) return json({ error: 'Session ID is required' }, { status: 400 });
+  if (request.method !== 'POST') return json({ error: 'Method not allowed' }, { status: 405 });
+
+  const body = (await request.json().catch(() => null)) as Record<string, unknown> | null;
+  if (!body || typeof body.text !== 'string' || (!body.text.trim() && !Array.isArray(body.attachments))) {
+    return json({ error: 'Invalid body: expected { text: string, attachments?, model? }' }, { status: 400 });
+  }
+  const queue = await appendQueueItem(sessionId, {
+    text: body.text,
+    attachments: body.attachments,
+    model: body.model,
+  });
+  return json({ queue });
+}
+
+/**
+ * PATCH — edit one item's text and/or model snapshot. Body: `{ text?, model? }`.
+ * Returns the canonical queue; 404 when the id is unknown or already claimed.
+ */
+export async function editQueueItem({ request, params }: ActionFunctionArgs) {
+  const sessionId = requireParam(params, 'sessionId');
+  if (!sessionId) return json({ error: 'Session ID is required' }, { status: 400 });
+  if (request.method !== 'PATCH') return json({ error: 'Method not allowed' }, { status: 405 });
+
+  const itemId = params.itemId;
+  if (!itemId) return json({ error: 'Item ID is required' }, { status: 400 });
+  const body = (await request.json().catch(() => null)) as Record<string, unknown> | null;
+  if (!body) return json({ error: 'Invalid JSON body' }, { status: 400 });
+
+  const queue = await patchQueueItem(sessionId, itemId, { text: body.text, model: body.model });
+  if (!queue) return json({ error: 'Queue item not found' }, { status: 404 });
+  return json({ queue });
+}
+
+/**
+ * DELETE — remove one item by id. 404 when it was already claimed for
+ * delivery or never existed (both leave nothing to remove).
+ */
+export async function removeQueueItem({ request, params }: ActionFunctionArgs) {
+  const sessionId = requireParam(params, 'sessionId');
+  if (!sessionId) return json({ error: 'Session ID is required' }, { status: 400 });
+  if (request.method !== 'DELETE') return json({ error: 'Method not allowed' }, { status: 405 });
+
+  const itemId = params.itemId;
+  if (!itemId) return json({ error: 'Item ID is required' }, { status: 400 });
+  const removed = await deleteQueueItem(sessionId, itemId);
+  if (!removed) return json({ error: 'Queue item not found' }, { status: 404 });
+  return json({ success: true });
+}
+
+/**
+ * PUT — reorder the queue to exactly `{ orderedIds: string[] }` (a drag in the
+ * panel ships ids only, never item payloads). Returns the canonical queue.
+ */
+export async function reorderQueueItems({ request, params }: ActionFunctionArgs) {
+  const sessionId = requireParam(params, 'sessionId');
+  if (!sessionId) return json({ error: 'Session ID is required' }, { status: 400 });
+  if (request.method !== 'PUT') return json({ error: 'Method not allowed' }, { status: 405 });
+
+  const body = (await request.json().catch(() => null)) as { orderedIds?: unknown } | null;
+  if (!body || !Array.isArray(body.orderedIds) || body.orderedIds.some((id) => typeof id !== 'string')) {
+    return json({ error: 'Invalid body: expected { orderedIds: string[] }' }, { status: 400 });
+  }
+  return json({ queue: await reorderQueue(sessionId, body.orderedIds) });
+}
+
+/**
+ * POST /queue/deliver — client nudge: a tab that (re)opens a session offers
+ * the server a delivery slot. The server-side claim makes this a no-op when a
+ * run is active or the head was already claimed; an idle session with queued
+ * items gets its head delivered exactly once.
+ */
+export async function nudgeQueueDelivery({ request, params }: ActionFunctionArgs) {
+  const sessionId = requireParam(params, 'sessionId');
+  if (!sessionId) return json({ error: 'Session ID is required' }, { status: 400 });
+  if (request.method !== 'POST') return json({ error: 'Method not allowed' }, { status: 405 });
+
+  const session = getRpcSession(sessionId);
+  if (!session?.isAlive()) return json({ success: true, delivered: false, reason: 'session-not-live' });
+  scheduleQueueDelivery(session);
+  return json({ success: true });
+}