modelrig 0.0.1 → 0.1.0

package/dist/registry/build.js

@@ -0,0 +1,192 @@
+"use strict";
+/**
+ * Registry v0 build logic — spec WS3. Pure functions (script entrypoints in
+ * registry/ do the IO): declared from the vendored pricing map + adapter
+ * capability maps; probed from probe result files; observed from telemetry
+ * aggregates; merge + discrepancy detection.
+ *
+ * PRIVACY (spec WS6 / plan step-4 review): the observed layer publishes
+ * AGGREGATES ONLY — no tags, no payloads, no fingerprint joins.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.latestPerClass = latestPerClass;
+exports.summarizeSchemaResult = summarizeSchemaResult;
+exports.summarizeGroundingResult = summarizeGroundingResult;
+exports.summarizeCachingResult = summarizeCachingResult;
+exports.buildProbedLayer = buildProbedLayer;
+exports.detectDiscrepancies = detectDiscrepancies;
+exports.buildRegistry = buildRegistry;
+exports.effectiveCostPer1kConformant = effectiveCostPer1kConformant;
+const call_notes_1 = require("./call-notes");
+const claims_1 = require("./claims");
+const CONFORMANCE_BAR = 0.9;
+const GROUNDED_BAR = 0.5;
+function mean(values) {
+    if (values.length === 0)
+        return null;
+    return values.reduce((a, b) => a + b, 0) / values.length;
+}
+function wilson95(successes, n) {
+    if (n === 0)
+        return [0, 1];
+    const z = 1.959963984540054;
+    const p = successes / n;
+    const z2 = z * z;
+    const denominator = 1 + z2 / n;
+    const center = (p + z2 / (2 * n)) / denominator;
+    const half = (z * Math.sqrt((p * (1 - p)) / n + z2 / (4 * n * n))) / denominator;
+    return [Math.max(0, center - half), Math.min(1, center + half)];
+}
+/** Latest result per class wins (results are dated). */
+function latestPerClass(results) {
+    const byClass = {};
+    for (const result of results) {
+        const current = byClass[result.class];
+        if (current === undefined || result.date > current.date) {
+            byClass[result.class] = result;
+        }
+    }
+    return byClass;
+}
+function summarizeSchemaResult(result) {
+    const samples = Object.values(result.raw).flat();
+    const n = samples.length;
+    const judged = samples.filter((s) => s.schemaConform !== null);
+    const conforming = judged.filter((s) => s.schemaConform === true).length;
+    const rungs = samples.filter((s) => s.rung !== undefined);
+    const accuracies = samples
+        .map((s) => s.valueAccuracy)
+        .filter((a) => a !== null);
+    return {
+        samples: n,
+        parse_rate: n === 0 ? 0 : samples.filter((s) => s.parseOk).length / n,
+        conform_rate: judged.length === 0 ? null : conforming / judged.length,
+        conform_ci95: judged.length === 0 ? null : wilson95(conforming, judged.length),
+        value_accuracy_mean: mean(accuracies),
+        native_rung_rate: rungs.length === 0 ? null : rungs.filter((s) => s.rung === "native").length / rungs.length,
+        mean_cost_usd: n === 0 ? 0 : samples.reduce((a, s) => a + s.costUsd, 0) / n,
+    };
+}
+function summarizeGroundingResult(result) {
+    const samples = Object.values(result.raw).flat();
+    const n = samples.length;
+    return {
+        samples: n,
+        grounded_rate: n === 0 ? 0 : samples.filter((s) => s.grounded === true).length / n,
+        mean_citations: mean(samples.map((s) => s.citationCount ?? 0)) ?? 0,
+    };
+}
+function summarizeCachingResult(result) {
+    const samples = Object.values(result.raw).flat();
+    const okSamples = samples.filter((s) => s.failureClass === null);
+    const n = okSamples.length;
+    return {
+        samples: samples.length,
+        cache_hit_rate: n === 0 ? 0 : okSamples.filter((s) => (s.cachedTokens ?? 0) > 0).length / n,
+        mean_cached_tokens: mean(okSamples.map((s) => s.cachedTokens ?? 0)) ?? 0,
+    };
+}
+function buildProbedLayer(results) {
+    if (results.length === 0)
+        return null;
+    const byClass = latestPerClass(results);
+    const dates = results.map((r) => r.date).sort();
+    const versions = results.map((r) => r.harnessVersion).sort();
+    const newest = dates[dates.length - 1];
+    const version = versions[versions.length - 1];
+    return {
+        as_of: newest,
+        source: `modelrig-probes@${version}`,
+        schema: byClass.schema !== undefined ? summarizeSchemaResult(byClass.schema) : null,
+        grounding: byClass.grounding !== undefined ? summarizeGroundingResult(byClass.grounding) : null,
+        caching: byClass.caching !== undefined ? summarizeCachingResult(byClass.caching) : null,
+    };
+}
+/** Declared-vs-probed disagreement detection — plan §4 (the rule pair) plus
+ * the rung gap that motivated the whole exercise (DeepSeek json_object). */
+function detectDiscrepancies(declared, probed) {
+    if (declared === null || probed === null)
+        return [];
+    const out = [];
+    const schema = probed.schema;
+    if (schema !== null && schema.conform_rate !== null) {
+        if (declared.flags.supports_response_schema === true && schema.conform_rate < CONFORMANCE_BAR) {
+            out.push({
+                kind: "declared_schema_low_conformance",
+                message: `declared supports_response_schema, but probed conformance is ` +
+                    `${(schema.conform_rate * 100).toFixed(0)}% (bar: ${CONFORMANCE_BAR * 100}%)`,
+            });
+        }
+        if (declared.flags.supports_response_schema !== true &&
+            schema.conform_rate >= CONFORMANCE_BAR) {
+            out.push({
+                kind: "undeclared_schema_capable",
+                message: `no declared schema support, but probed conformance is ` +
+                    `${(schema.conform_rate * 100).toFixed(0)}% — capability exists undeclared`,
+            });
+        }
+    }
+    if (schema !== null &&
+        schema.native_rung_rate !== null &&
+        declared.flags.supports_response_schema === true &&
+        schema.native_rung_rate === 0) {
+        out.push({
+            kind: "schema_served_via_json_mode",
+            message: "declared supports_response_schema, but every probed sample was served via " +
+                "json_mode coaching — no native strict enforcement exists on this serving path " +
+                "(the json_object-vs-schema gap)",
+        });
+    }
+    const grounding = probed.grounding;
+    if (grounding !== null && grounding.samples > 0) {
+        if (declared.flags.supports_web_search === true && grounding.grounded_rate < GROUNDED_BAR) {
+            out.push({
+                kind: "declared_search_ungrounded",
+                message: `declared supports_web_search, but only ${(grounding.grounded_rate * 100).toFixed(0)}% ` +
+                    `of probed answers carried citations (bar: ${GROUNDED_BAR * 100}%)`,
+            });
+        }
+        if (declared.flags.supports_web_search !== true && grounding.grounded_rate >= GROUNDED_BAR) {
+            out.push({
+                kind: "citations_without_declared_search",
+                message: `no declared web-search support, but ${(grounding.grounded_rate * 100).toFixed(0)}% of ` +
+                    `probed answers cited URLs — verify whether these are real or fabricated sources`,
+            });
+        }
+    }
+    const caching = probed.caching;
+    if (caching !== null && caching.samples > 0) {
+        if (declared.flags.supports_prompt_caching === true && caching.cache_hit_rate === 0) {
+            out.push({
+                kind: "declared_caching_unrealized",
+                message: "declared supports_prompt_caching, but no probed repeat call reported cached tokens",
+            });
+        }
+    }
+    return out;
+}
+function buildRegistry(entries, generatedAt) {
+    return {
+        generated_at: generatedAt,
+        license: "CC-BY-4.0",
+        models: entries
+            .map((e) => ({
+            model_key: e.model_key,
+            declared: e.declared,
+            probed: e.probed,
+            observed: e.observed,
+            discrepancies: detectDiscrepancies(e.declared, e.probed),
+            callNotes: (0, call_notes_1.callNotesFor)(e.model_key),
+            facts: (0, claims_1.factsFor)(e.model_key),
+        }))
+            .sort((a, b) => (a.model_key < b.model_key ? -1 : 1)),
+    };
+}
+/** Leaderboard ranking metric — spec WS3: "conformance per dollar".
+ * Effective $ per 1K conformant outputs: mean sample cost ÷ conform rate
+ * × 1000. Null when unjudged or never conformant. */
+function effectiveCostPer1kConformant(schema) {
+    if (schema === null || schema.conform_rate === null || schema.conform_rate === 0)
+        return null;
+    return (schema.mean_cost_usd / schema.conform_rate) * 1000;
+}

package/dist/registry/call-notes.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Per-model call-shaping knowledge as data — addendum A1 (Phase 2), closed as
+ * post-C2 patch P1 (Phase 3 step 0). Seeded from the adapters' documented
+ * constraints (the same facts the adapter code enforces); consumed by the
+ * registry artifact today and the Phase 5 oracle's `get_call_notes` later.
+ * Registry entries carry these top-level as `callNotes[]`; the Supabase
+ * mirror rides them inside the existing `declared` jsonb (no migration).
+ */
+/** Call notes for a "provider/model" key; [] for unknown providers. */
+export declare function callNotesFor(modelKey: string): readonly string[];
+//# sourceMappingURL=call-notes.d.ts.map

package/dist/registry/call-notes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"call-notes.d.ts","sourceRoot":"","sources":["../../src/registry/call-notes.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AA8BH,uEAAuE;AACvE,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,CAoChE"}

package/dist/registry/call-notes.js

@@ -0,0 +1,72 @@
+"use strict";
+/**
+ * Per-model call-shaping knowledge as data — addendum A1 (Phase 2), closed as
+ * post-C2 patch P1 (Phase 3 step 0). Seeded from the adapters' documented
+ * constraints (the same facts the adapter code enforces); consumed by the
+ * registry artifact today and the Phase 5 oracle's `get_call_notes` later.
+ * Registry entries carry these top-level as `callNotes[]`; the Supabase
+ * mirror rides them inside the existing `declared` jsonb (no migration).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callNotesFor = callNotesFor;
+/** Models that accept thinkingConfig — mirror of the gemini adapter's set. */
+const GEMINI_THINKING_CAPABLE = new Set([
+    "gemini-3.1-pro-preview",
+    "gemini-3.0-pro-preview",
+    "gemini-3.1-flash-preview",
+]);
+const GEMINI_COMMON = [
+    "temperature must be 1.0 — lower values cause output looping on Gemini 3 models",
+    "native strict structured output via responseJsonSchema; very complex schemas can be rejected as INVALID_ARGUMENT (complexity ceiling)",
+    "native web grounding via the googleSearch tool",
+    "cachedContent excludes systemInstruction and tools — bake the system prompt (and the googleSearch tool for grounded steps) into the cache at creation time",
+];
+const OPENAI_COMMON = [
+    "native strict structured output via response_format json_schema with strict: true",
+    "streamed refusal deltas are terminal for the call, even alongside partial content",
+    "prompt caching is keyed via prompt_cache_key; retention extends to 24h when the cache directive's TTL is ≥ 86400s",
+    "finish_reason=stop with <200 visible completion tokens on a 50K+ token prompt indicates flex-tier degradation or a stream drop — treat as invalid, not success",
+];
+const DEEPSEEK_COMMON = [
+    "no native json_schema — json_object forcing only; the schema must be coached into the prompt and validated caller-side",
+    'json_object mode returns 400 unless the literal word "JSON" appears in the prompt',
+    "automatic prefix caching: prompt_cache_hit_tokens are billed ~10x cheaper than fresh input",
+    "no service tiers — served tier is always standard",
+];
+/** Call notes for a "provider/model" key; [] for unknown providers. */
+function callNotesFor(modelKey) {
+    const slash = modelKey.indexOf("/");
+    if (slash <= 0)
+        return [];
+    const provider = modelKey.slice(0, slash);
+    const model = modelKey.slice(slash + 1);
+    switch (provider) {
+        case "gemini":
+            return [
+                ...GEMINI_COMMON,
+                GEMINI_THINKING_CAPABLE.has(model)
+                    ? "accepts thinkingConfig (thinking level); thinking tokens are billed as output and count against maxOutputTokens"
+                    : "does NOT accept thinkingConfig — sending it returns 400 (thinking models only)",
+            ];
+        case "openai": {
+            const flexEligible = !model.includes("-mini") &&
+                !model.includes("-nano") &&
+                ["gpt-5.4", "gpt-5.2", "gpt-5.1", "gpt-5", "gpt-4.1"].some((p) => model.startsWith(p));
+            return [
+                ...OPENAI_COMMON,
+                flexEligible
+                    ? "flex service tier eligible — discounted, sheddable capacity; served tier is echoed on the stream"
+                    : "NOT flex-eligible (mini/nano and older families) — flex requests are silently served at default tier",
+            ];
+        }
+        case "deepseek":
+            return [
+                ...DEEPSEEK_COMMON,
+                model.includes("reasoner")
+                    ? "emits reasoning_content (chain-of-thought) deltas — exclude them from the JSON buffer; only delta.content is the answer"
+                    : "max_tokens up to 64K — full capacity for long structured reports",
+            ];
+        default:
+            return [];
+    }
+}

package/dist/registry/claims.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Curated credential-scoped claims — Phase 4 WS3 fact-shape upgrade.
+ * Every fact is {value, scope, source, as_of}: WHAT is claimed, UNDER WHICH
+ * CREDENTIAL it holds, WHERE it's cited, and WHEN it was checked.
+ *
+ * Scope semantics (the TrustedRouter lesson): a provider's zero-data-
+ * retention arrangement on OUR managed account does not transfer to a
+ * customer's own (BYOK) key — the same capability can be true on one
+ * credential and false on the other, and conflating them is a compliance
+ * hazard. Conservative default: models/facts absent here are absent from
+ * the registry — false-until-cited, same doctrine as probed-beats-declared.
+ *
+ * This is the curated seed (same pattern as call-notes.ts); probe-derived
+ * facts can join the same shape later without changing consumers.
+ */
+export declare const SCOPES: readonly ["managed", "byok", "any"];
+export type FactScope = (typeof SCOPES)[number];
+export interface ScopedFact {
+    readonly value: boolean | string | number;
+    /** Which credential the claim holds under: the vendor-managed account,
+     * a bring-your-own-key credential, or any. */
+    readonly scope: FactScope;
+    /** Citation — a URL or document reference; never "we assume". */
+    readonly source: string;
+    readonly as_of: string;
+}
+export type ModelFacts = Readonly<Record<string, readonly ScopedFact[]>>;
+/** Facts for a model, or null when nothing is cited (the conservative
+ * default — absence is the claim). */
+export declare function factsFor(modelKey: string): ModelFacts | null;
+/** Which credential an account is calling a model under. Phase 6 WS3: the
+ * telemetry `key_ownership` dimension, seen from the registry's side. */
+export type CredentialOwnership = "managed" | "byok";
+/** A fact resolved to what holds under ONE credential. */
+export interface CredentialScopedFact {
+    readonly value: boolean | string | number;
+    readonly source: string;
+    readonly as_of: string;
+    /**
+     * True when a fact is cited for THIS credential (its own scope or `any`).
+     * False means "not established for your key" — the honest answer when a
+     * fact holds only under our managed account and the account is BYOK. It is
+     * NEVER silently promoted to the managed value.
+     */
+    readonly established: boolean;
+}
+/**
+ * Render a model's facts as they hold under ONE account's credential — Phase 6
+ * WS3, the "credential-scoped facts render per account" deliverable.
+ *
+ * THE RULE, and the whole reason this exists: **a BYOK key does not inherit our
+ * managed-account posture.** If `zero_retention` is cited `true` under
+ * `managed` and nothing is cited under `byok`, a BYOK account sees
+ * `established: false` — not `true`. Inheriting the managed value onto a
+ * customer's own key is the exact compliance hazard claims.ts's scope field
+ * exists to prevent (the TrustedRouter lesson). An `any`-scoped fact holds on
+ * every credential; a scope-specific fact holds only on its own.
+ *
+ * Returns one entry per fact NAME, so a caller (the console's model surface)
+ * can render "zero retention: yes / not established for your key" honestly.
+ */
+export declare function factsUnderCredential(modelKey: string, ownership: CredentialOwnership): Readonly<Record<string, CredentialScopedFact>>;
+//# sourceMappingURL=claims.d.ts.map

package/dist/registry/claims.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"claims.d.ts","sourceRoot":"","sources":["../../src/registry/claims.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,eAAO,MAAM,MAAM,qCAAsC,CAAC;AAC1D,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,MAAM,CAAC,CAAC,MAAM,CAAC,CAAC;AAEhD,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,MAAM,CAAC;IAC1C;kDAC8C;IAC9C,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC;IAC1B,iEAAiE;IACjE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,MAAM,UAAU,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,UAAU,EAAE,CAAC,CAAC,CAAC;AA0CzE;sCACsC;AACtC,wBAAgB,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI,CAE5D;AAED;yEACyE;AACzE,MAAM,MAAM,mBAAmB,GAAG,SAAS,GAAG,MAAM,CAAC;AAErD,0DAA0D;AAC1D,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,MAAM,CAAC;IAC1C,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB;;;;;OAKG;IACH,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;CAC/B;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,mBAAmB,GAC7B,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAC,CAwBhD"}

package/dist/registry/claims.js

@@ -0,0 +1,107 @@
+"use strict";
+/**
+ * Curated credential-scoped claims — Phase 4 WS3 fact-shape upgrade.
+ * Every fact is {value, scope, source, as_of}: WHAT is claimed, UNDER WHICH
+ * CREDENTIAL it holds, WHERE it's cited, and WHEN it was checked.
+ *
+ * Scope semantics (the TrustedRouter lesson): a provider's zero-data-
+ * retention arrangement on OUR managed account does not transfer to a
+ * customer's own (BYOK) key — the same capability can be true on one
+ * credential and false on the other, and conflating them is a compliance
+ * hazard. Conservative default: models/facts absent here are absent from
+ * the registry — false-until-cited, same doctrine as probed-beats-declared.
+ *
+ * This is the curated seed (same pattern as call-notes.ts); probe-derived
+ * facts can join the same shape later without changing consumers.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SCOPES = void 0;
+exports.factsFor = factsFor;
+exports.factsUnderCredential = factsUnderCredential;
+exports.SCOPES = ["managed", "byok", "any"];
+/** The curated claims table. Add entries WITH citations only. */
+const CLAIMS = {
+    "openai/gpt-5.4-mini": {
+        zero_retention: [
+            {
+                // OpenAI's API-platform data controls: eligible orgs can be approved
+                // for zero data retention on the API — an ACCOUNT property, granted
+                // to our managed platform account.
+                value: true,
+                scope: "managed",
+                source: "https://platform.openai.com/docs/models/how-we-use-your-data",
+                as_of: "2026-08-02",
+            },
+            {
+                // The same claim does NOT transfer to a customer's own key: a BYOK
+                // org has whatever retention ITS account negotiated — unknowable
+                // from here, so the honest value is false (not "probably fine").
+                value: false,
+                scope: "byok",
+                source: "https://platform.openai.com/docs/models/how-we-use-your-data",
+                as_of: "2026-08-02",
+            },
+        ],
+    },
+    "gemini/gemini-3.1-pro-preview": {
+        zero_retention: [
+            {
+                // Paid-tier Gemini API: prompts/outputs not used for training, but
+                // retained transiently for abuse monitoring — that is NOT zero
+                // retention, on any credential. Recorded false to keep the registry
+                // honest where marketing language blurs.
+                value: false,
+                scope: "any",
+                source: "https://ai.google.dev/gemini-api/terms",
+                as_of: "2026-08-02",
+            },
+        ],
+    },
+};
+/** Facts for a model, or null when nothing is cited (the conservative
+ * default — absence is the claim). */
+function factsFor(modelKey) {
+    return CLAIMS[modelKey] ?? null;
+}
+/**
+ * Render a model's facts as they hold under ONE account's credential — Phase 6
+ * WS3, the "credential-scoped facts render per account" deliverable.
+ *
+ * THE RULE, and the whole reason this exists: **a BYOK key does not inherit our
+ * managed-account posture.** If `zero_retention` is cited `true` under
+ * `managed` and nothing is cited under `byok`, a BYOK account sees
+ * `established: false` — not `true`. Inheriting the managed value onto a
+ * customer's own key is the exact compliance hazard claims.ts's scope field
+ * exists to prevent (the TrustedRouter lesson). An `any`-scoped fact holds on
+ * every credential; a scope-specific fact holds only on its own.
+ *
+ * Returns one entry per fact NAME, so a caller (the console's model surface)
+ * can render "zero retention: yes / not established for your key" honestly.
+ */
+function factsUnderCredential(modelKey, ownership) {
+    const facts = CLAIMS[modelKey];
+    if (facts === undefined)
+        return {};
+    const out = {};
+    for (const [name, claims] of Object.entries(facts)) {
+        // Prefer the credential-specific claim; fall back to an `any` claim; never
+        // borrow the OTHER credential's claim.
+        const specific = claims.find((c) => c.scope === ownership);
+        const anyScoped = claims.find((c) => c.scope === "any");
+        const chosen = specific ?? anyScoped;
+        if (chosen !== undefined) {
+            out[name] = {
+                value: chosen.value,
+                source: chosen.source,
+                as_of: chosen.as_of,
+                established: true,
+            };
+        }
+        else {
+            // A managed-only fact seen from a BYOK account (or vice-versa): not
+            // inherited. The value is the conservative false, flagged not-established.
+            out[name] = { value: false, source: claims[0]?.source ?? "", as_of: claims[0]?.as_of ?? "", established: false };
+        }
+    }
+    return out;
+}

package/dist/registry/facts.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Registry-wired capability facts — Phase 3 spec WS6, plan §4. Replaces the
+ * Phase 1 "grant whatever the adapter claims" stub: routing now consumes
+ * declared+probed registry facts from the packaged registry.json
+ * (env-overridable path), with precedence
+ *
+ *   capabilityOverrides (config) > probed > declared
+ *
+ * applied PER FLAG. Discrepancy-aware: a probed-false trumps a declared-true
+ * — the DeepSeek case (declared supports_response_schema, probed
+ * native_rung_rate = 0) finally routes correctly.
+ *
+ * Conservatism rules (measurement honesty):
+ *  - grounded_native: probed can only REVOKE (a declared-true with a low
+ *    probed grounded rate), never grant — high citation rates without
+ *    declared search may be fabricated URLs.
+ *  - Unprobed/undeclared dimensions (explicit caches, cache keys, flex tier,
+ *    trace visibility) fall back to the adapter-static map, which is the
+ *    declared layer for call-shaping facts.
+ */
+import type { CapabilityFlag, ProviderId } from "../types/provider";
+import type { RegistryEntry } from "./build";
+export interface RegistryFacts {
+    /** Capability flags for a (provider, model), or null when the registry has
+     * no entry for it (caller falls back to the adapter-static map). */
+    flagsFor(provider: ProviderId, model: string, staticFlags: ReadonlySet<CapabilityFlag>): ReadonlySet<CapabilityFlag> | null;
+}
+/** Per-flag fact merge for one registry entry. `staticFlags` is the
+ * adapter-static (declared call-shaping) baseline. */
+export declare function capabilityFactsFromEntry(entry: RegistryEntry, staticFlags: ReadonlySet<CapabilityFlag>): Set<CapabilityFlag>;
+export declare function loadRegistryFacts(registryPath?: string): RegistryFacts;
+//# sourceMappingURL=facts.d.ts.map

package/dist/registry/facts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"facts.d.ts","sourceRoot":"","sources":["../../src/registry/facts.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAIH,OAAO,KAAK,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpE,OAAO,KAAK,EAAY,aAAa,EAAE,MAAM,SAAS,CAAC;AAMvD,MAAM,WAAW,aAAa;IAC5B;wEACoE;IACpE,QAAQ,CACN,QAAQ,EAAE,UAAU,EACpB,KAAK,EAAE,MAAM,EACb,WAAW,EAAE,WAAW,CAAC,cAAc,CAAC,GACvC,WAAW,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC;CACvC;AAED;sDACsD;AACtD,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,aAAa,EACpB,WAAW,EAAE,WAAW,CAAC,cAAc,CAAC,GACvC,GAAG,CAAC,cAAc,CAAC,CAsDrB;AAQD,wBAAgB,iBAAiB,CAAC,YAAY,CAAC,EAAE,MAAM,GAAG,aAAa,CA8BtE"}

package/dist/registry/facts.js

@@ -0,0 +1,120 @@
+"use strict";
+/**
+ * Registry-wired capability facts — Phase 3 spec WS6, plan §4. Replaces the
+ * Phase 1 "grant whatever the adapter claims" stub: routing now consumes
+ * declared+probed registry facts from the packaged registry.json
+ * (env-overridable path), with precedence
+ *
+ *   capabilityOverrides (config) > probed > declared
+ *
+ * applied PER FLAG. Discrepancy-aware: a probed-false trumps a declared-true
+ * — the DeepSeek case (declared supports_response_schema, probed
+ * native_rung_rate = 0) finally routes correctly.
+ *
+ * Conservatism rules (measurement honesty):
+ *  - grounded_native: probed can only REVOKE (a declared-true with a low
+ *    probed grounded rate), never grant — high citation rates without
+ *    declared search may be fabricated URLs.
+ *  - Unprobed/undeclared dimensions (explicit caches, cache keys, flex tier,
+ *    trace visibility) fall back to the adapter-static map, which is the
+ *    declared layer for call-shaping facts.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.capabilityFactsFromEntry = capabilityFactsFromEntry;
+exports.loadRegistryFacts = loadRegistryFacts;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+/** Same bar the registry's discrepancy detection uses. */
+const GROUNDED_BAR = 0.5;
+const CONFORMANCE_BAR = 0.9;
+/** Per-flag fact merge for one registry entry. `staticFlags` is the
+ * adapter-static (declared call-shaping) baseline. */
+function capabilityFactsFromEntry(entry, staticFlags) {
+    const flags = new Set(staticFlags);
+    const declared = entry.declared;
+    const probed = entry.probed;
+    // structured_native — probed native_rung_rate is the ground truth when
+    // sampled; else declared (adapter fact first, pricing-map flag second).
+    const nativeRate = probed?.schema?.native_rung_rate ?? null;
+    if (nativeRate !== null) {
+        if (nativeRate > 0)
+            flags.add("structured_native");
+        else
+            flags.delete("structured_native"); // the DeepSeek json_object-vs-schema gap
+    }
+    else if (declared !== null) {
+        const declaredNative = declared.flags.adapter_structured_native ?? declared.flags.supports_response_schema;
+        if (declaredNative === true)
+            flags.add("structured_native");
+        else if (declaredNative === false)
+            flags.delete("structured_native");
+    }
+    // json_mode — probed: a sampled schema class with a decent conform rate on
+    // ANY rung proves the model can emit parseable schema-shaped JSON.
+    const conformRate = probed?.schema?.conform_rate ?? null;
+    if (conformRate !== null && conformRate >= CONFORMANCE_BAR) {
+        flags.add("json_mode");
+    }
+    // grounded_native — probed may REVOKE a declared-true, never grant.
+    const groundedRate = probed?.grounding?.grounded_rate ?? null;
+    const declaredGrounded = declared === null
+        ? null
+        : (declared.flags.adapter_grounded_native ?? declared.flags.supports_web_search);
+    if (declaredGrounded === true)
+        flags.add("grounded_native");
+    else if (declaredGrounded === false)
+        flags.delete("grounded_native");
+    if (flags.has("grounded_native") &&
+        groundedRate !== null &&
+        (probed?.grounding?.samples ?? 0) > 0 &&
+        groundedRate < GROUNDED_BAR) {
+        flags.delete("grounded_native");
+    }
+    // prefix_cache_implicit — probed realized cache behavior wins when sampled.
+    const caching = probed?.caching ?? null;
+    if (caching !== null && caching.samples > 0) {
+        if (caching.cache_hit_rate > 0)
+            flags.add("prefix_cache_implicit");
+        else
+            flags.delete("prefix_cache_implicit");
+    }
+    else if (declared?.flags.supports_prompt_caching === true) {
+        flags.add("prefix_cache_implicit");
+    }
+    // context_cache_explicit / prompt_cache_key / tier_flex / trace_visible:
+    // unprobed dimensions — the adapter-static baseline stands.
+    return flags;
+}
+/** Packaged registry.json (registry/ at the package root; dist/ and src/
+ * both sit one level below it). */
+function packagedRegistryPath() {
+    return (0, node_path_1.join)(__dirname, "..", "..", "registry", "registry.json");
+}
+function loadRegistryFacts(registryPath) {
+    const path = registryPath ?? packagedRegistryPath();
+    let byKey = new Map();
+    if ((0, node_fs_1.existsSync)(path)) {
+        const registry = JSON.parse((0, node_fs_1.readFileSync)(path, "utf8"));
+        byKey = new Map(registry.models.map((m) => [m.model_key, m]));
+    }
+    else if (registryPath !== undefined) {
+        // An EXPLICIT path that doesn't exist is a config error worth failing on;
+        // a missing packaged file just means static fallback (fresh checkout).
+        throw new Error(`registry facts file not found: ${path}`);
+    }
+    const cache = new Map();
+    return {
+        flagsFor(provider, model, staticFlags) {
+            const key = `${provider}/${model}`;
+            const entry = byKey.get(key);
+            if (entry === undefined)
+                return null;
+            let flags = cache.get(key);
+            if (flags === undefined) {
+                flags = capabilityFactsFromEntry(entry, staticFlags);
+                cache.set(key, flags);
+            }
+            return flags;
+        },
+    };
+}

package/dist/registry/fingerprint.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Schema fingerprinting — spec §2 WS6, network-effects instrumentation.
+ * Pure function: JSON schema → bucketed structural features + task category
+ * + a stable cell key. Computed at route load; stored on every telemetry row.
+ * PRIVACY: the fingerprint must be irreversible — features and category only,
+ * never field names, titles, descriptions, or enum values.
+ */
+export type TaskCategory = "extraction" | "generation" | "classification" | "analysis";
+export interface SchemaFingerprint {
+    readonly depthBucket: "1-2" | "3-4" | "5+";
+    readonly fieldCountBucket: "1-5" | "6-20" | "21-60" | "61+";
+    readonly enumDensityBucket: "none" | "low" | "high";
+    readonly lengthFloorCount: number;
+    readonly arrayComplexityBucket: "none" | "flat" | "nested";
+    readonly category: TaskCategory;
+    /** Stable hash of the buckets above — the Conformance Matrix cell key. */
+    readonly cellKey: string;
+}
+export declare function fingerprintSchema(schema: object | null): SchemaFingerprint | null;
+//# sourceMappingURL=fingerprint.d.ts.map

package/dist/registry/fingerprint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fingerprint.d.ts","sourceRoot":"","sources":["../../src/registry/fingerprint.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,MAAM,MAAM,YAAY,GAAG,YAAY,GAAG,YAAY,GAAG,gBAAgB,GAAG,UAAU,CAAC;AAEvF,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,WAAW,EAAE,KAAK,GAAG,KAAK,GAAG,IAAI,CAAC;IAC3C,QAAQ,CAAC,gBAAgB,EAAE,KAAK,GAAG,MAAM,GAAG,OAAO,GAAG,KAAK,CAAC;IAC5D,QAAQ,CAAC,iBAAiB,EAAE,MAAM,GAAG,KAAK,GAAG,MAAM,CAAC;IACpD,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,qBAAqB,EAAE,MAAM,GAAG,MAAM,GAAG,QAAQ,CAAC;IAC3D,QAAQ,CAAC,QAAQ,EAAE,YAAY,CAAC;IAChC,0EAA0E;IAC1E,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AA8GD,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,iBAAiB,GAAG,IAAI,CAgDjF"}