@schlessera/brain-ui-server 0.21.0 → 0.24.0

package/src/routes/models.ts

@@ -18,8 +18,12 @@ import type { BackendRegistry } from "../agent/backend.js";
 import type { ModelPricingState } from "../pricing/model-pricing.js";
 import {
   getBillingOverrides,
+  getCustomOpenRouterModels,
+  getDefaultModelId,
   getHiddenModelIds,
   setBillingOverrides,
+  setCustomOpenRouterModels,
+  setDefaultModelId,
   setHiddenModelIds,
 } from "../db/settings.js";
 
@@ -49,8 +53,12 @@ export function createModelRoutes(deps: {
   }));
 
   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 +104,78 @@ 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/billing", async (c) => {
     const body = (await c.req.json().catch(() => null)) as unknown;
     const billing = (body as { billing?: unknown } | null)?.billing;

package/src/routes/pi-auth.ts

@@ -0,0 +1,153 @@
+/**
+ * Provider sign-in over the pi backend's OAuth service — the Settings UI's
+ * path to logging in to OpenAI (ChatGPT Plus/Pro, device-code flow) without a
+ * shell on the host.
+ *
+ * The pi package is an OPTIONAL peer: it is reached only through
+ * `loadBackendModule("pi")` and typed as a local structural mirror, per the
+ * declaration-surface rules. The routes are live only when pi profiles are
+ * configured (BRAIN_UI_PI_PROFILES, or AGENT_BACKEND=pi) — provider ids are
+ * validated against the CONFIGURED roster's vendors, so an authenticated
+ * client still cannot start login flows for arbitrary providers.
+ *
+ * Mount BEHIND the /api auth guard: an open login-start endpoint would let
+ * anyone mint OpenAI device codes against this server.
+ */
+
+import { Hono } from "hono";
+import type { AgentConfig } from "../config/env.js";
+import { loadBackendModule, parsePiProfiles } from "../agent/backend.js";
+
+/** Structural mirror of the pi package's PiLoginFlow (primitives only). */
+export interface PiLoginFlowView {
+  id: string;
+  providerId: string;
+  status: "pending" | "success" | "error" | "cancelled";
+  userCode?: string;
+  verificationUri?: string;
+  intervalSeconds?: number;
+  expiresInSeconds?: number;
+  error?: string;
+  startedAt: number;
+}
+
+/** Structural mirror of the pi package's PiAuthProviderStatus. */
+export interface PiAuthProviderStatusView {
+  providerId: string;
+  name: string;
+  configured: boolean;
+  source?: string;
+  oauth: boolean;
+}
+
+/** Structural mirror of the pi package's PiAuth service. */
+interface PiAuthMirror {
+  status(providerIds: string[]): Promise<PiAuthProviderStatusView[]>;
+  startLogin(providerId: string): Promise<PiLoginFlowView>;
+  getFlow(id: string): PiLoginFlowView | null;
+  cancelFlow(id: string): void;
+  logout(providerId: string): Promise<void>;
+}
+
+export interface PiAuthRoutesDeps {
+  agent: AgentConfig;
+  /** Test seam — forwarded to loadBackendModule. */
+  importer?: (specifier: string) => Promise<unknown>;
+}
+
+export function createPiAuthRoutes(deps: PiAuthRoutesDeps): Hono {
+  const { agent } = deps;
+
+  /**
+   * Vendors the deployment actually configured — the only providers this
+   * surface may touch. Empty when pi is not in play at all.
+   */
+  function allowedProviders(): string[] {
+    const fromProfiles = parsePiProfiles(agent.piProfilesJson, agent.profilesJson).map(
+      (profile) => profile.vendor
+    );
+    return [...new Set(fromProfiles)];
+  }
+
+  const piConfigured = () =>
+    Boolean(agent.piProfilesJson) || (agent.backend || "claude") === "pi";
+
+  // One service for the app's lifetime: it owns the pending-flow state.
+  let authPromise: Promise<PiAuthMirror> | null = null;
+  function getAuth(): Promise<PiAuthMirror> {
+    if (!authPromise) {
+      authPromise = (async () => {
+        const mod = (await loadBackendModule("pi", deps.importer)) as {
+          createPiAuth?: () => PiAuthMirror;
+        };
+        if (typeof mod.createPiAuth !== "function") {
+          throw new Error(
+            '"@schlessera/brain-backend-pi" does not export createPiAuth — update the package.'
+          );
+        }
+        return mod.createPiAuth();
+      })();
+      authPromise.catch(() => {
+        authPromise = null;
+      });
+    }
+    return authPromise;
+  }
+
+  return new Hono()
+    .get("/pi-auth/providers", async (c) => {
+      // Not-configured is a normal state, not an error: the client hides the
+      // whole card on an empty list.
+      if (!piConfigured()) return c.json({ providers: [] });
+      const providers = allowedProviders();
+      if (providers.length === 0) return c.json({ providers: [] });
+      const auth = await getAuth();
+      return c.json({ providers: await auth.status(providers) });
+    })
+    .post("/pi-auth/login", async (c) => {
+      const body = (await c.req.json().catch(() => null)) as {
+        providerId?: unknown;
+      } | null;
+      const providerId = typeof body?.providerId === "string" ? body.providerId : "";
+      if (!piConfigured()) {
+        return c.json({ error: "The pi backend is not configured." }, 409);
+      }
+      if (!providerId || !allowedProviders().includes(providerId)) {
+        return c.json({ error: "Unknown provider." }, 400);
+      }
+      const auth = await getAuth();
+      try {
+        const flow = await auth.startLogin(providerId);
+        return c.json({ flow });
+      } catch (err) {
+        // e.g. a provider whose flow the web surface cannot drive.
+        return c.json(
+          { error: err instanceof Error ? err.message : "Could not start login." },
+          400
+        );
+      }
+    })
+    .get("/pi-auth/login/:id", async (c) => {
+      const auth = await getAuth();
+      const flow = auth.getFlow(c.req.param("id"));
+      if (!flow) return c.json({ error: "Unknown login flow." }, 404);
+      return c.json({ flow });
+    })
+    .delete("/pi-auth/login/:id", async (c) => {
+      const auth = await getAuth();
+      auth.cancelFlow(c.req.param("id"));
+      return c.json({ ok: true });
+    })
+    .post("/pi-auth/logout", async (c) => {
+      const body = (await c.req.json().catch(() => null)) as {
+        providerId?: unknown;
+      } | null;
+      const providerId = typeof body?.providerId === "string" ? body.providerId : "";
+      if (!providerId || !allowedProviders().includes(providerId)) {
+        return c.json({ error: "Unknown provider." }, 400);
+      }
+      const auth = await getAuth();
+      await auth.logout(providerId);
+      return c.json({ ok: true });
+    });
+}

package/src/ws/bridge.ts

@@ -35,6 +35,10 @@ export function makeBridge(
         // Echo the client's correlation id, so it can recognise which
         // announcement is its own rather than adopting the first to arrive.
         if (turn.draftId) msg = { ...msg, draftId: turn.draftId };
+        // The host owns backend identity: stamp it authoritatively so an
+        // injected backend that omits (or mislabels) it still scopes the
+        // client's tool rendering correctly.
+        msg = { ...msg, backendId };
         coordinator.bySession.set(msg.sessionId, turn);
         // Persist ownership the moment the identity exists — a turn that
         // later fails or is cancelled must not leave an unowned transcript.

package/src/ws/connection.ts

@@ -104,6 +104,7 @@ export function createWsHandlers(host: WsHost) {
               sessionId: sid,
               isNew: false,
               providerId: turn.providerId ?? catalog.getStoredProviderId(sid) ?? undefined,
+              backendId: catalog.getStoredBackendId(sid) ?? turn.backend.id,
             },
             turn
           )

package/src/ws/dispatch.ts

@@ -196,6 +196,7 @@ export async function handleClientMessage(
         sessionId: msg.sessionId,
         isNew: false,
         providerId: catalog.getStoredProviderId(msg.sessionId) ?? undefined,
+        backendId: catalog.getStoredBackendId(msg.sessionId) ?? undefined,
       });
 
       try {

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 } : {}) };