@schlessera/brain-ui-server 0.13.1 → 0.15.0

package/dist/agent/backend.js

@@ -1,27 +1,6 @@
 import { createRequire } from "module";
-import { createClaudeBackend, createModelSource, defineProfiles, } from "@schlessera/brain-backend-claude";
-import { getHiddenModelIds } from "../db/settings.js";
-/**
- * Backend registry for the deployment. Claude is always available.
- * `AGENT_BACKEND=pi` retains the legacy single-backend deployment mode when the
- * optional pi package is installed.
- *
- * The old five hardcoded personal inference profiles are gone: the Claude
- * backend ships the single "claude" default, and additional Anthropic-compatible
- * endpoints are declared via the BRAIN_UI_CLAUDE_PROFILES env var (documented in
- * .env.example) rather than in code.
- */
-const BRAIN_PATH = process.env.BRAIN_PATH || `${process.env.HOME || "/root"}/brain`;
-// The Claude Code native binary is not in node_modules — it is installed via
-// the official curl-bash installer (~/.local/bin/claude, symlinked to
-// /usr/local/bin/claude in the container). The Agent SDK can't always
-// auto-discover it, so hand it the explicit path; override with CLAUDE_CODE_PATH.
-const CLAUDE_CODE_PATH = process.env.CLAUDE_CODE_PATH || "/usr/local/bin/claude";
 const PROFILE_MEMO_MS = 5_000;
-let cachedRegistry = null;
-let profileSnapshot = null;
-let modelSource = null;
-async function createRegistry(backends, defaultBackendId) {
+function buildSnapshot(backends, defaultBackendId) {
     if (backends.length === 0) {
         throw new Error("Backend registry requires at least one backend.");
     }
@@ -35,290 +14,306 @@ async function createRegistry(backends, defaultBackendId) {
     ];
     return { backends: ordered, byId, defaultBackendId: resolvedDefaultId };
 }
-/** Recompute the profile roster (memoized), asserting cross-backend id uniqueness. */
-async function getProfileSnapshot() {
-    if (profileSnapshot && Date.now() - profileSnapshot.at < PROFILE_MEMO_MS) {
-        return profileSnapshot;
-    }
-    const registry = await getRegistry();
-    const byBackend = new Map();
-    const owners = new Map();
-    for (const backend of registry.backends) {
-        const profiles = await backend.listProfiles();
-        byBackend.set(backend.id, profiles);
-        for (const profile of profiles) {
-            const owner = owners.get(profile.id);
-            if (owner && owner !== backend.id) {
-                throw new Error(`Profile id collision across backends: "${profile.id}" is exposed by "${owner}" and "${backend.id}".`);
-            }
-            owners.set(profile.id, backend.id);
-        }
-    }
-    profileSnapshot = { at: Date.now(), byBackend, owners };
-    return profileSnapshot;
-}
-/** Drop the memo so the next read reflects a refresh or a settings change. */
-export function invalidateProfiles() {
-    profileSnapshot = null;
-}
-/**
- * The Claude backend's discovery source, once the registry is built. Null when
- * discovery is disabled or the deployment runs a different backend.
- */
-export async function getModelSource() {
-    await getRegistry();
-    return modelSource;
+const BACKEND_SPECIFIERS = {
+    claude: "@schlessera/brain-backend-claude",
+    pi: "@schlessera/brain-backend-pi",
+};
+function unknownBackendError(primary) {
+    return new Error(`AGENT_BACKEND="${primary}" does not match any configured backend ` +
+        `(expected "claude" or "pi").`);
 }
-/**
- * Hidden profile ids, from the settings table. Presentation only — a hidden
- * profile still resolves for sessions pinned to it. A db read failure must not
- * take the picker down, so it degrades to "nothing hidden".
- */
-function hiddenIds() {
-    try {
-        return new Set(getHiddenModelIds());
-    }
-    catch (err) {
-        console.warn(`[models] Could not read hidden models: ${err instanceof Error ? err.message : String(err)}`);
-        return new Set();
+function missingBackendError(primary) {
+    if (primary === "pi") {
+        return new Error('AGENT_BACKEND=pi but "@schlessera/brain-backend-pi" is not installed. ' +
+            "Add it (with its pi SDK dependencies) or set AGENT_BACKEND=claude.");
     }
+    return new Error(`AGENT_BACKEND=${primary} but "@schlessera/brain-backend-claude" is not installed. ` +
+        "Add it (it carries the Claude Agent SDK) or set AGENT_BACKEND=pi.");
 }
 /**
- * Model discovery is on unless explicitly disabled — except under a test
- * runner, where the default flips to off: discovery is a live call to the
- * Anthropic API, and a suite that silently depends on network access (and on
- * whatever credentials the developer happens to have exported) is flaky by
- * construction. Tests that want it set BRAIN_UI_MODEL_DISCOVERY=1 explicitly.
- */
-function modelDiscoveryEnabled() {
-    const raw = process.env.BRAIN_UI_MODEL_DISCOVERY?.trim().toLowerCase();
-    if (raw)
-        return !(raw === "0" || raw === "off" || raw === "false");
-    return process.env.NODE_ENV !== "test";
-}
-/** How long a discovery result stays fresh. Default 24h. */
-function modelTtlMs() {
-    const raw = Number(process.env.BRAIN_UI_MODEL_TTL_HOURS);
-    const hours = Number.isFinite(raw) && raw > 0 ? raw : 24;
-    return hours * 60 * 60 * 1000;
-}
-/**
- * Declared profiles (built-in default + BRAIN_UI_CLAUDE_PROFILES) plus every
- * discovered model whose id isn't already declared. Declared wins: the env stays
- * an override mechanism, and a hand-pinned entry keeps its label and endpoint.
+ * Boot-time guard: the SELECTED backend's package must at least RESOLVE, so a
+ * broken install refuses to start instead of reporting healthy and failing
+ * every agent turn (the guarantee the old static import gave, restored without
+ * giving up the lazy load — `require.resolve` never executes the module, so
+ * the Agent SDK still loads on first use only). Called by `createApp()` next
+ * to the auth assertions; skipped when an explicit registry is injected.
+ *
+ * An unrecognized AGENT_BACKEND fails here too, for the same reason.
  *
- * Memoized on the discovered array's identity — `createModelSource` swaps the
- * array only on a successful refresh, so steady state is one comparison.
+ * The `resolve` parameter exists for tests (simulating an absent package);
+ * production callers pass nothing.
  */
-let mergeCache = null;
-function mergeDiscovered(declared, discovered) {
-    if (mergeCache &&
-        mergeCache.declared === declared &&
-        mergeCache.discovered === discovered) {
-        return mergeCache.result;
-    }
-    const declaredIds = new Set(declared.map((profile) => profile.id));
-    const extra = discovered.filter((input) => !declaredIds.has(input.id));
-    const result = [...declared, ...defineProfiles(extra)];
-    mergeCache = { declared, discovered, result };
-    return result;
-}
-async function buildRegistry() {
-    const primary = (process.env.AGENT_BACKEND || "claude")
-        .trim()
-        .toLowerCase();
-    if (primary === "pi") {
-        const pi = buildPiBackend();
-        return createRegistry([pi], pi.id);
+export function assertBackendResolvable(agent, resolve = (specifier) => {
+    createRequire(import.meta.url).resolve(specifier);
+}) {
+    const primary = agent.backend || "claude";
+    if (!(primary in BACKEND_SPECIFIERS))
+        throw unknownBackendError(primary);
+    const key = primary;
+    try {
+        resolve(BACKEND_SPECIFIERS[key]);
     }
-    // Declared profiles are resolved EAGERLY so a malformed
-    // BRAIN_UI_CLAUDE_PROFILES still fails at boot rather than on first request.
-    const declared = loadClaudeProfiles();
-    modelSource = createModelSource({
-        brainPath: BRAIN_PATH,
-        enabled: modelDiscoveryEnabled(),
-        ttlMs: modelTtlMs(),
-    });
-    const claude = createClaudeBackend({
-        brainPath: BRAIN_PATH,
-        claudeCodePath: CLAUDE_CODE_PATH,
-        // A function, not an array: discovery refreshes in the background and the
-        // new roster has to be visible without restarting the process.
-        profiles: () => mergeDiscovered(declared, modelSource?.list() ?? []),
-    });
-    const backends = [claude];
-    // AGENT_BACKEND must name a configured backend. The in-process options are
-    // "claude" (default) and "pi" (handled above). An unrecognized value is a
-    // misconfiguration — fail loudly instead of silently coercing to claude and
-    // running on the wrong backend with nothing in the logs.
-    if (process.env.AGENT_BACKEND && !backends.some((b) => b.id === primary)) {
-        throw new Error(`AGENT_BACKEND="${primary}" does not match any configured backend ` +
-            `(expected "claude" or "pi").`);
+    catch {
+        throw missingBackendError(key);
     }
-    return createRegistry(backends, primary);
-}
-async function getRegistry() {
-    if (!cachedRegistry)
-        cachedRegistry = buildRegistry();
-    return cachedRegistry;
-}
-/** All configured backends, with the default backend first. */
-export async function getBackends() {
-    return (await getRegistry()).backends;
-}
-/** Find a configured backend by its stable id. */
-export async function getBackendById(id) {
-    return (await getRegistry()).byId.get(id);
-}
-/** The default backend used for new and legacy sessions. */
-export async function getDefaultBackend() {
-    const registry = await getRegistry();
-    return registry.byId.get(registry.defaultBackendId);
 }
-/** The stable id of the default backend. */
-export async function getDefaultBackendId() {
-    return (await getRegistry()).defaultBackendId;
-}
-/** Resolve the backend that owns a globally unique profile id. */
-export async function getBackendForProfile(profileId) {
-    const registry = await getRegistry();
-    // Deliberately resolved against the UNFILTERED roster: a session pinned to a
-    // profile the user later hid must keep running.
-    const snapshot = await getProfileSnapshot();
-    const backendId = snapshot.owners.get(profileId);
-    return backendId ? registry.byId.get(backendId) : undefined;
-}
-/** Resolve a persisted backend id, falling back for legacy/unknown sessions. */
-export async function getBackendForSession(backendId) {
-    if (backendId) {
-        const backend = await getBackendById(backendId);
-        if (backend)
-            return backend;
+export function createBackendRegistry(options) {
+    const { brainPath, agent } = options;
+    const getHidden = options.getHiddenModelIds ?? (() => []);
+    let cachedRegistry = null;
+    let modelSource = null;
+    /**
+     * Declared profiles (built-in default + BRAIN_UI_CLAUDE_PROFILES) plus every
+     * discovered model whose id isn't already declared. Declared wins: the env
+     * stays an override mechanism, and a hand-pinned entry keeps its label and
+     * endpoint.
+     *
+     * Memoized on the discovered array's identity — `createModelSource` swaps the
+     * array only on a successful refresh, so steady state is one comparison.
+     */
+    let mergeCache = null;
+    function mergeDiscovered(claude, declared, discovered) {
+        if (mergeCache &&
+            mergeCache.declared === declared &&
+            mergeCache.discovered === discovered) {
+            return mergeCache.result;
+        }
+        const declaredIds = new Set(declared.map((profile) => profile.id));
+        const extra = discovered.filter((input) => !declaredIds.has(input.id));
+        const result = [...declared, ...claude.defineProfiles(extra)];
+        mergeCache = { declared, discovered, result };
+        return result;
     }
-    return getDefaultBackend();
-}
-/**
- * Every available profile, tagged with its owning backend id.
- *
- * Hidden profiles are omitted by default (this feeds the picker); the settings
- * screen passes `includeHidden` to render the full catalog.
- */
-export async function listAllProviders(options = {}) {
-    const registry = await getRegistry();
-    const snapshot = await getProfileSnapshot();
-    const hidden = options.includeHidden ? new Set() : hiddenIds();
-    return registry.backends.flatMap((backend) => (snapshot.byBackend.get(backend.id) ?? [])
-        .filter((profile) => !hidden.has(profile.id))
-        .map((profile) => ({ ...profile, backendId: backend.id })));
-}
-/** Per-backend capability metadata exposed by the providers route. */
-export async function getBackendsInfo() {
-    const backends = await getBackends();
-    return Object.fromEntries(backends.map((backend) => [
-        backend.id,
-        { id: backend.id, capabilities: backend.capabilities },
-    ]));
-}
-/** @deprecated Use getDefaultBackend() or a routing-specific accessor. */
-export async function getBackend() {
-    return getDefaultBackend();
-}
-/** Test seam: drop the cached registry so later access rebuilds from env. */
-export function resetBackendForTests() {
-    cachedRegistry = null;
-    profileSnapshot = null;
-    modelSource = null;
-}
-/** Test seam: install one fake backend as the complete registry. */
-export function setBackendForTests(backend) {
-    cachedRegistry = createRegistry([backend], backend.id);
-    profileSnapshot = null;
-}
-/** Test seam: install a complete fake registry with an explicit default. */
-export function setBackendsForTests(backends, defaultBackendId = backends[0]?.id ?? "") {
-    cachedRegistry = createRegistry(backends, defaultBackendId);
-    profileSnapshot = null;
-}
-// The built-in default profile's model. The Claude backend historically pinned
-// the default to a specific model; after the SDK extraction the pin was lost and
-// resumed default-profile sessions drifted to "whatever the CLI defaults to",
-// silently changing model/behaviour/billing on every CLI bump. Re-pin it here
-// (a committed default, overridable per deploy via BRAIN_UI_CLAUDE_DEFAULT_MODEL)
-// so the default stays on a known model.
-const BUILTIN_DEFAULT_MODEL = process.env.BRAIN_UI_CLAUDE_DEFAULT_MODEL?.trim() || "claude-sonnet-4-6";
-function builtinDefaultProfiles() {
-    return defineProfiles([
-        {
-            id: "claude",
-            label: "Claude",
-            vendor: "anthropic",
-            model: BUILTIN_DEFAULT_MODEL,
-            modelAliases: true,
-            source: "builtin",
-        },
-    ]);
-}
-/**
- * The Claude roster: the pinned built-in "claude" default first, plus any extra
- * profiles from BRAIN_UI_CLAUDE_PROFILES (a JSON array of InferenceProfileInput
- * {id,label,model?,baseUrl?,authTokenEnv?,apiKeyEnv?,modelAliases?}).
- *
- * A malformed or duplicate-id roster THROWS — caught at boot by the registry
- * fail-fast — rather than silently degrading to default-only and rebilling
- * every pinned session to the subscription with nothing in the logs.
- */
-function loadClaudeProfiles() {
-    const base = builtinDefaultProfiles();
-    const raw = process.env.BRAIN_UI_CLAUDE_PROFILES?.trim();
-    if (!raw)
-        return base;
-    let inputs;
-    try {
-        inputs = JSON.parse(raw);
+    // The built-in default profile's model. The Claude backend historically
+    // pinned the default to a specific model; after the SDK extraction the pin
+    // was lost and resumed default-profile sessions drifted to "whatever the CLI
+    // defaults to", silently changing model/behaviour/billing on every CLI bump.
+    // Re-pin it (a committed default, overridable per deploy via
+    // BRAIN_UI_CLAUDE_DEFAULT_MODEL) so the default stays on a known model.
+    function builtinDefaultProfiles(claude) {
+        return claude.defineProfiles([
+            {
+                id: "claude",
+                label: "Claude",
+                vendor: "anthropic",
+                model: agent.defaultModel,
+                modelAliases: true,
+                source: "builtin",
+            },
+        ]);
+    }
+    /**
+     * The Claude roster: the pinned built-in "claude" default first, plus any
+     * extra profiles from BRAIN_UI_CLAUDE_PROFILES (a JSON array of profile
+     * inputs: {id,label,model?,baseUrl?,authTokenEnv?,apiKeyEnv?,modelAliases?}).
+     *
+     * A malformed or duplicate-id roster THROWS — caught at boot by the registry
+     * fail-fast — rather than silently degrading to default-only and rebilling
+     * every pinned session to the subscription with nothing in the logs.
+     */
+    function loadClaudeProfiles(claude) {
+        const base = builtinDefaultProfiles(claude);
+        const raw = agent.profilesJson;
+        if (!raw)
+            return base;
+        let inputs;
+        try {
+            inputs = JSON.parse(raw);
+        }
+        catch (err) {
+            throw new Error(`BRAIN_UI_CLAUDE_PROFILES is not valid JSON: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        if (!Array.isArray(inputs)) {
+            throw new Error("BRAIN_UI_CLAUDE_PROFILES must be a JSON array.");
+        }
+        // Reject duplicate ids (including collisions with the built-in "claude"): a
+        // duplicate silently shadows and can resolve to the wrong credentials.
+        const seen = new Set(base.map((profile) => profile.id));
+        for (const input of inputs) {
+            if (!input || typeof input.id !== "string" || input.id.length === 0) {
+                throw new Error("Each BRAIN_UI_CLAUDE_PROFILES entry needs a non-empty string id.");
+            }
+            if (seen.has(input.id)) {
+                throw new Error(`Duplicate profile id in BRAIN_UI_CLAUDE_PROFILES: "${input.id}".`);
+            }
+            seen.add(input.id);
+        }
+        const declared = inputs.map((input) => ({
+            source: "declared",
+            ...input,
+        }));
+        return [...base, ...claude.defineProfiles(declared)];
     }
-    catch (err) {
-        throw new Error(`BRAIN_UI_CLAUDE_PROFILES is not valid JSON: ${err instanceof Error ? err.message : String(err)}`);
+    /**
+     * NEITHER backend package is a hard dependency — a deployment installs the
+     * one its AGENT_BACKEND names (both, if it switches). Loaded lazily through
+     * the same `createRequire` path so the server still boots without the unused
+     * one; when the configured backend's package is absent, fail with an
+     * actionable message.
+     */
+    function buildClaudeBackend() {
+        const require = createRequire(import.meta.url);
+        let claude;
+        try {
+            claude = require("@schlessera/brain-backend-claude");
+        }
+        catch {
+            throw missingBackendError("claude");
+        }
+        if (typeof claude.createClaudeBackend !== "function") {
+            throw new Error('"@schlessera/brain-backend-claude" does not export createClaudeBackend.');
+        }
+        // Declared profiles are resolved EAGERLY so a malformed
+        // BRAIN_UI_CLAUDE_PROFILES still fails at boot rather than on first request.
+        const declared = loadClaudeProfiles(claude);
+        modelSource = claude.createModelSource({
+            brainPath,
+            enabled: agent.modelDiscovery,
+            ttlMs: agent.modelTtlMs,
+        });
+        return claude.createClaudeBackend({
+            brainPath,
+            claudeCodePath: agent.claudeCodePath,
+            // A function, not an array: discovery refreshes in the background and the
+            // new roster has to be visible without restarting the process.
+            profiles: () => mergeDiscovered(claude, declared, modelSource?.list() ?? []),
+        });
     }
-    if (!Array.isArray(inputs)) {
-        throw new Error("BRAIN_UI_CLAUDE_PROFILES must be a JSON array.");
+    function buildPiBackend() {
+        const require = createRequire(import.meta.url);
+        let mod;
+        try {
+            mod = require("@schlessera/brain-backend-pi");
+        }
+        catch {
+            throw missingBackendError("pi");
+        }
+        if (typeof mod.createPiBackend !== "function") {
+            throw new Error('"@schlessera/brain-backend-pi" does not export createPiBackend.');
+        }
+        return mod.createPiBackend({ brainPath });
     }
-    // Reject duplicate ids (including collisions with the built-in "claude"): a
-    // duplicate silently shadows and can resolve to the wrong credentials.
-    const seen = new Set(base.map((profile) => profile.id));
-    for (const input of inputs) {
-        if (!input || typeof input.id !== "string" || input.id.length === 0) {
-            throw new Error("Each BRAIN_UI_CLAUDE_PROFILES entry needs a non-empty string id.");
+    async function buildRegistry() {
+        const primary = agent.backend || "claude";
+        if (primary === "pi") {
+            const pi = buildPiBackend();
+            return buildSnapshot([pi], pi.id);
         }
-        if (seen.has(input.id)) {
-            throw new Error(`Duplicate profile id in BRAIN_UI_CLAUDE_PROFILES: "${input.id}".`);
+        const backends = [buildClaudeBackend()];
+        // AGENT_BACKEND must name a configured backend. The in-process options are
+        // "claude" (default) and "pi" (handled above). An unrecognized value is a
+        // misconfiguration — fail loudly instead of silently coercing to claude and
+        // running on the wrong backend with nothing in the logs.
+        if (agent.backend && !backends.some((b) => b.id === primary)) {
+            throw unknownBackendError(primary);
         }
-        seen.add(input.id);
+        return buildSnapshot(backends, primary);
+    }
+    async function getRegistry() {
+        if (!cachedRegistry)
+            cachedRegistry = buildRegistry();
+        return cachedRegistry;
     }
-    const declared = inputs.map((input) => ({
-        source: "declared",
-        ...input,
-    }));
-    return [...base, ...defineProfiles(declared)];
+    return makeRegistry(getRegistry, getHidden, async () => {
+        await getRegistry();
+        return modelSource;
+    });
 }
 /**
- * Optional pi backend. @schlessera/brain-backend-pi is NOT a hard dependency — a
- * deployment that never opts into it does not need it (or its pi SDK peer deps)
- * installed. Loaded lazily so the server still boots without it; when requested
- * but absent, fail with an actionable message.
+ * A registry over an explicit backend list — the seam tests (and embedders
+ * with their own backend wiring) use instead of mutating module state. Takes
+ * the same optional hidden-ids reader so visibility behavior matches
+ * production.
  */
-function buildPiBackend() {
-    const require = createRequire(import.meta.url);
-    let mod;
-    try {
-        mod = require("@schlessera/brain-backend-pi");
-    }
-    catch {
-        throw new Error('AGENT_BACKEND=pi but "@schlessera/brain-backend-pi" is not installed. ' +
-            "Add it (with its pi SDK dependencies) or set AGENT_BACKEND=claude.");
+export function createStaticBackendRegistry(backends, defaultBackendId = backends[0]?.id ?? "", options = {}) {
+    const snapshot = buildSnapshot(backends, defaultBackendId);
+    return makeRegistry(async () => snapshot, options.getHiddenModelIds ?? (() => []), async () => null);
+}
+/** The accessor surface, shared by the config-driven and static registries. */
+function makeRegistry(getRegistry, getHidden, getModelSource) {
+    let profileSnapshot = null;
+    /** Recompute the profile roster (memoized), asserting cross-backend id uniqueness. */
+    async function getProfileSnapshot() {
+        if (profileSnapshot && Date.now() - profileSnapshot.at < PROFILE_MEMO_MS) {
+            return profileSnapshot;
+        }
+        const registry = await getRegistry();
+        const byBackend = new Map();
+        const owners = new Map();
+        for (const backend of registry.backends) {
+            const profiles = await backend.listProfiles();
+            byBackend.set(backend.id, profiles);
+            for (const profile of profiles) {
+                const owner = owners.get(profile.id);
+                if (owner && owner !== backend.id) {
+                    throw new Error(`Profile id collision across backends: "${profile.id}" is exposed by "${owner}" and "${backend.id}".`);
+                }
+                owners.set(profile.id, backend.id);
+            }
+        }
+        profileSnapshot = { at: Date.now(), byBackend, owners };
+        return profileSnapshot;
     }
-    if (typeof mod.createPiBackend !== "function") {
-        throw new Error('"@schlessera/brain-backend-pi" does not export createPiBackend.');
+    /** A settings read failure must not take the picker down — degrade to "nothing hidden". */
+    function hiddenIds() {
+        try {
+            return new Set(getHidden());
+        }
+        catch (err) {
+            console.warn(`[models] Could not read hidden models: ${err instanceof Error ? err.message : String(err)}`);
+            return new Set();
+        }
     }
-    return mod.createPiBackend({ brainPath: BRAIN_PATH });
+    return {
+        async getBackends() {
+            return (await getRegistry()).backends;
+        },
+        async getBackendById(id) {
+            return (await getRegistry()).byId.get(id);
+        },
+        async getDefaultBackend() {
+            const registry = await getRegistry();
+            return registry.byId.get(registry.defaultBackendId);
+        },
+        async getDefaultBackendId() {
+            return (await getRegistry()).defaultBackendId;
+        },
+        async getBackendForProfile(profileId) {
+            const registry = await getRegistry();
+            // Deliberately resolved against the UNFILTERED roster: a session pinned
+            // to a profile the user later hid must keep running.
+            const snapshot = await getProfileSnapshot();
+            const backendId = snapshot.owners.get(profileId);
+            return backendId ? registry.byId.get(backendId) : undefined;
+        },
+        async getBackendForSession(backendId) {
+            const registry = await getRegistry();
+            if (backendId) {
+                const backend = registry.byId.get(backendId);
+                if (backend)
+                    return backend;
+            }
+            return registry.byId.get(registry.defaultBackendId);
+        },
+        async listAllProviders(options = {}) {
+            const registry = await getRegistry();
+            const snapshot = await getProfileSnapshot();
+            const hidden = options.includeHidden ? new Set() : hiddenIds();
+            return registry.backends.flatMap((backend) => (snapshot.byBackend.get(backend.id) ?? [])
+                .filter((profile) => !hidden.has(profile.id))
+                .map((profile) => ({ ...profile, backendId: backend.id })));
+        },
+        async getBackendsInfo() {
+            const backends = (await getRegistry()).backends;
+            return Object.fromEntries(backends.map((backend) => [
+                backend.id,
+                { id: backend.id, capabilities: backend.capabilities },
+            ]));
+        },
+        getModelSource,
+        invalidateProfiles() {
+            profileSnapshot = null;
+        },
+    };
 }
 //# sourceMappingURL=backend.js.map