@framers/agentos 0.2.6 → 0.2.8

package/dist/memory-router/adaptive.js

@@ -0,0 +1,202 @@
+/**
+ * @file adaptive.ts
+ * @description Self-calibrating routing-table generator.
+ *
+ * The shipping {@link MINIMIZE_COST_TABLE} / {@link BALANCED_TABLE} /
+ * {@link MAXIMIZE_ACCURACY_TABLE} are calibrated from LongMemEval-S
+ * Phase B N=500 measurements. For workloads whose cost-accuracy profile
+ * diverges from that distribution, those tables are not optimal.
+ *
+ * AdaptiveMemoryRouter takes a workload-specific calibration dataset
+ * (a list of {category, backend, costUsd, correct} samples) and derives
+ * a routing table from it. Same MemoryRouter API; different table
+ * source.
+ *
+ * Calibration workflow:
+ *   1. Run a Phase A sweep on your workload (a few hundred queries
+ *      across a small subset of expected categories, dispatched to all
+ *      candidate backends).
+ *   2. Each sample contributes one (category, backend, costUsd, correct)
+ *      data point.
+ *   3. AdaptiveMemoryRouter aggregates these into per-(category, backend)
+ *      mean cost + mean accuracy.
+ *   4. Apply a preset selection rule:
+ *        - 'minimize-cost': cheapest backend within 2pp of best accuracy;
+ *          if none within tolerance, pick best accuracy.
+ *        - 'maximize-accuracy': highest accuracy; ties broken by cost.
+ *        - 'balanced': best $/correct (mean cost divided by mean
+ *          accuracy).
+ *   5. Categories with insufficient samples fall back to the static
+ *      preset table.
+ *
+ * The router is otherwise identical to {@link MemoryRouter} — same
+ * decide() / decideAndDispatch() / budget-aware dispatch.
+ *
+ * @module @framers/agentos/memory-router/adaptive
+ */
+import { MemoryRouter } from './MemoryRouter.js';
+import { PRESET_TABLES, } from './routing-tables.js';
+// ============================================================================
+// Aggregation
+// ============================================================================
+/**
+ * Roll up raw calibration samples into per-(category, backend) cells.
+ * Each cell carries n, meanCost, meanAccuracy.
+ */
+export function aggregateCalibration(samples) {
+    const acc = {};
+    for (const s of samples) {
+        if (!acc[s.category])
+            acc[s.category] = {};
+        if (!acc[s.category][s.backend]) {
+            acc[s.category][s.backend] = { n: 0, sumCost: 0, sumCorrect: 0 };
+        }
+        const cell = acc[s.category][s.backend];
+        cell.n += 1;
+        cell.sumCost += s.costUsd;
+        cell.sumCorrect += s.correct;
+    }
+    const out = {};
+    for (const cat of Object.keys(acc)) {
+        out[cat] = {};
+        const inner = out[cat];
+        for (const backend of Object.keys(acc[cat])) {
+            const cell = acc[cat][backend];
+            inner[backend] = {
+                n: cell.n,
+                meanCost: cell.sumCost / cell.n,
+                meanAccuracy: cell.sumCorrect / cell.n,
+            };
+        }
+    }
+    return out;
+}
+// ============================================================================
+// Per-category selection
+// ============================================================================
+/**
+ * Select a backend for one category from aggregated calibration data
+ * using the named preset rule. Falls back to the preset's static table
+ * when calibration is insufficient.
+ */
+export function selectByPreset(args) {
+    const { category, agg, preset, minSamplesPerCell = 1, accuracyTolerance = 0.02, } = args;
+    const fallbackTable = PRESET_TABLES[preset];
+    const fallback = fallbackTable.defaultMapping[category];
+    const cells = agg[category];
+    if (!cells)
+        return fallback;
+    // Filter cells meeting min-sample threshold.
+    const eligible = Object.entries(cells)
+        .filter(([, cell]) => cell.n >= minSamplesPerCell);
+    if (eligible.length === 0)
+        return fallback;
+    if (preset === 'maximize-accuracy') {
+        return eligible.reduce((best, [backend, cell]) => {
+            const [bestBackend, bestCell] = best;
+            if (cell.meanAccuracy > bestCell.meanAccuracy)
+                return [backend, cell];
+            if (cell.meanAccuracy === bestCell.meanAccuracy) {
+                return cell.meanCost < bestCell.meanCost ? [backend, cell] : best;
+            }
+            return best;
+        }, eligible[0])[0];
+    }
+    if (preset === 'balanced') {
+        // best $/correct (skip zero-accuracy cells to avoid div-by-zero)
+        const valid = eligible.filter(([, cell]) => cell.meanAccuracy > 0);
+        if (valid.length === 0)
+            return fallback;
+        return valid.reduce((best, [backend, cell]) => {
+            const [bestBackend, bestCell] = best;
+            const cellCpc = cell.meanCost / cell.meanAccuracy;
+            const bestCpc = bestCell.meanCost / bestCell.meanAccuracy;
+            return cellCpc < bestCpc ? [backend, cell] : best;
+        }, valid[0])[0];
+    }
+    // minimize-cost: cheapest within accuracyTolerance of best accuracy.
+    const bestAccuracy = Math.max(...eligible.map(([, cell]) => cell.meanAccuracy));
+    const withinTolerance = eligible.filter(([, cell]) => bestAccuracy - cell.meanAccuracy <= accuracyTolerance);
+    if (withinTolerance.length === 0) {
+        // No candidates within tolerance is impossible (the best-accuracy
+        // backend itself qualifies), but guard anyway.
+        return fallback;
+    }
+    return withinTolerance.reduce((best, [backend, cell]) => {
+        const [bestBackend, bestCell] = best;
+        return cell.meanCost < bestCell.meanCost ? [backend, cell] : best;
+    }, withinTolerance[0])[0];
+}
+// ============================================================================
+// Table construction
+// ============================================================================
+const ALL_CATEGORIES = [
+    'single-session-user',
+    'single-session-assistant',
+    'single-session-preference',
+    'knowledge-update',
+    'multi-session',
+    'temporal-reasoning',
+];
+/**
+ * Build a complete frozen routing table from calibration samples + a
+ * preset rule. Categories without enough calibration fall back to the
+ * preset's static table.
+ */
+export function buildAdaptiveRoutingTable(args) {
+    const { samples, preset, minSamplesPerCell, accuracyTolerance, fallbackTable, } = args;
+    const agg = aggregateCalibration(samples);
+    const fb = fallbackTable ?? PRESET_TABLES[preset];
+    const mapping = {};
+    for (const cat of ALL_CATEGORIES) {
+        mapping[cat] = selectByPreset({
+            category: cat,
+            agg,
+            preset,
+            minSamplesPerCell,
+            accuracyTolerance,
+        });
+        // selectByPreset falls back to the preset's STATIC default mapping,
+        // not the caller-supplied fallback table. Apply the explicit
+        // fallback only when the static fallback wasn't applied because of
+        // missing data — easiest is to override after the fact.
+        if (!agg[cat] && fb !== PRESET_TABLES[preset]) {
+            mapping[cat] = fb.defaultMapping[cat];
+        }
+    }
+    return Object.freeze({
+        preset: preset,
+        defaultMapping: Object.freeze(mapping),
+    });
+}
+// ============================================================================
+// AdaptiveMemoryRouter class
+// ============================================================================
+/**
+ * Memory router whose routing table is derived from a calibration
+ * dataset rather than a static preset. Otherwise identical API to
+ * {@link MemoryRouter}.
+ */
+export class AdaptiveMemoryRouter extends MemoryRouter {
+    constructor(options) {
+        const derivedTable = buildAdaptiveRoutingTable({
+            samples: options.calibrationSamples,
+            preset: options.preset,
+            minSamplesPerCell: options.minSamplesPerCell,
+            accuracyTolerance: options.accuracyTolerance,
+        });
+        super({
+            ...options,
+            preset: options.preset,
+            routingTable: derivedTable,
+        });
+        this.derivedTable = derivedTable;
+    }
+    /**
+     * Inspect the derived routing table for debugging / telemetry.
+     */
+    getRoutingTable() {
+        return this.derivedTable;
+    }
+}
+//# sourceMappingURL=adaptive.js.map

package/dist/memory-router/adaptive.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"adaptive.js","sourceRoot":"","sources":["../../src/memory-router/adaptive.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAEH,OAAO,EAAE,YAAY,EAA4B,MAAM,mBAAmB,CAAC;AAC3E,OAAO,EACL,aAAa,GAKd,MAAM,qBAAqB,CAAC;AA4F7B,+EAA+E;AAC/E,cAAc;AACd,+EAA+E;AAE/E;;;GAGG;AACH,MAAM,UAAU,oBAAoB,CAClC,OAAqC;IAErC,MAAM,GAAG,GAAuF,EAAE,CAAC;IAEnG,KAAK,MAAM,CAAC,IAAI,OAAO,EAAE,CAAC;QACxB,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,QAAQ,CAAC;YAAE,GAAG,CAAC,CAAC,CAAC,QAAQ,CAAC,GAAG,EAAE,CAAC;QAC3C,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,QAAQ,CAAE,CAAC,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC;YACjC,GAAG,CAAC,CAAC,CAAC,QAAQ,CAAE,CAAC,CAAC,CAAC,OAAO,CAAC,GAAG,EAAE,CAAC,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,CAAC;QACpE,CAAC;QACD,MAAM,IAAI,GAAG,GAAG,CAAC,CAAC,CAAC,QAAQ,CAAE,CAAC,CAAC,CAAC,OAAO,CAAE,CAAC;QAC1C,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC;QACZ,IAAI,CAAC,OAAO,IAAI,CAAC,CAAC,OAAO,CAAC;QAC1B,IAAI,CAAC,UAAU,IAAI,CAAC,CAAC,OAAO,CAAC;IAC/B,CAAC;IAED,MAAM,GAAG,GAA0B,EAAE,CAAC;IACtC,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,GAAG,CAA0B,EAAE,CAAC;QAC5D,GAAG,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC;QACd,MAAM,KAAK,GAAG,GAAG,CAAC,GAAG,CAAE,CAAC;QACxB,KAAK,MAAM,OAAO,IAAI,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAE,CAAsB,EAAE,CAAC;YAClE,MAAM,IAAI,GAAG,GAAG,CAAC,GAAG,CAAE,CAAC,OAAO,CAAE,CAAC;YACjC,KAAK,CAAC,OAAO,CAAC,GAAG;gBACf,CAAC,EAAE,IAAI,CAAC,CAAC;gBACT,QAAQ,EAAE,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,CAAC;gBAC/B,YAAY,EAAE,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,CAAC;aACvC,CAAC;QACJ,CAAC;IACH,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED,+EAA+E;AAC/E,yBAAyB;AACzB,+EAA+E;AAE/E;;;;GAIG;AACH,MAAM,UAAU,cAAc,CAAC,IAAwB;IACrD,MAAM,EACJ,QAAQ,EACR,GAAG,EACH,MAAM,EACN,iBAAiB,GAAG,CAAC,EACrB,iBAAiB,GAAG,IAAI,GACzB,GAAG,IAAI,CAAC;IAET,MAAM,aAAa,GAAG,aAAa,CAAC,MAAM,CAAC,CAAC;IAC5C,MAAM,QAAQ,GAAG,aAAa,CAAC,cAAc,CAAC,QAAQ,CAAC,CAAC;IAExD,MAAM,KAAK,GAAG,GAAG,CAAC,QAAQ,CAAC,CAAC;IAC5B,IAAI,CAAC,KAAK;QAAE,OAAO,QAAQ,CAAC;IAE5B,6CAA6C;IAC7C,MAAM,QAAQ,GAAI,MAAM,CAAC,OAAO,CAAC,KAAK,CAA0C;SAC7E,MAAM,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,IAAI,iBAAiB,CAAC,CAAC;IAErD,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,QAAQ,CAAC;IAE3C,IAAI,MAAM,KAAK,mBAAmB,EAAE,CAAC;QACnC,OAAO,QAAQ,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,CAAC,OAAO,EAAE,IAAI,CAAC,EAAE,EAAE;YAC/C,MAAM,CAAC,WAAW,EAAE,QAAQ,CAAC,GAAG,IAAI,CAAC;YACrC,IAAI,IAAI,CAAC,YAAY,GAAG,QAAQ,CAAC,YAAY;gBAAE,OAAO,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;YACtE,IAAI,IAAI,CAAC,YAAY,KAAK,QAAQ,CAAC,YAAY,EAAE,CAAC;gBAChD,OAAO,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;YACpE,CAAC;YACD,OAAO,IAAI,CAAC;QACd,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAE,CAAC,CAAC,CAAC,CAAC,CAAC;IACtB,CAAC;IAED,IAAI,MAAM,KAAK,UAAU,EAAE,CAAC;QAC1B,iEAAiE;QACjE,MAAM,KAAK,GAAG,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,YAAY,GAAG,CAAC,CAAC,CAAC;QACnE,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO,QAAQ,CAAC;QACxC,OAAO,KAAK,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,CAAC,OAAO,EAAE,IAAI,CAAC,EAAE,EAAE;YAC5C,MAAM,CAAC,WAAW,EAAE,QAAQ,CAAC,GAAG,IAAI,CAAC;YACrC,MAAM,OAAO,GAAG,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,YAAY,CAAC;YAClD,MAAM,OAAO,GAAG,QAAQ,CAAC,QAAQ,GAAG,QAAQ,CAAC,YAAY,CAAC;YAC1D,OAAO,OAAO,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;QACpD,CAAC,EAAE,KAAK,CAAC,CAAC,CAAE,CAAC,CAAC,CAAC,CAAC,CAAC;IACnB,CAAC;IAED,qEAAqE;IACrE,MAAM,YAAY,GAAG,IAAI,CAAC,GAAG,CAC3B,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,YAAY,CAAC,CACjD,CAAC;IACF,MAAM,eAAe,GAAG,QAAQ,CAAC,MAAM,CACrC,CAAC,CAAC,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,YAAY,GAAG,IAAI,CAAC,YAAY,IAAI,iBAAiB,CACpE,CAAC;IAEF,IAAI,eAAe,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACjC,kEAAkE;QAClE,+CAA+C;QAC/C,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED,OAAO,eAAe,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,CAAC,OAAO,EAAE,IAAI,CAAC,EAAE,EAAE;QACtD,MAAM,CAAC,WAAW,EAAE,QAAQ,CAAC,GAAG,IAAI,CAAC;QACrC,OAAO,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;IACpE,CAAC,EAAE,eAAe,CAAC,CAAC,CAAE,CAAC,CAAC,CAAC,CAAC,CAAC;AAC7B,CAAC;AAED,+EAA+E;AAC/E,qBAAqB;AACrB,+EAA+E;AAE/E,MAAM,cAAc,GAAmC;IACrD,qBAAqB;IACrB,0BAA0B;IAC1B,2BAA2B;IAC3B,kBAAkB;IAClB,eAAe;IACf,oBAAoB;CACrB,CAAC;AAEF;;;;GAIG;AACH,MAAM,UAAU,yBAAyB,CACvC,IAAmC;IAEnC,MAAM,EACJ,OAAO,EACP,MAAM,EACN,iBAAiB,EACjB,iBAAiB,EACjB,aAAa,GACd,GAAG,IAAI,CAAC;IAET,MAAM,GAAG,GAAG,oBAAoB,CAAC,OAAO,CAAC,CAAC;IAC1C,MAAM,EAAE,GAAG,aAAa,IAAI,aAAa,CAAC,MAAM,CAAC,CAAC;IAElD,MAAM,OAAO,GAAiD,EAG7D,CAAC;IACF,KAAK,MAAM,GAAG,IAAI,cAAc,EAAE,CAAC;QACjC,OAAO,CAAC,GAAG,CAAC,GAAG,cAAc,CAAC;YAC5B,QAAQ,EAAE,GAAG;YACb,GAAG;YACH,MAAM;YACN,iBAAiB;YACjB,iBAAiB;SAClB,CAAC,CAAC;QACH,oEAAoE;QACpE,6DAA6D;QAC7D,mEAAmE;QACnE,wDAAwD;QACxD,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,EAAE,KAAK,aAAa,CAAC,MAAM,CAAC,EAAE,CAAC;YAC9C,OAAO,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC;QACxC,CAAC;IACH,CAAC;IAED,OAAO,MAAM,CAAC,MAAM,CAAC;QACnB,MAAM,EAAE,MAA4B;QACpC,cAAc,EAAE,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC;KACvC,CAAiB,CAAC;AACrB,CAAC;AAED,+EAA+E;AAC/E,6BAA6B;AAC7B,+EAA+E;AAE/E;;;;GAIG;AACH,MAAM,OAAO,oBAAqB,SAAQ,YAAY;IAGpD,YAAY,OAAoC;QAC9C,MAAM,YAAY,GAAG,yBAAyB,CAAC;YAC7C,OAAO,EAAE,OAAO,CAAC,kBAAkB;YACnC,MAAM,EAAE,OAAO,CAAC,MAAM;YACtB,iBAAiB,EAAE,OAAO,CAAC,iBAAiB;YAC5C,iBAAiB,EAAE,OAAO,CAAC,iBAAiB;SAC7C,CAAC,CAAC;QAEH,KAAK,CAAC;YACJ,GAAG,OAAO;YACV,MAAM,EAAE,OAAO,CAAC,MAA4B;YAC5C,YAAY,EAAE,YAAY;SAC3B,CAAC,CAAC;QAEH,IAAI,CAAC,YAAY,GAAG,YAAY,CAAC;IACnC,CAAC;IAED;;OAEG;IACH,eAAe;QACb,OAAO,IAAI,CAAC,YAAY,CAAC;IAC3B,CAAC;CACF"}

package/dist/memory-router/backend-costs.d.ts

@@ -0,0 +1,67 @@
+/**
+ * @file backend-costs.ts
+ * @description Per-backend per-category cost-accuracy-latency points
+ * measured on LongMemEval-S Phase B (N=500). The {@link MemoryRouter} uses
+ * these to:
+ *   - estimate the per-query USD cost of a routing decision before executing,
+ *   - apply budget constraints (`hard` / `soft` / `cheapest-fallback`),
+ *   - pick the cheapest backend that fits a budget when downgrading.
+ *
+ * Numbers come from the canonical Phase B run JSONs:
+ *   - canonical-hybrid: results/runs/2026-04-20T20-03-14-675 (Tier 1)
+ *   - observational-memory-v10: results/runs/2026-04-23T04-14-40-609 (Tier 2a v10)
+ *   - observational-memory-v11: results/runs/2026-04-23T17-27-28-793 (Tier 2b v11)
+ *
+ * The per-tier `avgCostPerQuery` is the totalUsd-divided-by-n_cases
+ * average; on routed configurations the actual per-call cost depends on
+ * which backend the dispatcher picked and which category the call hit, so
+ * the per-category breakdown below is what the router actually consumes.
+ *
+ * @module @framers/agentos/memory-router/backend-costs
+ */
+import type { MemoryBackendId, MemoryQueryCategory } from './routing-tables.js';
+/**
+ * Cost-accuracy-latency point for one backend across the six categories.
+ * The router compares these to make budget-aware decisions.
+ */
+export interface MemoryBackendCostPoint {
+    readonly backend: MemoryBackendId;
+    /** Average USD per query across all categories (Phase B aggregate). */
+    readonly avgCostPerQuery: number;
+    /** Per-category accuracy at this backend (Phase B N=500). */
+    readonly perCategoryAccuracy: Readonly<Record<MemoryQueryCategory, number>>;
+    /** Per-category USD per query at this backend (Phase B N=500). */
+    readonly perCategoryCostPerQuery: Readonly<Record<MemoryQueryCategory, number>>;
+    /** Per-category average latency in ms at this backend (Phase B N=500). */
+    readonly perCategoryLatencyMs: Readonly<Record<MemoryQueryCategory, number>>;
+}
+/**
+ * canonical-hybrid: BM25 + dense + RRF + Cohere rerank-v3.5 over raw
+ * memory traces. Phase B measured 73.2% [69.2, 77.0] aggregate at
+ * $0.0213/correct.
+ */
+export declare const TIER_1_CANONICAL_COSTS: MemoryBackendCostPoint;
+/**
+ * observational-memory-v10: synthesized observation log + classifier-driven
+ * dispatch inside the OM pipeline (no verbatim citation). Phase B measured
+ * 74.6% [70.8, 78.4] aggregate at $0.3265/correct, 12s avg latency.
+ */
+export declare const TIER_2A_V10_COSTS: MemoryBackendCostPoint;
+/**
+ * observational-memory-v11: v10 + conditional verbatim citation rule for
+ * knowledge-update and single-session-user categories. Phase B measured
+ * 75.4% [71.6, 79.0] aggregate at $0.4362/correct, 14s avg latency.
+ */
+export declare const TIER_2B_V11_COSTS: MemoryBackendCostPoint;
+/**
+ * Default cost-points registry. Indexed by {@link MemoryBackendId} so the
+ * router can look up the picked backend's cost on any category.
+ *
+ * Custom deployments can substitute their own cost-points by passing a
+ * different `backendCosts` map into the {@link MemoryRouter} config —
+ * useful when a workload diverges from the LongMemEval-S Phase B
+ * distribution and the calibrator wants to plug in measurements from
+ * their own benchmark.
+ */
+export declare const DEFAULT_MEMORY_BACKEND_COSTS: Readonly<Record<MemoryBackendId, MemoryBackendCostPoint>>;
+//# sourceMappingURL=backend-costs.d.ts.map

package/dist/memory-router/backend-costs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"backend-costs.d.ts","sourceRoot":"","sources":["../../src/memory-router/backend-costs.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAEhF;;;GAGG;AACH,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,OAAO,EAAE,eAAe,CAAC;IAClC,uEAAuE;IACvE,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,6DAA6D;IAC7D,QAAQ,CAAC,mBAAmB,EAAE,QAAQ,CAAC,MAAM,CAAC,mBAAmB,EAAE,MAAM,CAAC,CAAC,CAAC;IAC5E,kEAAkE;IAClE,QAAQ,CAAC,uBAAuB,EAAE,QAAQ,CAAC,MAAM,CAAC,mBAAmB,EAAE,MAAM,CAAC,CAAC,CAAC;IAChF,0EAA0E;IAC1E,QAAQ,CAAC,oBAAoB,EAAE,QAAQ,CAAC,MAAM,CAAC,mBAAmB,EAAE,MAAM,CAAC,CAAC,CAAC;CAC9E;AAED;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,EAAE,sBA2BT,CAAC;AAE7B;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,EAAE,sBA2BJ,CAAC;AAE7B;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,EAAE,sBA2BJ,CAAC;AAE7B;;;;;;;;;GASG;AACH,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CACjD,MAAM,CAAC,eAAe,EAAE,sBAAsB,CAAC,CAK/C,CAAC"}

package/dist/memory-router/backend-costs.js

@@ -0,0 +1,136 @@
+/**
+ * @file backend-costs.ts
+ * @description Per-backend per-category cost-accuracy-latency points
+ * measured on LongMemEval-S Phase B (N=500). The {@link MemoryRouter} uses
+ * these to:
+ *   - estimate the per-query USD cost of a routing decision before executing,
+ *   - apply budget constraints (`hard` / `soft` / `cheapest-fallback`),
+ *   - pick the cheapest backend that fits a budget when downgrading.
+ *
+ * Numbers come from the canonical Phase B run JSONs:
+ *   - canonical-hybrid: results/runs/2026-04-20T20-03-14-675 (Tier 1)
+ *   - observational-memory-v10: results/runs/2026-04-23T04-14-40-609 (Tier 2a v10)
+ *   - observational-memory-v11: results/runs/2026-04-23T17-27-28-793 (Tier 2b v11)
+ *
+ * The per-tier `avgCostPerQuery` is the totalUsd-divided-by-n_cases
+ * average; on routed configurations the actual per-call cost depends on
+ * which backend the dispatcher picked and which category the call hit, so
+ * the per-category breakdown below is what the router actually consumes.
+ *
+ * @module @framers/agentos/memory-router/backend-costs
+ */
+/**
+ * canonical-hybrid: BM25 + dense + RRF + Cohere rerank-v3.5 over raw
+ * memory traces. Phase B measured 73.2% [69.2, 77.0] aggregate at
+ * $0.0213/correct.
+ */
+export const TIER_1_CANONICAL_COSTS = Object.freeze({
+    backend: 'canonical-hybrid',
+    avgCostPerQuery: 0.0156,
+    perCategoryAccuracy: Object.freeze({
+        'single-session-user': 0.971,
+        'single-session-assistant': 0.893,
+        'single-session-preference': 0.600,
+        'knowledge-update': 0.868,
+        'multi-session': 0.549,
+        'temporal-reasoning': 0.702,
+    }),
+    perCategoryCostPerQuery: Object.freeze({
+        'single-session-user': 0.0191,
+        'single-session-assistant': 0.0175,
+        'single-session-preference': 0.0206,
+        'knowledge-update': 0.0189,
+        'multi-session': 0.0196,
+        'temporal-reasoning': 0.0202,
+    }),
+    perCategoryLatencyMs: Object.freeze({
+        'single-session-user': 104837,
+        'single-session-assistant': 55252,
+        'single-session-preference': 58373,
+        'knowledge-update': 82807,
+        'multi-session': 131188,
+        'temporal-reasoning': 100881,
+    }),
+});
+/**
+ * observational-memory-v10: synthesized observation log + classifier-driven
+ * dispatch inside the OM pipeline (no verbatim citation). Phase B measured
+ * 74.6% [70.8, 78.4] aggregate at $0.3265/correct, 12s avg latency.
+ */
+export const TIER_2A_V10_COSTS = Object.freeze({
+    backend: 'observational-memory-v10',
+    avgCostPerQuery: 0.2436,
+    perCategoryAccuracy: Object.freeze({
+        'single-session-user': 0.971,
+        'single-session-assistant': 0.839,
+        'single-session-preference': 0.600,
+        'knowledge-update': 0.859,
+        'multi-session': 0.602,
+        'temporal-reasoning': 0.710,
+    }),
+    perCategoryCostPerQuery: Object.freeze({
+        'single-session-user': 0.0214,
+        'single-session-assistant': 0.0195,
+        'single-session-preference': 0.0206,
+        'knowledge-update': 0.0306,
+        'multi-session': 0.0308,
+        'temporal-reasoning': 0.0206,
+    }),
+    perCategoryLatencyMs: Object.freeze({
+        'single-session-user': 7649,
+        'single-session-assistant': 5668,
+        'single-session-preference': 4469,
+        'knowledge-update': 19569,
+        'multi-session': 21360,
+        'temporal-reasoning': 4236,
+    }),
+});
+/**
+ * observational-memory-v11: v10 + conditional verbatim citation rule for
+ * knowledge-update and single-session-user categories. Phase B measured
+ * 75.4% [71.6, 79.0] aggregate at $0.4362/correct, 14s avg latency.
+ */
+export const TIER_2B_V11_COSTS = Object.freeze({
+    backend: 'observational-memory-v11',
+    avgCostPerQuery: 0.3289,
+    perCategoryAccuracy: Object.freeze({
+        'single-session-user': 0.986,
+        'single-session-assistant': 0.839,
+        'single-session-preference': 0.633,
+        'knowledge-update': 0.872,
+        'multi-session': 0.617,
+        'temporal-reasoning': 0.692,
+    }),
+    perCategoryCostPerQuery: Object.freeze({
+        'single-session-user': 0.0212,
+        'single-session-assistant': 0.0192,
+        'single-session-preference': 0.0206,
+        'knowledge-update': 0.0307,
+        'multi-session': 0.0336,
+        'temporal-reasoning': 0.0209,
+    }),
+    perCategoryLatencyMs: Object.freeze({
+        'single-session-user': 6676,
+        'single-session-assistant': 6879,
+        'single-session-preference': 8822,
+        'knowledge-update': 21085,
+        'multi-session': 27423,
+        'temporal-reasoning': 5025,
+    }),
+});
+/**
+ * Default cost-points registry. Indexed by {@link MemoryBackendId} so the
+ * router can look up the picked backend's cost on any category.
+ *
+ * Custom deployments can substitute their own cost-points by passing a
+ * different `backendCosts` map into the {@link MemoryRouter} config —
+ * useful when a workload diverges from the LongMemEval-S Phase B
+ * distribution and the calibrator wants to plug in measurements from
+ * their own benchmark.
+ */
+export const DEFAULT_MEMORY_BACKEND_COSTS = Object.freeze({
+    'canonical-hybrid': TIER_1_CANONICAL_COSTS,
+    'observational-memory-v10': TIER_2A_V10_COSTS,
+    'observational-memory-v11': TIER_2B_V11_COSTS,
+});
+//# sourceMappingURL=backend-costs.js.map

package/dist/memory-router/backend-costs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"backend-costs.js","sourceRoot":"","sources":["../../src/memory-router/backend-costs.ts"],"names":[],"mappings":"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"}

package/dist/memory-router/classifier.d.ts

@@ -0,0 +1,169 @@
+/**
+ * @file classifier.ts
+ * @description The LLM-as-judge classifier that the {@link MemoryRouter}
+ * uses to pick a {@link MemoryQueryCategory} for each incoming query.
+ *
+ * The classifier is deliberately abstracted behind {@link IMemoryClassifier}
+ * so callers can swap:
+ *   - the LLM client (any provider — OpenAI, Anthropic, local, mock) via
+ *     the {@link IMemoryClassifierLLM} adapter interface,
+ *   - the prompt variant (base vs few-shot) per-call,
+ *   - the classifier implementation entirely (e.g. a keyword-matcher or a
+ *     small custom ML model) by implementing {@link IMemoryClassifier}.
+ *
+ * The reference implementation, {@link LLMMemoryClassifier}, runs the
+ * gpt-5-mini-style cheap single-shot discriminator prompt and robustly
+ * parses the output, falling back to `multi-session` on unparseable
+ * responses (the safest default — multi-session routes cover cross-session
+ * synthesis which handles most misidentified question types gracefully).
+ *
+ * @module @framers/agentos/memory-router/classifier
+ */
+import { type MemoryQueryCategory } from './routing-tables.js';
+/**
+ * Minimal LLM-call interface the built-in classifier needs. Agentos
+ * consumers wire their preferred provider to this shape via an adapter
+ * — we intentionally do NOT import any provider SDK here so the
+ * memory-router module stays provider-agnostic.
+ */
+export interface MemoryClassifierLLMRequest {
+    /** System prompt. The classifier supplies this based on prompt variant. */
+    readonly system: string;
+    /** User prompt. The classifier renders `Question: {q}\n\nCategory:`. */
+    readonly user: string;
+    /** Max tokens to generate. Classifier passes ≤16 (bare category token). */
+    readonly maxTokens: number;
+    /** Temperature. Classifier passes 0 for determinism. */
+    readonly temperature: number;
+}
+/**
+ * Response shape the built-in classifier expects from the adapter.
+ */
+export interface MemoryClassifierLLMResponse {
+    /** The model's raw text. Whitespace is tolerated; the parser normalizes it. */
+    readonly text: string;
+    /** Input token count, for cost tracking. */
+    readonly tokensIn: number;
+    /** Output token count, for cost tracking. */
+    readonly tokensOut: number;
+    /** Model identifier the LLM reports. */
+    readonly model: string;
+}
+/**
+ * The LLM-client adapter the built-in classifier expects. Adapt any
+ * provider SDK (OpenAI, Anthropic, a provider-router, a mock) to this
+ * shape before passing into {@link LLMMemoryClassifier}.
+ */
+export interface IMemoryClassifierLLM {
+    invoke(request: MemoryClassifierLLMRequest): Promise<MemoryClassifierLLMResponse>;
+}
+/**
+ * Options passed per-call to {@link IMemoryClassifier.classify}. The
+ * classifier reads these to pick a prompt variant; everything else is
+ * constructor-scoped.
+ */
+export interface MemoryClassifierClassifyOptions {
+    /**
+     * Use the few-shot prompt variant instead of the base prompt. The
+     * few-shot prompt includes explicit Question/Category pairs targeting
+     * known confusion patterns (SSU-vs-SSA, SSP-vs-SSA, MS-vs-KU). Default
+     * false — the base prompt is ~2.5x cheaper per-classification-token and
+     * matches the shipping Tier 3 v10 classifier configuration.
+     */
+    readonly useFewShotPrompt?: boolean;
+}
+/**
+ * Result of a classification call. The returned category is always a
+ * valid {@link MemoryQueryCategory}; parse failures map to the safe
+ * fallback 'multi-session'.
+ */
+export interface MemoryClassifierResult {
+    readonly category: MemoryQueryCategory;
+    readonly tokensIn: number;
+    readonly tokensOut: number;
+    readonly model: string;
+}
+/**
+ * The public classifier contract. Implementations decide how to turn a
+ * query into a category — via LLM, keyword heuristic, small ML model, or
+ * mock.
+ */
+export interface IMemoryClassifier {
+    classify(query: string, options?: MemoryClassifierClassifyOptions): Promise<MemoryClassifierResult>;
+}
+/**
+ * Base classifier prompt. Lists the six category tokens with one-sentence
+ * definitions and a few examples per category, then instructs the model
+ * to emit ONLY the bare category token.
+ */
+export declare const CLASSIFIER_SYSTEM_PROMPT = "You are classifying a memory-system question into one of six categories.\n\nReturn ONLY the category token (no explanation, no quotes, no punctuation).\n\nCategories:\n- single-session-user: the question asks about something the USER said, did, or stated in a specific past session. Answer is in one session. Examples: \"What did I tell you about my favorite dessert?\", \"Where did I say I moved to last month?\"\n- single-session-assistant: the question asks about something the ASSISTANT said, generated, or recommended in a specific session. Answer is in one session. Examples: \"What recipe did you suggest for the birthday party?\", \"What books did you recommend to me?\"\n- single-session-preference: the question asks about a preference the user stated in passing. Answer is in one session. Examples: \"Do I prefer tea or coffee?\", \"What's my favorite type of movie?\"\n- knowledge-update: the question asks about current state where the answer EVOLVED across sessions (supersession). Examples: \"What's my current job title?\", \"Where do I live now?\", \"What's my latest project?\"\n- multi-session: the question requires combining information from 2+ separate sessions. Examples: \"How many different languages have I mentioned studying?\", \"Which authors did you recommend across our conversations?\"\n- temporal-reasoning: the question asks about the order, timing, or duration of events across time. Examples: \"In what order did I visit the three countries?\", \"How many months ago did I start the new job?\"";
+/**
+ * Few-shot variant of the classifier prompt. Adds explicit
+ * Question/Category pairs targeting confusion patterns observed in the
+ * gpt-5-mini base-prompt classifier on LongMemEval Tier A:
+ *   - SSA confused as SSU (YOU-said vs I-said distinction)
+ *   - SSP confused as SSA (preferences phrased like recommendations)
+ *   - MS confused as KU (cross-session vs current-state)
+ *
+ * Used when {@link MemoryClassifierClassifyOptions.useFewShotPrompt} is true.
+ */
+export declare const CLASSIFIER_SYSTEM_PROMPT_FEWSHOT = "You are classifying a memory-system question into one of six categories.\n\nReturn ONLY the category token (no explanation, no quotes, no punctuation).\n\nCategories:\n- single-session-user: the question asks about something the USER said, did, or stated in a specific past session. Answer is in one session.\n- single-session-assistant: the question asks about something the ASSISTANT said, generated, or recommended in a specific session. Answer is in one session.\n- single-session-preference: the question asks about a preference the user stated in passing. Answer is in one session.\n- knowledge-update: the question asks about current state where the answer EVOLVED across sessions (supersession). The user wants the LATEST value of an attribute that has changed over time.\n- multi-session: the question requires combining information from 2+ separate sessions. Counting, listing, or aggregating items the user mentioned across sessions.\n- temporal-reasoning: the question asks about the order, timing, or duration of events across time.\n\nExamples:\n\nQuestion: What did I tell you my favorite ice cream flavor was?\nCategory: single-session-user\n\nQuestion: Where did I say I moved to last month?\nCategory: single-session-user\n\nQuestion: What book did you recommend to me last week?\nCategory: single-session-assistant\n\nQuestion: What recipe did you suggest for the birthday party?\nCategory: single-session-assistant\n\nQuestion: Do I prefer working in the morning or evening?\nCategory: single-session-preference\n\nQuestion: What's my favorite type of movie?\nCategory: single-session-preference\n\nQuestion: What's my current job title?\nCategory: knowledge-update\n\nQuestion: Where do I live now?\nCategory: knowledge-update\n\nQuestion: How many different programming languages have I mentioned learning?\nCategory: multi-session\n\nQuestion: Which authors have you recommended to me across our conversations?\nCategory: multi-session\n\nQuestion: In what order did I visit the three European cities?\nCategory: temporal-reasoning\n\nQuestion: How many weeks ago did I start the new job?\nCategory: temporal-reasoning";
+/**
+ * Default fallback category used when the classifier's LLM output cannot
+ * be parsed into a known category token. multi-session is chosen because
+ * its routing target (OM-based cross-session synthesis under max-accuracy,
+ * canonical-hybrid under min-cost) degrades gracefully on most other
+ * question types.
+ */
+export declare const SAFE_FALLBACK_CATEGORY: MemoryQueryCategory;
+/**
+ * Strips common LLM-output decorations so the parser can match the bare
+ * category token:
+ *   - keeps only the first non-empty line,
+ *   - strips common label prefixes ("category:", "type:", "answer:"),
+ *   - strips surrounding quotes / backticks,
+ *   - strips trailing sentence punctuation,
+ *   - lower-cases the result.
+ */
+export declare function normalizeClassifierOutput(raw: string): string;
+/**
+ * Parse a normalized classifier output into a known category token, or
+ * return the safe fallback if no match is found.
+ */
+export declare function parseClassifierOutput(raw: string): MemoryQueryCategory;
+/**
+ * Constructor options for {@link LLMMemoryClassifier}.
+ */
+export interface LLMMemoryClassifierOptions {
+    /** LLM adapter the classifier calls. */
+    readonly llm: IMemoryClassifierLLM;
+    /**
+     * Max output tokens. Default 16 — the classifier only needs to emit
+     * one bare category token. Callers rarely need to change this.
+     */
+    readonly maxTokens?: number;
+}
+/**
+ * The built-in LLM-based classifier. Runs the category-discrimination
+ * prompt on the configured LLM adapter and parses the response robustly.
+ *
+ * @example
+ * ```ts
+ * import { LLMMemoryClassifier } from '../memory-router';
+ *
+ * const classifier = new LLMMemoryClassifier({
+ *   llm: createOpenAIClassifierAdapter('gpt-5-mini'),
+ * });
+ * const { category } = await classifier.classify(
+ *   "What's my current job title?",
+ * );
+ * // => { category: 'knowledge-update', tokensIn: 412, tokensOut: 4, model: 'gpt-5-mini-2025-08-07' }
+ * ```
+ */
+export declare class LLMMemoryClassifier implements IMemoryClassifier {
+    private readonly llm;
+    private readonly maxTokens;
+    constructor(options: LLMMemoryClassifierOptions);
+    classify(query: string, options?: MemoryClassifierClassifyOptions): Promise<MemoryClassifierResult>;
+}
+//# sourceMappingURL=classifier.d.ts.map

package/dist/memory-router/classifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"classifier.d.ts","sourceRoot":"","sources":["../../src/memory-router/classifier.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,EAEL,KAAK,mBAAmB,EACzB,MAAM,qBAAqB,CAAC;AAM7B;;;;;GAKG;AACH,MAAM,WAAW,0BAA0B;IACzC,2EAA2E;IAC3E,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,wEAAwE;IACxE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,2EAA2E;IAC3E,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,wDAAwD;IACxD,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;CAC9B;AAED;;GAEG;AACH,MAAM,WAAW,2BAA2B;IAC1C,+EAA+E;IAC/E,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,4CAA4C;IAC5C,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,6CAA6C;IAC7C,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,wCAAwC;IACxC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED;;;;GAIG;AACH,MAAM,WAAW,oBAAoB;IACnC,MAAM,CACJ,OAAO,EAAE,0BAA0B,GAClC,OAAO,CAAC,2BAA2B,CAAC,CAAC;CACzC;AAMD;;;;GAIG;AACH,MAAM,WAAW,+BAA+B;IAC9C;;;;;;OAMG;IACH,QAAQ,CAAC,gBAAgB,CAAC,EAAE,OAAO,CAAC;CACrC;AAED;;;;GAIG;AACH,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,QAAQ,EAAE,mBAAmB,CAAC;IACvC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED;;;;GAIG;AACH,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CACN,KAAK,EAAE,MAAM,EACb,OAAO,CAAC,EAAE,+BAA+B,GACxC,OAAO,CAAC,sBAAsB,CAAC,CAAC;CACpC;AAMD;;;;GAIG;AACH,eAAO,MAAM,wBAAwB,8/CAU0K,CAAC;AAEhN;;;;;;;;;GASG;AACH,eAAO,MAAM,gCAAgC,kmEAgDhB,CAAC;AAM9B;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB,EAAE,mBAAqC,CAAC;AAE3E;;;;;;;;GAQG;AACH,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAe7D;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,MAAM,GAAG,mBAAmB,CAYtE;AAMD;;GAEG;AACH,MAAM,WAAW,0BAA0B;IACzC,wCAAwC;IACxC,QAAQ,CAAC,GAAG,EAAE,oBAAoB,CAAC;IACnC;;;OAGG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,mBAAoB,YAAW,iBAAiB;IAC3D,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAuB;IAC3C,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;gBAEvB,OAAO,EAAE,0BAA0B;IAKzC,QAAQ,CACZ,KAAK,EAAE,MAAM,EACb,OAAO,CAAC,EAAE,+BAA+B,GACxC,OAAO,CAAC,sBAAsB,CAAC;CAoBnC"}