modelrig 0.0.1 → 0.2.0

package/dist/watch/state-store.js

@@ -0,0 +1,86 @@
+"use strict";
+/**
+ * Watch-state persistence — Phase 5 addendum A4.
+ *
+ * The watch loop's pricing snapshot has to survive between runs, and the
+ * runs happen in an EPHEMERAL cron container. A local file cannot do that:
+ * every run reads nothing, re-seeds, and reports zero events — the cron was
+ * live and structurally incapable of ever firing a proposal.
+ *
+ * Two implementations behind one interface:
+ *  - control plane (default when Supabase is configured): a keyed row in
+ *    `control_state`. Survives the container.
+ *  - local file (the self-host / no-Supabase fallback): the Phase 4
+ *    behavior, kept because a single-machine user should not need a
+ *    control plane to run a watch cycle.
+ *
+ * A store that cannot load is NOT treated as "no previous state". Seeding on
+ * a transient read failure would re-baseline the universe and silently
+ * swallow every price move since the last successful run, which is exactly
+ * the bug this file exists to fix — so a failed read throws.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WATCH_STATE_KEY = void 0;
+exports.createFileWatchStateStore = createFileWatchStateStore;
+exports.createControlPlaneWatchStateStore = createControlPlaneWatchStateStore;
+exports.createWatchStateStore = createWatchStateStore;
+const state_1 = require("./state");
+/** Key under which the pricing universe lives in `control_state`. */
+exports.WATCH_STATE_KEY = "watch:pricing-universe";
+function createFileWatchStateStore(path) {
+    return {
+        description: `local file ${path} (no control plane configured — NOT durable across containers)`,
+        load: async () => (0, state_1.loadWatchState)(path),
+        save: async (universe) => {
+            (0, state_1.saveWatchState)(path, universe);
+        },
+    };
+}
+function createControlPlaneWatchStateStore(config) {
+    const fetchFn = config.fetchFn ?? fetch;
+    const base = config.supabaseUrl.replace(/\/$/, "");
+    const key = config.key ?? exports.WATCH_STATE_KEY;
+    const headers = {
+        "content-type": "application/json",
+        apikey: config.serviceRoleKey,
+        authorization: `Bearer ${config.serviceRoleKey}`,
+    };
+    return {
+        description: `control plane control_state["${key}"]`,
+        async load() {
+            const response = await fetchFn(`${base}/rest/v1/control_state?select=value&key=eq.${encodeURIComponent(key)}`, { headers });
+            if (!response.ok) {
+                // Loud, not silent: a read failure that returned null would look
+                // exactly like a first run and re-seed the baseline.
+                throw new Error(`watch state read failed (${response.status}) — refusing to re-seed, because ` +
+                    "treating a failed read as 'no previous state' would discard every price move " +
+                    `since the last successful cycle. ${await response.text().catch(() => "")}`);
+            }
+            const rows = (await response.json());
+            return rows.length > 0 ? rows[0].value : null;
+        },
+        async save(universe) {
+            const response = await fetchFn(`${base}/rest/v1/control_state?on_conflict=key`, {
+                method: "POST",
+                headers: { ...headers, prefer: "resolution=merge-duplicates,return=minimal" },
+                body: JSON.stringify([
+                    { key, value: universe, updated_at: new Date().toISOString() },
+                ]),
+            });
+            if (!response.ok) {
+                throw new Error(`watch state write failed (${response.status}) — the next cycle would re-seed and ` +
+                    `miss this cycle's changes. ${await response.text().catch(() => "")}`);
+            }
+        },
+    };
+}
+/** Pick the durable store when a control plane exists, else the local file. */
+function createWatchStateStore(opts) {
+    if (opts.export === undefined)
+        return createFileWatchStateStore(opts.filePath);
+    return createControlPlaneWatchStateStore({
+        supabaseUrl: opts.export.supabaseUrl,
+        serviceRoleKey: opts.export.serviceRoleKey,
+        ...(opts.fetchFn !== undefined ? { fetchFn: opts.fetchFn } : {}),
+    });
+}

package/dist/watch/state.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Watch state — Phase 4 WS1. The cycle's memory: a JSON snapshot of the
+ * last-seen pricing universe (provider/model → token rates), diffed against
+ * the current pricing map each run. Seed runs emit no events by design.
+ *
+ * The universe is restricted to providers the loaded routes actually
+ * declare — a price move on a provider nobody routes to is not news.
+ */
+import type { TokenRates, WatchEvent } from "./evaluate";
+/** provider/model → rates. Keys use OUR provider ids, not LiteLLM's. */
+export type PriceUniverse = Record<string, TokenRates>;
+/** Build the current universe from the vendored pricing map, filtered to
+ * the providers in scope. Model ids are normalized to the bare form route
+ * candidates use ("gemini/gemini-2.5-pro" → "gemini-2.5-pro"). */
+export declare function buildPriceUniverse(providersInScope: ReadonlySet<string>, pricingMapPath?: string): PriceUniverse;
+/** Pure diff: current vs last-seen → events. Null previous = seed run,
+ * nothing fires. Delisted models are silence, not events. */
+export declare function computeWatchEvents(current: PriceUniverse, previous: PriceUniverse | null): WatchEvent[];
+export declare function loadWatchState(path: string): PriceUniverse | null;
+export declare function saveWatchState(path: string, universe: PriceUniverse): void;
+//# sourceMappingURL=state.d.ts.map

package/dist/watch/state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../src/watch/state.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,OAAO,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAEzD,wEAAwE;AACxE,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;AAkCvD;;kEAEkE;AAClE,wBAAgB,kBAAkB,CAChC,gBAAgB,EAAE,WAAW,CAAC,MAAM,CAAC,EACrC,cAAc,CAAC,EAAE,MAAM,GACtB,aAAa,CAoBf;AAED;6DAC6D;AAC7D,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,aAAa,EACtB,QAAQ,EAAE,aAAa,GAAG,IAAI,GAC7B,UAAU,EAAE,CAkBd;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,aAAa,GAAG,IAAI,CAGjE;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,aAAa,GAAG,IAAI,CAG1E"}

package/dist/watch/state.js

@@ -0,0 +1,93 @@
+"use strict";
+/**
+ * Watch state — Phase 4 WS1. The cycle's memory: a JSON snapshot of the
+ * last-seen pricing universe (provider/model → token rates), diffed against
+ * the current pricing map each run. Seed runs emit no events by design.
+ *
+ * The universe is restricted to providers the loaded routes actually
+ * declare — a price move on a provider nobody routes to is not news.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildPriceUniverse = buildPriceUniverse;
+exports.computeWatchEvents = computeWatchEvents;
+exports.loadWatchState = loadWatchState;
+exports.saveWatchState = saveWatchState;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+/** LiteLLM's litellm_provider values → our ProviderId space (watch scope:
+ * the launch providers; extending = adding a line). */
+const LITELLM_PROVIDER_MAP = {
+    gemini: "gemini",
+    openai: "openai",
+    deepseek: "deepseek",
+    anthropic: "anthropic",
+    xai: "grok",
+    // A1 hosts (openai-compatible generic adapter).
+    deepinfra: "deepinfra",
+    fireworks_ai: "fireworks",
+};
+/** Normalize a pricing-map key to the bare model id route candidates use:
+ * strip the leading litellm-provider segment, then Fireworks' wire prefix.
+ * DeepInfra org paths ("Qwen/QwQ-32B") are PART of the model id — kept. */
+function normalizeModelId(rawKey, litellmProvider) {
+    let model = rawKey.startsWith(`${litellmProvider}/`)
+        ? rawKey.slice(litellmProvider.length + 1)
+        : rawKey;
+    if (model.startsWith("accounts/fireworks/models/")) {
+        model = model.slice("accounts/fireworks/models/".length);
+    }
+    return model;
+}
+/** Build the current universe from the vendored pricing map, filtered to
+ * the providers in scope. Model ids are normalized to the bare form route
+ * candidates use ("gemini/gemini-2.5-pro" → "gemini-2.5-pro"). */
+function buildPriceUniverse(providersInScope, pricingMapPath) {
+    const path = pricingMapPath ?? (0, node_path_1.join)(__dirname, "..", "..", "data", "pricing-map.json");
+    const map = JSON.parse((0, node_fs_1.readFileSync)(path, "utf8"));
+    const universe = {};
+    for (const [rawKey, entry] of Object.entries(map)) {
+        const provider = LITELLM_PROVIDER_MAP[entry.litellm_provider ?? ""];
+        if (provider === undefined || !providersInScope.has(provider))
+            continue;
+        if (typeof entry.input_cost_per_token !== "number" ||
+            typeof entry.output_cost_per_token !== "number") {
+            continue;
+        }
+        const model = normalizeModelId(rawKey, entry.litellm_provider ?? "");
+        universe[`${provider}/${model}`] = {
+            inputUsdPerTok: entry.input_cost_per_token,
+            outputUsdPerTok: entry.output_cost_per_token,
+        };
+    }
+    return universe;
+}
+/** Pure diff: current vs last-seen → events. Null previous = seed run,
+ * nothing fires. Delisted models are silence, not events. */
+function computeWatchEvents(current, previous) {
+    if (previous === null)
+        return [];
+    const events = [];
+    for (const [key, rates] of Object.entries(current)) {
+        const slash = key.indexOf("/");
+        const provider = key.slice(0, slash);
+        const model = key.slice(slash + 1);
+        const before = previous[key];
+        if (before === undefined) {
+            events.push({ type: "new_model", provider, model, pricing: rates });
+        }
+        else if (before.inputUsdPerTok !== rates.inputUsdPerTok ||
+            before.outputUsdPerTok !== rates.outputUsdPerTok) {
+            events.push({ type: "price_change", provider, model, old: before, new: rates });
+        }
+    }
+    return events;
+}
+function loadWatchState(path) {
+    if (!(0, node_fs_1.existsSync)(path))
+        return null;
+    return JSON.parse((0, node_fs_1.readFileSync)(path, "utf8"));
+}
+function saveWatchState(path, universe) {
+    (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(path), { recursive: true });
+    (0, node_fs_1.writeFileSync)(path, `${JSON.stringify(universe, null, 2)}\n`);
+}

package/package.json

@@ -1,20 +1,62 @@
 {
   "name": "modelrig",
-  "version": "0.0.1",
-  "description": "ModelRig — the capability-aware AI gateway. Rig it. Prove it. Sell it. Full release coming soon.",
-  "homepage": "https://modelrig.ai",
+  "version": "0.2.0",
+  "private": false,
+  "description": "ModelRig — capability-aware AI gateway: routes-as-code, provider adapters, typed failures, budget envelopes, and local-first telemetry.",
   "license": "Apache-2.0",
-  "main": "index.js",
-  "files": [
-    "index.js",
-    "README.md"
-  ],
+  "homepage": "https://modelrig.dev",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/modelrig/modelrig.git"
+  },
   "keywords": [
-    "ai",
     "llm",
-    "gateway",
-    "routing",
-    "evals",
-    "structured-output"
-  ]
+    "ai-gateway",
+    "model-routing",
+    "openai",
+    "anthropic",
+    "gemini",
+    "telemetry",
+    "failover"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "//files": "ALLOWLIST, not a denylist, and the difference is not academic. Without this field npm falls back to .npmignore, then to THIS DIRECTORY's .gitignore — never the repo root's. The root ignores `.env.*`, which is why git has never committed .env.local; the package-level .gitignore says nothing about it, so `npm pack` happily included it. A publish would have shipped 13 live secrets, the Supabase service-role key among them, into an immutable public tarball. Anything added here must be something we would hand a stranger. See __tests__/publish-safety.test.ts.",
+  "//files-registry": "registry/{registry,leaderboard}.json are fail-open runtime reads (facts.ts/rows.ts degrade to the static baseline when absent) — shipped by R-1 F2 RULING so a clean install routes on the PROBED capability profile the docs and the DVP report describe, not the static fallback. Enumerated file entries, NOT the registry/ dir (it also holds build scripts + tests). Public CC BY 4.0.",
+  "//files-data": "`data/` is a RUNTIME dependency, not a build input (R-1 clean-room audit, A1): getPricing() reads data/pricing-map.json from the package root at first cost lookup, with NO existsSync guard — so an absent data/ throws, not degrades. 0.1.0 shipped dist-only and broke the flagship 'effective cost' story on a clean `npm i`. It is public CC BY 4.0 pricing data (data/PROVENANCE.md) — safe to hand a stranger. The tarball clean-room test (__tests__/tarball-cleanroom.test.ts) installs the packed artifact and asserts getPricing() returns a real rate, so this can never silently regress again.",
+  "files": [
+    "dist",
+    "data",
+    "registry/registry.json",
+    "registry/leaderboard.json",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "type-check": "tsc --noEmit && tsc -p tsconfig.test.json",
+    "test": "vitest run",
+    "test:live": "MODELRIG_LIVE=1 vitest run"
+  },
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.71.2",
+    "@google/genai": "^2.4.0",
+    "ajv": "^8.17.0",
+    "better-sqlite3": "^11.10.0",
+    "openai": "^4.77.0",
+    "yaml": "^2.6.0"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.12",
+    "tsx": "^4.21.0",
+    "typescript": "^5.2.0",
+    "vitest": "^2.1.0"
+  },
+  "bin": {
+    "modelrig": "dist/cli.js"
+  }
 }

package/registry/LICENSE

@@ -0,0 +1,20 @@
+The ModelRig registry data (registry.json, layers/, leaderboard.json, and all
+probe-derived data files in this directory) is licensed under the Creative
+Commons Attribution 4.0 International License (CC BY 4.0).
+
+You are free to share and adapt this data for any purpose, including
+commercially, provided you give appropriate credit to ModelRig
+(https://modelrig.dev), link to the license, and indicate if changes were made.
+
+Full license text: https://creativecommons.org/licenses/by/4.0/legalcode
+
+Attribution example:
+  "Model capability data from the ModelRig registry (https://modelrig.dev),
+   CC BY 4.0."
+
+The build scripts in this directory (build-*.ts) are code, licensed under the
+repository's Apache-2.0 LICENSE.
+
+The pricing snapshot under data/ is derived from BerriAI/litellm's
+model_prices_and_context_window.json (MIT License, Copyright (c) 2023 Berri AI)
+at the pinned SHA recorded in data/PROVENANCE.md.