@schlessera/brain-ui-server 0.23.0 → 0.25.0

package/src/routes/models.ts

@@ -10,17 +10,25 @@ import { Hono } from "hono";
 import type { Database } from "bun:sqlite";
 import {
   isBillingMode,
+  isThinkingLevel,
   type BillingMode,
   type ModelCatalogEntry,
   type ModelCatalogResponse,
+  type ThinkingLevel,
 } from "@schlessera/brain-ui-sdk";
 import type { BackendRegistry } from "../agent/backend.js";
 import type { ModelPricingState } from "../pricing/model-pricing.js";
 import {
   getBillingOverrides,
+  getCustomOpenRouterModels,
+  getDefaultModelId,
   getHiddenModelIds,
+  getThinkingOverrides,
   setBillingOverrides,
+  setCustomOpenRouterModels,
+  setDefaultModelId,
   setHiddenModelIds,
+  setThinkingOverrides,
 } from "../db/settings.js";
 
 export function createModelRoutes(deps: {
@@ -37,6 +45,7 @@ export function createModelRoutes(deps: {
   const source = await registry.getModelSource();
   const hidden = new Set(getHiddenModelIds(db));
   const overrides = getBillingOverrides(db);
+  const thinking = getThinkingOverrides(db);
   // `billingMode` already rides each provider entry (the registry applies the
   // override last); the catalog additionally tags WHICH rows carry an explicit
   // override, so the settings screen can render auto vs forced.
@@ -46,11 +55,19 @@ export function createModelRoutes(deps: {
     ...profile,
     hidden: hidden.has(profile.id),
     ...(overrides[profile.id] ? { billingOverride: overrides[profile.id] } : {}),
+    // `thinkingLevel` on the profile is already the EFFECTIVE level (the
+    // registry applies overrides at read time); this tags which rows carry
+    // an explicit user choice, so the UI can render default vs forced.
+    ...(thinking[profile.id] ? { thinkingOverride: thinking[profile.id] } : {}),
   }));
 
   const state = source?.state();
+  const resolvedDefaultId = await registry.getPreferredProfileId();
   return {
     models,
+    defaultModelId: getDefaultModelId(db),
+    ...(resolvedDefaultId ? { resolvedDefaultId } : {}),
+    customModels: getCustomOpenRouterModels(db),
     refreshedAt: state?.refreshedAt ?? null,
     stale: state?.stale ?? false,
     discovery: {
@@ -96,6 +113,111 @@ export function createModelRoutes(deps: {
     return c.json(await buildCatalog());
   })
 
+  .put("/models/default", async (c) => {
+    const body = (await c.req.json().catch(() => null)) as unknown;
+    const defaultId = (body as { defaultId?: unknown } | null)?.defaultId;
+    if (defaultId !== null && typeof defaultId !== "string") {
+      return c.json({ error: "defaultId must be a profile id or null" }, 400);
+    }
+    if (typeof defaultId === "string") {
+      const known = await registry.listAllProviders({ includeHidden: true });
+      if (!known.some((profile) => profile.id === defaultId)) {
+        return c.json({ error: `Unknown profile id: ${defaultId}` }, 400);
+      }
+    }
+
+    setDefaultModelId(db, defaultId);
+    registry.invalidateProfiles();
+    return c.json(await buildCatalog());
+  })
+
+  .put("/models/custom", async (c) => {
+    const body = (await c.req.json().catch(() => null)) as unknown;
+    const models = (body as { models?: unknown } | null)?.models;
+    if (!Array.isArray(models) || models.some((id) => typeof id !== "string")) {
+      return c.json({ error: "models must be an array of OpenRouter model ids" }, 400);
+    }
+    // OpenRouter ids are "<org>/<model>", org and model from a small safe
+    // charset (e.g. "z.ai/glm-5.3-flash", "openai/gpt-oss-120b:nitro").
+    const ID_SHAPE = /^[A-Za-z0-9][\w.-]*\/[\w.:-]+$/;
+    const bad = (models as string[]).find((id) => !ID_SHAPE.test(id));
+    if (bad !== undefined) {
+      return c.json({ error: `Not an OpenRouter model id: "${bad}"` }, 400);
+    }
+
+    // A generated id ("openrouter:<model>") that collides with a profile
+    // another source owns (a pi profile, a discovered model) must be refused
+    // BEFORE persisting: stored, it would 500 every roster read until the
+    // setting is dug out of the database. An id the CLAUDE env already
+    // declares is fine — the merge dedupes it in the declared entry's favor.
+    const currentCustomIds = new Set(
+      getCustomOpenRouterModels(db).map((model) => `openrouter:${model}`)
+    );
+    const nonCustomIds = new Set(
+      (await registry.listAllProviders({ includeHidden: true }))
+        .filter((profile) => !currentCustomIds.has(profile.id))
+        .map((profile) => profile.id)
+    );
+    const collision = (models as string[])
+      .map((model) => `openrouter:${model}`)
+      .find((id) => nonCustomIds.has(id));
+    if (collision !== undefined) {
+      return c.json(
+        { error: `"${collision}" collides with an existing profile id.` },
+        400
+      );
+    }
+
+    setCustomOpenRouterModels(db, models as string[]);
+    registry.invalidateProfiles();
+
+    // A removal that takes the stored default's profile off the roster would
+    // strand the default on nothing; reset it to auto — but only when the
+    // profile is actually gone (an id the env also declares survives the
+    // removal of its custom duplicate).
+    const currentDefault = getDefaultModelId(db);
+    if (currentDefault) {
+      const roster = await registry.listAllProviders({ includeHidden: true });
+      if (!roster.some((profile) => profile.id === currentDefault)) {
+        setDefaultModelId(db, null);
+      }
+    }
+    return c.json(await buildCatalog());
+  })
+
+  .put("/models/thinking", async (c) => {
+    const body = (await c.req.json().catch(() => null)) as unknown;
+    const thinking = (body as { thinking?: unknown } | null)?.thinking;
+    if (
+      typeof thinking !== "object" ||
+      thinking === null ||
+      Array.isArray(thinking) ||
+      Object.values(thinking).some((level) => !isThinkingLevel(level))
+    ) {
+      return c.json(
+        { error: "thinking must map profile ids to a reasoning-effort level" },
+        400
+      );
+    }
+    // Only rows that actually take an effort level accept an override — a
+    // stray id would be stored dead weight and mislead the settings UI.
+    const known = await registry.listAllProviders({ includeHidden: true });
+    const supported = new Set(
+      known.filter((profile) => profile.thinkingLevel).map((profile) => profile.id)
+    );
+    const stray = Object.keys(thinking).find((id) => !supported.has(id));
+    if (stray !== undefined) {
+      return c.json(
+        { error: `Profile "${stray}" does not take a reasoning-effort level.` },
+        400
+      );
+    }
+
+    setThinkingOverrides(db, thinking as Record<string, ThinkingLevel>);
+    registry.invalidateProfiles();
+    return c.json(await buildCatalog());
+  })
+
   .put("/models/billing", async (c) => {
     const body = (await c.req.json().catch(() => null)) as unknown;
     const billing = (body as { billing?: unknown } | null)?.billing;

package/src/ws/routing.ts

@@ -33,6 +33,15 @@ export async function resolveTurnTarget(
     }
   }
 
+  // No explicit choice (fresh client, share, host-initiated action): the
+  // preferred default — the Settings-stored default model, else a connected
+  // subscription-auth profile — before the default backend's own first profile.
+  const preferred = await registry.getPreferredProfileId();
+  if (preferred) {
+    const backend = await registry.getBackendForProfile(preferred);
+    if (backend) return { backend, profileId: preferred };
+  }
+
   const backend = await registry.getDefaultBackend();
   const profileId = (await backend.listProfiles())[0]?.id;
   return { backend, ...(profileId ? { profileId } : {}) };