@elizaos/app-core 2.0.0-alpha.85 → 2.0.0-beta.2

package/services/local-inference/recommendation.js

@@ -0,0 +1,309 @@
+import { DEFAULT_ELIGIBLE_MODEL_IDS, FIRST_RUN_DEFAULT_MODEL_ID, MODEL_CATALOG, } from "./catalog";
+import { assessFit } from "./hardware";
+import { defaultManifestLoader, resolveRamBudget, } from "./ram-budget";
+// Local tier-id constants derived once from the manifest-driven catalog
+// type so the ladder definitions can't drift from the canonical list.
+// Adding a tier requires extending the manifest module; this file picks
+// it up automatically.
+const TIER_LITE = "eliza-1-lite-0_6b";
+const TIER_MOBILE = "eliza-1-mobile-1_7b";
+const TIER_DESKTOP = "eliza-1-desktop-9b";
+const TIER_PRO = "eliza-1-pro-27b";
+const TIER_SERVER = "eliza-1-server-h200";
+const BYTES_PER_GB = 1024 ** 3;
+/**
+ * Per-platform slot ladders. Every default-recommended entry is an
+ * Eliza-1 tier (the only default-eligible line — see catalog.ts and
+ * `packages/inference/AGENTS.md` §2). Ladders bias toward the smallest
+ * tier that fits the platform; desktops/servers pick larger tiers
+ * first when memory headroom allows.
+ */
+const SLOT_LADDERS = {
+    mobile: {
+        TEXT_SMALL: [TIER_LITE, TIER_MOBILE],
+        TEXT_LARGE: [TIER_MOBILE, TIER_LITE],
+    },
+    "apple-silicon": {
+        TEXT_SMALL: [TIER_MOBILE, TIER_LITE],
+        TEXT_LARGE: [TIER_PRO, TIER_DESKTOP, TIER_MOBILE],
+    },
+    "linux-gpu": {
+        TEXT_SMALL: [TIER_MOBILE, TIER_LITE],
+        TEXT_LARGE: [TIER_SERVER, TIER_PRO, TIER_DESKTOP, TIER_MOBILE],
+    },
+    "linux-cpu": {
+        TEXT_SMALL: [TIER_MOBILE, TIER_LITE],
+        TEXT_LARGE: [TIER_DESKTOP, TIER_MOBILE],
+    },
+    "desktop-gpu": {
+        TEXT_SMALL: [TIER_MOBILE, TIER_LITE],
+        TEXT_LARGE: [TIER_SERVER, TIER_PRO, TIER_DESKTOP, TIER_MOBILE],
+    },
+    "desktop-cpu": {
+        TEXT_SMALL: [TIER_MOBILE, TIER_LITE],
+        TEXT_LARGE: [TIER_DESKTOP, TIER_MOBILE],
+    },
+};
+function catalogById(catalog) {
+    return new Map(catalog.map((model) => [model.id, model]));
+}
+function chatCandidates(catalog) {
+    return catalog.filter((model) => !model.hiddenFromCatalog && model.runtimeRole !== "dflash-drafter");
+}
+export function classifyRecommendationPlatform(hardware) {
+    // Mobile detection comes from the typed `hardware.mobile.platform`
+    // field (`"ios" | "android" | "web"`). `NodeJS.Platform` doesn't
+    // include those values — the previous `process.platform as string`
+    // cast was hiding that the cast was the only way the comparison
+    // type-checked. Reading the proper typed field is both safer and
+    // accurate when a host advertises mobile via the mobile probe.
+    const mobilePlatform = hardware.mobile?.platform;
+    if (mobilePlatform === "android" || mobilePlatform === "ios")
+        return "mobile";
+    const platform = hardware.platform;
+    if (hardware.appleSilicon)
+        return "apple-silicon";
+    if (platform === "linux" && hardware.gpu)
+        return "linux-gpu";
+    if (platform === "linux")
+        return "linux-cpu";
+    if (hardware.gpu)
+        return "desktop-gpu";
+    return "desktop-cpu";
+}
+export function catalogDownloadSizeGb(model, catalog = MODEL_CATALOG) {
+    const byId = catalogById(catalog);
+    return (model.companionModelIds ?? []).reduce((total, companionId) => {
+        const companion = byId.get(companionId);
+        return total + (companion?.sizeGb ?? 0);
+    }, model.sizeGb);
+}
+export function catalogDownloadSizeBytes(model, catalog = MODEL_CATALOG) {
+    return Math.round(catalogDownloadSizeGb(model, catalog) * BYTES_PER_GB);
+}
+const MB_PER_GB = 1024;
+function mobileFit(hardware, model, catalog, budget) {
+    const sizeGb = catalogDownloadSizeGb(model, catalog);
+    const totalRamMb = hardware.totalRamGb * MB_PER_GB;
+    // `minMb` is the won't-fit floor (catalog scalar by default; manifest
+    // override when an installed Eliza-1 bundle declared one).
+    if (totalRamMb < budget.minMb)
+        return "wontfit";
+    if (sizeGb > hardware.totalRamGb * 0.8)
+        return "wontfit";
+    // `recommendedMb` is the fits-vs-tight cutoff. Catalog fallback collapses
+    // recommended === min so the new line never tightens prior behavior.
+    if (totalRamMb < budget.recommendedMb)
+        return "tight";
+    if (sizeGb > hardware.totalRamGb * 0.65)
+        return "tight";
+    return "fits";
+}
+export function assessCatalogModelFit(hardware, model, catalog = MODEL_CATALOG, options = {}) {
+    if (model.runtime?.dflash) {
+        const byId = catalogById(catalog);
+        if (!byId.has(model.runtime.dflash.drafterModelId))
+            return "wontfit";
+    }
+    const budget = resolveRamBudget(model, options.installed, options.manifestLoader ?? defaultManifestLoader);
+    if (classifyRecommendationPlatform(hardware) === "mobile") {
+        return mobileFit(hardware, model, catalog, budget);
+    }
+    // `assessFit` historically takes minRamGb. Use the manifest-derived
+    // floor (minMb) when available; fall back to the catalog scalar
+    // otherwise. The manifest's `recommendedMb` further tightens the
+    // "fits" line via the wrapper below.
+    const baseline = assessFit(hardware, catalogDownloadSizeGb(model, catalog), budget.minMb / MB_PER_GB);
+    if (baseline === "wontfit")
+        return "wontfit";
+    if (budget.source === "manifest") {
+        const effectiveGb = effectiveMemoryGb(hardware);
+        if (effectiveGb * MB_PER_GB < budget.recommendedMb)
+            return "tight";
+    }
+    return baseline;
+}
+/** Mirrors the effective-memory math in `assessFit`. */
+function effectiveMemoryGb(probe) {
+    if (probe.appleSilicon)
+        return probe.totalRamGb;
+    if (probe.gpu) {
+        return Math.max(probe.gpu.totalVramGb, probe.totalRamGb * 0.5);
+    }
+    return probe.totalRamGb * 0.5;
+}
+function canFit(hardware, model, catalog, options = {}) {
+    return assessCatalogModelFit(hardware, model, catalog, options) !== "wontfit";
+}
+/**
+ * True when every kernel listed in `model.runtime.optimizations.requiresKernel`
+ * is advertised as `true` in the binary's CAPABILITIES.json kernels map.
+ *
+ * `binaryKernels === null` means we have no probe (older binary, or
+ * llama-server isn't installed). In that case we trust the catalog —
+ * filtering would hide every kernel-required model and the dispatcher's
+ * load-time check will surface the real error if/when the user tries to
+ * activate it.
+ */
+function kernelRequirementsSatisfied(model, binaryKernels) {
+    const required = model.runtime?.optimizations?.requiresKernel ?? [];
+    if (required.length === 0)
+        return true;
+    if (!binaryKernels)
+        return true;
+    return required.every((k) => binaryKernels[k] === true);
+}
+function modelsFromLadder(ids, catalog) {
+    const byId = catalogById(catalog);
+    return ids.flatMap((id) => {
+        const model = byId.get(id);
+        return model ? [model] : [];
+    });
+}
+/**
+ * True when this host has enough memory headroom to serve the long-context
+ * KV cache for a 64k+ window. Threshold mirrors the "16 GB workstation"
+ * line from the porting plan — a 64k context for an 8B model at fp16 KV
+ * occupies ~4 GB; with TurboQuant compression it fits inside 1 GB. Below
+ * 16 GB total we keep the historical short-context preference.
+ *
+ * For GPU hosts we look at total VRAM, since the KV cache lives wherever
+ * the layers do; for CPU-only hosts we look at total RAM.
+ */
+const LONG_CONTEXT_RAM_BUMP_THRESHOLD_GB = 16;
+const LONG_CONTEXT_MIN_LENGTH = 65536;
+function hasLongContextHeadroom(hardware) {
+    const vramGb = hardware.gpu?.totalVramGb ?? 0;
+    if (vramGb >= LONG_CONTEXT_RAM_BUMP_THRESHOLD_GB)
+        return true;
+    return hardware.totalRamGb >= LONG_CONTEXT_RAM_BUMP_THRESHOLD_GB;
+}
+function isLongContextModel(model) {
+    return (typeof model.contextLength === "number" &&
+        model.contextLength >= LONG_CONTEXT_MIN_LENGTH);
+}
+function fallbackCandidates(slot, hardware, catalog, budgetOptions) {
+    const candidates = chatCandidates(catalog).filter((model) => DEFAULT_ELIGIBLE_MODEL_IDS.has(model.id) &&
+        canFit(hardware, model, catalog, budgetOptionsForModel(model, budgetOptions)));
+    const preferLongContext = hasLongContextHeadroom(hardware);
+    return candidates.sort((left, right) => {
+        if (preferLongContext) {
+            const leftLong = isLongContextModel(left) ? 1 : 0;
+            const rightLong = isLongContextModel(right) ? 1 : 0;
+            if (leftLong !== rightLong)
+                return rightLong - leftLong;
+        }
+        const sizeDelta = catalogDownloadSizeGb(right, catalog) -
+            catalogDownloadSizeGb(left, catalog);
+        return slot === "TEXT_LARGE" ? sizeDelta : -sizeDelta;
+    });
+}
+function budgetOptionsForModel(model, budget) {
+    return {
+        installed: budget.installed.find((m) => m.id === model.id),
+        manifestLoader: budget.manifestLoader,
+    };
+}
+function resolveBudgetOptions(options) {
+    return {
+        installed: options.installed ?? [],
+        manifestLoader: options.manifestLoader ?? defaultManifestLoader,
+    };
+}
+export function selectRecommendedModelForSlot(slot, hardware, catalog = MODEL_CATALOG, options = {}) {
+    const platformClass = classifyRecommendationPlatform(hardware);
+    const ladder = modelsFromLadder(SLOT_LADDERS[platformClass][slot], catalog);
+    const binaryKernels = options.binaryKernels ?? null;
+    const budget = resolveBudgetOptions(options);
+    const eligible = ladder.filter((model) => canFit(hardware, model, catalog, budgetOptionsForModel(model, budget)) &&
+        kernelRequirementsSatisfied(model, binaryKernels));
+    // On hosts with >= 16 GB RAM/VRAM, give long-context (>= 64k) ladder
+    // entries a small bump so we surface 128k models when they fit. The
+    // ladder order still wins when long-context availability is the same
+    // for every entry (or when the host doesn't have the headroom).
+    const ranked = eligible.length > 0 && hasLongContextHeadroom(hardware)
+        ? rankLadderByLongContext(eligible)
+        : eligible;
+    const alternatives = ranked.length > 0
+        ? ranked
+        : fallbackCandidates(slot, hardware, catalog, budget).filter((model) => kernelRequirementsSatisfied(model, binaryKernels));
+    const model = alternatives[0] ?? null;
+    const fit = model
+        ? assessCatalogModelFit(hardware, model, catalog, budgetOptionsForModel(model, budget))
+        : null;
+    return {
+        slot,
+        platformClass,
+        model,
+        fit,
+        reason: model
+            ? `${platformClass} ${slot} ladder selected ${model.id}`
+            : `${platformClass} ${slot} ladder has no fitting catalog model`,
+        alternatives,
+    };
+}
+/**
+ * Stable sort that pulls long-context models toward the front while
+ * preserving relative order within each group. Used only on hosts with
+ * the long-context RAM/VRAM headroom — the ladder order remains the
+ * tie-breaker so DFlash-first preferences survive.
+ */
+function rankLadderByLongContext(ladder) {
+    return ladder
+        .map((model, idx) => ({ model, idx, long: isLongContextModel(model) }))
+        .sort((left, right) => {
+        if (left.long !== right.long)
+            return right.long ? 1 : -1;
+        return left.idx - right.idx;
+    })
+        .map((entry) => entry.model);
+}
+export function selectRecommendedModels(hardware, catalog = MODEL_CATALOG, options = {}) {
+    return {
+        TEXT_SMALL: selectRecommendedModelForSlot("TEXT_SMALL", hardware, catalog, options),
+        TEXT_LARGE: selectRecommendedModelForSlot("TEXT_LARGE", hardware, catalog, options),
+    };
+}
+/**
+ * Pick the model the engine should auto-load on first run when no user
+ * preference exists. Always resolves to an Eliza-1 default-eligible
+ * tier — never a non-Eliza catalog entry, never a HF-search result.
+ *
+ * Resolution order:
+ *   1. `FIRST_RUN_DEFAULT_MODEL_ID` when present in the catalog and in
+ *      the default-eligible set.
+ *   2. The first default-eligible chat entry in the catalog as a
+ *      defensive fallback if the default id is somehow missing
+ *      (catalog lint should prevent this; see catalog.test.ts).
+ *
+ * Returns null only when no default-eligible entry exists at all —
+ * which means the catalog is misconfigured and the caller should
+ * surface a hard error rather than degrade silently.
+ */
+export function recommendForFirstRun(catalog = MODEL_CATALOG) {
+    const byId = catalogById(catalog);
+    const preferred = byId.get(FIRST_RUN_DEFAULT_MODEL_ID);
+    if (preferred && DEFAULT_ELIGIBLE_MODEL_IDS.has(preferred.id))
+        return preferred;
+    return (catalog.find((model) => !model.hiddenFromCatalog &&
+        model.runtimeRole !== "dflash-drafter" &&
+        DEFAULT_ELIGIBLE_MODEL_IDS.has(model.id)) ?? null);
+}
+export function chooseSmallerFallbackModel(currentModelId, hardware, slot = "TEXT_LARGE", catalog = MODEL_CATALOG, options = {}) {
+    const byId = catalogById(catalog);
+    const current = byId.get(currentModelId);
+    const currentSize = current
+        ? catalogDownloadSizeGb(current, catalog)
+        : Number.POSITIVE_INFINITY;
+    const platformClass = classifyRecommendationPlatform(hardware);
+    const budget = resolveBudgetOptions(options);
+    const ladderFallback = modelsFromLadder(SLOT_LADDERS[platformClass][slot], catalog)
+        .filter((model) => model.id !== currentModelId)
+        .filter((model) => catalogDownloadSizeGb(model, catalog) < currentSize)
+        .filter((model) => canFit(hardware, model, catalog, budgetOptionsForModel(model, budget)))[0];
+    if (ladderFallback)
+        return ladderFallback;
+    return (fallbackCandidates(slot, hardware, catalog, budget)
+        .filter((model) => model.id !== currentModelId)
+        .filter((model) => catalogDownloadSizeGb(model, catalog) < currentSize)[0] ?? null);
+}

package/services/local-inference/registry.d.ts

@@ -0,0 +1,35 @@
+/**
+ * On-disk registry of installed models.
+ *
+ * Two sources feed the registry:
+ *   1. Eliza-owned downloads (source: "eliza-download") — written on
+ *      successful completion by the downloader.
+ *   2. External scans (source: "external-scan") — merged in at read time
+ *      from `scanExternalModels()`. These are never persisted to the
+ *      registry file; a rescan runs whenever we read.
+ *
+ * The JSON file only holds Eliza-owned entries. That way, if a user
+ * cleans up LM Studio models we don't show stale ghosts.
+ */
+import type { InstalledModel } from "./types";
+/**
+ * Return all models currently usable: persisted Eliza downloads plus a
+ * fresh external-tool scan. External duplicates of Eliza-owned files are
+ * filtered out by path.
+ */
+export declare function listInstalledModels(): Promise<InstalledModel[]>;
+/** Add or update a Eliza-owned entry. External entries are rejected. */
+export declare function upsertElizaModel(model: InstalledModel): Promise<void>;
+/** Mark an existing Eliza-owned model as most-recently-used. */
+export declare function touchElizaModel(id: string): Promise<void>;
+/**
+ * Delete a Eliza-owned model from the registry and from disk.
+ *
+ * Refuses if the model was discovered from another tool — Eliza must not
+ * touch files it doesn't own. Callers surface that refusal as a 4xx.
+ */
+export declare function removeElizaModel(id: string): Promise<{
+    removed: boolean;
+    reason?: "external" | "not-found";
+}>;
+//# sourceMappingURL=registry.d.ts.map

package/services/local-inference/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../../../../src/services/local-inference/registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAMH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAmC9C;;;;GAIG;AACH,wBAAsB,mBAAmB,IAAI,OAAO,CAAC,cAAc,EAAE,CAAC,CAcrE;AAED,wEAAwE;AACxE,wBAAsB,gBAAgB,CAAC,KAAK,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CAyB3E;AAED,gEAAgE;AAChE,wBAAsB,eAAe,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAM/D;AAED;;;;;GAKG;AACH,wBAAsB,gBAAgB,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC;IAC1D,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,CAAC,EAAE,UAAU,GAAG,WAAW,CAAC;CACnC,CAAC,CA6BD"}

package/services/local-inference/registry.js

@@ -0,0 +1,117 @@
+/**
+ * On-disk registry of installed models.
+ *
+ * Two sources feed the registry:
+ *   1. Eliza-owned downloads (source: "eliza-download") — written on
+ *      successful completion by the downloader.
+ *   2. External scans (source: "external-scan") — merged in at read time
+ *      from `scanExternalModels()`. These are never persisted to the
+ *      registry file; a rescan runs whenever we read.
+ *
+ * The JSON file only holds Eliza-owned entries. That way, if a user
+ * cleans up LM Studio models we don't show stale ghosts.
+ */
+import fs from "node:fs/promises";
+import path from "node:path";
+import { scanExternalModels } from "./external-scanner";
+import { isWithinElizaRoot, localInferenceRoot, registryPath } from "./paths";
+async function ensureRootDir() {
+    await fs.mkdir(localInferenceRoot(), { recursive: true });
+}
+async function readElizaOwned() {
+    try {
+        const raw = await fs.readFile(registryPath(), "utf8");
+        const parsed = JSON.parse(raw);
+        if (!parsed || parsed.version !== 1 || !Array.isArray(parsed.models)) {
+            return [];
+        }
+        return parsed.models.filter((m) => m && typeof m === "object" && m.source === "eliza-download");
+    }
+    catch {
+        return [];
+    }
+}
+async function writeElizaOwned(models) {
+    await ensureRootDir();
+    const tmp = `${registryPath()}.tmp`;
+    const payload = { version: 1, models };
+    await fs.writeFile(tmp, JSON.stringify(payload, null, 2), "utf8");
+    await fs.rename(tmp, registryPath());
+}
+/**
+ * Return all models currently usable: persisted Eliza downloads plus a
+ * fresh external-tool scan. External duplicates of Eliza-owned files are
+ * filtered out by path.
+ */
+export async function listInstalledModels() {
+    const [owned, external] = await Promise.all([
+        readElizaOwned(),
+        scanExternalModels(),
+    ]);
+    // Filter out Eliza-owned files that also survived a reboot of the local
+    // file and got re-detected by the scanner.
+    const ownedPaths = new Set(owned.map((m) => path.resolve(m.path)));
+    const dedupedExternal = external.filter((m) => !ownedPaths.has(path.resolve(m.path)));
+    return [...owned, ...dedupedExternal];
+}
+/** Add or update a Eliza-owned entry. External entries are rejected. */
+export async function upsertElizaModel(model) {
+    if (model.source !== "eliza-download") {
+        throw new Error("[local-inference] registry only accepts Eliza-owned models");
+    }
+    if (!isWithinElizaRoot(model.path)) {
+        throw new Error("[local-inference] Eliza-owned models must live under the local-inference root");
+    }
+    if (model.bundleRoot && !isWithinElizaRoot(model.bundleRoot)) {
+        throw new Error("[local-inference] Eliza-owned bundle roots must live under the local-inference root");
+    }
+    if (model.manifestPath && !isWithinElizaRoot(model.manifestPath)) {
+        throw new Error("[local-inference] Eliza-owned manifests must live under the local-inference root");
+    }
+    const owned = await readElizaOwned();
+    const withoutCurrent = owned.filter((m) => m.id !== model.id);
+    withoutCurrent.push(model);
+    await writeElizaOwned(withoutCurrent);
+}
+/** Mark an existing Eliza-owned model as most-recently-used. */
+export async function touchElizaModel(id) {
+    const owned = await readElizaOwned();
+    const target = owned.find((m) => m.id === id);
+    if (!target)
+        return;
+    target.lastUsedAt = new Date().toISOString();
+    await writeElizaOwned(owned);
+}
+/**
+ * Delete a Eliza-owned model from the registry and from disk.
+ *
+ * Refuses if the model was discovered from another tool — Eliza must not
+ * touch files it doesn't own. Callers surface that refusal as a 4xx.
+ */
+export async function removeElizaModel(id) {
+    const owned = await readElizaOwned();
+    const target = owned.find((m) => m.id === id);
+    if (!target) {
+        // Check whether it's a known external entry so we can return a
+        // helpful error message instead of 404.
+        const external = await scanExternalModels();
+        if (external.some((m) => m.id === id)) {
+            return { removed: false, reason: "external" };
+        }
+        return { removed: false, reason: "not-found" };
+    }
+    if (!isWithinElizaRoot(target.path)) {
+        return { removed: false, reason: "external" };
+    }
+    const removePath = target.bundleRoot && isWithinElizaRoot(target.bundleRoot)
+        ? target.bundleRoot
+        : target.path;
+    try {
+        await fs.rm(removePath, { recursive: true, force: true });
+    }
+    catch {
+        // If the file was already gone we still want to clear the registry entry.
+    }
+    await writeElizaOwned(owned.filter((m) => m.id !== id));
+    return { removed: true };
+}

package/services/local-inference/router-handler.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Top-priority router handler.
+ *
+ * Registers a model handler for every `AgentModelSlot` at priority
+ * `Number.MAX_SAFE_INTEGER`, which guarantees the runtime dispatches to
+ * us first. At dispatch time we:
+ *
+ *   1. Read the user's per-slot policy + preferred-provider choice from
+ *      `routing-preferences.ts`.
+ *   2. Ask the `policyEngine` to pick a provider from the handler
+ *      registry's current set (excluding ourselves).
+ *   3. Invoke that provider's original handler directly — bypassing
+ *      `runtime.useModel` which would recurse into us.
+ *   4. Record the observed latency so future "fastest" picks have data.
+ *
+ * If no other handler exists we throw a clear error rather than return
+ * garbage — the caller is meant to see "no provider configured" so they
+ * know to set one up.
+ *
+ * Because the router sits at the top of the priority stack, the user's
+ * preference is always authoritative regardless of what plugins register
+ * at lower priorities. This is the mechanism that unifies cloud + local
+ * + device-bridge routing from one settings panel.
+ */
+import type { AgentRuntime } from "@elizaos/core";
+import type { HandlerRegistration } from "./handler-registry";
+import { type AgentModelSlot } from "./types";
+export declare const ROUTER_PROVIDER = "eliza-router";
+declare function modelTypeToSlot(modelType: string): AgentModelSlot | null;
+export declare function filterUnavailableLocalInferenceCandidates(candidates: HandlerRegistration[], localInferenceAvailable: boolean, forceLocalInference: boolean): HandlerRegistration[];
+export declare function filterUnavailableLocalInference(slot: AgentModelSlot, policy: string, preferredProvider: string | null, candidates: HandlerRegistration[]): Promise<HandlerRegistration[]>;
+/**
+ * Install the router as the top-priority handler for every slot.
+ *
+ * Idempotent per-runtime via the handler-registry's "last write wins"
+ * behaviour — re-registering our handlers just refreshes them in place.
+ * Called from `ensure-local-inference-handler.ts` after `handlerRegistry`
+ * has been installed on the runtime.
+ */
+export declare function installRouterHandler(runtime: AgentRuntime): void;
+/** Public helper — useful for diagnostics endpoints. */
+export declare function describeCurrentRouting(): Array<{
+    slot: AgentModelSlot;
+    modelType: string;
+    candidates: Array<{
+        provider: string;
+        priority: number;
+    }>;
+}>;
+export { modelTypeToSlot };
+//# sourceMappingURL=router-handler.d.ts.map

package/services/local-inference/router-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"router-handler.d.ts","sourceRoot":"","sources":["../../../../../../src/services/local-inference/router-handler.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAiB,MAAM,eAAe,CAAC;AAIjE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAO9D,OAAO,EAAqB,KAAK,cAAc,EAAE,MAAM,SAAS,CAAC;AAEjE,eAAO,MAAM,eAAe,iBAAiB,CAAC;AA6B9C,iBAAS,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,cAAc,GAAG,IAAI,CAKjE;AASD,wBAAgB,yCAAyC,CACvD,UAAU,EAAE,mBAAmB,EAAE,EACjC,uBAAuB,EAAE,OAAO,EAChC,mBAAmB,EAAE,OAAO,GAC3B,mBAAmB,EAAE,CAQvB;AAED,wBAAsB,+BAA+B,CACnD,IAAI,EAAE,cAAc,EACpB,MAAM,EAAE,MAAM,EACd,iBAAiB,EAAE,MAAM,GAAG,IAAI,EAChC,UAAU,EAAE,mBAAmB,EAAE,GAChC,OAAO,CAAC,mBAAmB,EAAE,CAAC,CAchC;AAwFD;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,YAAY,GAAG,IAAI,CAqBhE;AAED,wDAAwD;AACxD,wBAAgB,sBAAsB,IAAI,KAAK,CAAC;IAC9C,IAAI,EAAE,cAAc,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,KAAK,CAAC;QAChB,QAAQ,EAAE,MAAM,CAAC;QACjB,QAAQ,EAAE,MAAM,CAAC;KAClB,CAAC,CAAC;CACJ,CAAC,CAWD;AAID,OAAO,EAAE,eAAe,EAAE,CAAC"}