modelrig 0.9.0 → 0.11.0

package/dist/run/raw-schema.js

@@ -0,0 +1,166 @@
+"use strict";
+/**
+ * R2 (GitLab issue #6) — `responseSchema` on the raw lane: the schema helpers
+ * the guard (raw-knobs.ts) and the finalize path (raw-finalize.ts) share.
+ *
+ * What the knob IS: a JSON Schema the caller declares on `rig.runRaw`. It is
+ * forwarded as the provider's NATIVE structured-output directive (the adapters'
+ * existing `AdapterRequest.outputSchema` path — gemini `responseJsonSchema`,
+ * openai/grok strict `json_schema`, anthropic a forced tool call) AND the
+ * returned text is checked client-side by the SAME Ajv instance the routed lane
+ * uses (`createModelrigAjv`, 2020-12 + draft-07). A miss is `content_invalid`.
+ *
+ * What the knob is NOT: a ladder. The raw lane never repairs, never retries,
+ * and never falls through — a schema miss is a terminal, billed `content_invalid`
+ * row and a thrown `RigFailureError` whose `fixHint` names the first errors. F4
+ * is narrowed, not reversed: `meta.validated` stays `false` because no ladder
+ * stands behind the check (routing-docs.ts B2 states the boundary).
+ *
+ * Why its own file: raw-finalize.ts and raw-knobs.ts both sit under the 700-LOC
+ * cap (P1) and neither should pull Ajv + hashing into its header story; this
+ * module keeps the raw lane's no-route/registry dependency invariant (it imports
+ * only the shared Ajv factory and failure types).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RAW_SCHEMA_MAX_ERRORS = void 0;
+exports.canonicalJson = canonicalJson;
+exports.rawSchemaSha = rawSchemaSha;
+exports.schemaRootType = schemaRootType;
+exports.assertRawResponseSchemaShape = assertRawResponseSchemaShape;
+exports.validateRawOutput = validateRawOutput;
+exports.rawSchemaMismatchFailure = rawSchemaMismatchFailure;
+const node_crypto_1 = require("node:crypto");
+const ajv_1 = require("./ajv");
+const failures_1 = require("../types/failures");
+/** Canonical JSON — object keys sorted recursively, arrays in order, no
+ * whitespace — so two authored spellings of ONE schema hash identically and a
+ * reordered key never reads as drift. Pure; exported for the hash tests. */
+function canonicalJson(value) {
+    if (Array.isArray(value))
+        return `[${value.map(canonicalJson).join(",")}]`;
+    if (value !== null && typeof value === "object") {
+        const entries = Object.keys(value)
+            .sort()
+            .map((k) => `${JSON.stringify(k)}:${canonicalJson(value[k])}`);
+        return `{${entries.join(",")}}`;
+    }
+    return JSON.stringify(value);
+}
+/** `sha256:<hex>` of the canonical schema JSON — the value stamped on
+ * `inferences.meta.schema_sha` (a hash, never content; meta-safe by shape). */
+function rawSchemaSha(schema) {
+    return `sha256:${(0, node_crypto_1.createHash)("sha256").update(canonicalJson(schema), "utf8").digest("hex")}`;
+}
+/** Root `type` of a schema when it declares one (the openai strict-mode
+ * object-root check reads this). `undefined` when absent or non-string. */
+function schemaRootType(schema) {
+    const t = schema.type;
+    return typeof t === "string" ? t : undefined;
+}
+/** Compiled validators, keyed by schema sha — a pipeline re-declares the same
+ * schema on every call, and Ajv compilation is the expensive step. Bounded:
+ * the raw lane sees a handful of distinct schemas per process. */
+const compiled = new Map();
+const COMPILED_CAP = 256;
+function compileRawSchema(schema, sha) {
+    const hit = compiled.get(sha);
+    if (hit !== undefined)
+        return hit;
+    // A fresh instance per schema: Ajv de-duplicates on `$id`, so two schemas
+    // sharing an `$id` on one instance would throw "already exists".
+    const fn = (0, ajv_1.createModelrigAjv)().compile(schema);
+    if (compiled.size >= COMPILED_CAP)
+        compiled.clear();
+    compiled.set(sha, fn);
+    return fn;
+}
+/**
+ * Pre-dispatch SHAPE check (called from the knob guard): the schema must be a
+ * plain JSON-Schema object that Ajv can compile. Anything else throws the
+ * existing terminal class `invariant_violation` BEFORE any adapter is built —
+ * no meter, no provider call, no telemetry row — with a teaching fixHint. Also
+ * the one place the openai strict-root warning lives: strict `json_schema`
+ * requires an object root; a non-object root is WARNED (the provider enforces
+ * and its rejection is classified teachably by the adapter), never silently
+ * rewritten. Idempotent; side-effect-free apart from the warning + compile cache.
+ */
+function assertRawResponseSchemaShape(input) {
+    const schema = input.responseSchema;
+    if (schema === undefined)
+        return;
+    const base = { class: "invariant_violation", provider: input.provider, model: input.model };
+    if (input.responseFormat !== undefined) {
+        throw new failures_1.RigFailureError({
+            ...base,
+            message: "responseSchema and responseFormat were both declared on the raw lane",
+            fixHint: "declare ONE of responseSchema (a JSON Schema — implies JSON output) or responseFormat: \"json_object\" (mime-shaping only); remove the other",
+        });
+    }
+    if (schema === null || typeof schema !== "object" || Array.isArray(schema)) {
+        throw new failures_1.RigFailureError({
+            ...base,
+            message: "responseSchema on the raw lane must be a JSON Schema object",
+            fixHint: "pass the schema as a plain object (e.g. { type: \"object\", properties: {…}, required: […] }), not a string, array, or null",
+        });
+    }
+    const sha = rawSchemaSha(schema);
+    try {
+        compileRawSchema(schema, sha);
+    }
+    catch (err) {
+        const reason = err instanceof Error ? err.message : String(err);
+        throw new failures_1.RigFailureError({
+            ...base,
+            message: `responseSchema on the raw lane does not compile: ${reason}`,
+            fixHint: "fix the schema so Ajv (JSON Schema 2020-12, draft-07 accepted; `format` annotation-only) compiles it — the same instance validates route schemas, so a schema that loads on a route loads here",
+        });
+    }
+    if (input.provider === "openai" && schemaRootType(schema) !== "object") {
+        console.warn(`[modelrig] responseSchema on openai/${input.model}: strict json_schema requires an object root (got type: ${schemaRootType(schema) ?? "absent"}); the provider will reject it — wrap the schema in { type: "object", properties: { items: … } }`);
+    }
+}
+/** The one terminal-error rendering the raw lane makes (parity with run.ts's
+ * `content_invalid` message shape); exported for the finalize tests. */
+exports.RAW_SCHEMA_MAX_ERRORS = 5;
+/**
+ * Validate the raw output text against the declared schema with the shared
+ * Ajv. Parity with the routed lane's `validateOutput`: a non-JSON body is a
+ * schema miss (one `parse` error), and Ajv errors render as `instancePath
+ * message`. Never throws — the shape check above already compiled the schema;
+ * a late compile failure (cache cleared + a schema that stopped compiling, which
+ * cannot happen for the same object) is reported as a miss, not a crash.
+ */
+function validateRawOutput(schema, text) {
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        return { ok: false, errors: ["output is not valid JSON (the provider returned non-JSON text)"] };
+    }
+    let fn;
+    try {
+        fn = compileRawSchema(schema, rawSchemaSha(schema));
+    }
+    catch (err) {
+        return { ok: false, errors: [`schema did not compile: ${err instanceof Error ? err.message : String(err)}`] };
+    }
+    if (fn(parsed))
+        return { ok: true };
+    const errors = (fn.errors ?? []).map((e) => `${e.instancePath || "/"} ${e.message ?? "invalid"}`);
+    return { ok: false, errors: errors.length > 0 ? errors : ["output failed schema validation"] };
+}
+/** The `content_invalid` failure a raw schema miss raises — the EXISTING class
+ * (its table teaching + docsUrl apply via `teach()`), with a raw-lane fixHint:
+ * this lane never repairs, so the fix is the prompt/schema or a route. */
+function rawSchemaMismatchFailure(input, errors) {
+    const shown = errors.slice(0, exports.RAW_SCHEMA_MAX_ERRORS);
+    const more = errors.length > shown.length ? ` (+${errors.length - shown.length} more)` : "";
+    return {
+        class: "content_invalid",
+        message: `raw output failed responseSchema validation: ${shown.join("; ")}${more}`,
+        provider: input.provider,
+        model: input.model,
+        fixHint: "the raw lane validates but never repairs or retries — tighten the prompt or loosen the schema, or graduate this call to a route (policy.retries.content_invalid + a repair rung) if you want ModelRig to recover it",
+    };
+}

package/dist/run/raw-search-cost.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Native-search cost row for the RAW lane (Native Web Search lane, spec N3) —
+ * ZERO DDL. On a successful native-grounded raw attempt (openai/grok Responses
+ * API), the model's token cost rides the normal raw row while the `web_search`
+ * tool SURCHARGE rides one extra, distinct, legible line here — exactly like the
+ * inject rung's synthetic search-cost row (`dispatch.ts recordSearchCostRow`),
+ * but shaped for the raw lane (which has no `RouteBundle` / `LadderKeyMinter`):
+ * the row records the REAL provider id and a `web_search` pseudo-model under
+ * `rung:"search"`, reusing the existing `inferences` telemetry family — no new
+ * table, no schema change (spec §2, conservative-schema).
+ *
+ * Search cost is never folded into token cost. The rate is a static, drift-locked
+ * ESTIMATE (`WEB_SEARCH_PRICING`, `web-search-pricing.ts`) — placeholders until the
+ * post-merge live-invoice reconciliation (spec §6 live gate) un-tags it.
+ *
+ * Extracted into its own module (not inlined in `raw.ts`) to keep `raw.ts` under
+ * its 700-LOC ceiling (P-cap); the recorder mirrors `recordRawRow`'s minimal
+ * telemetry shape so a raw search-cost line reads identically to a raw token line.
+ */
+import type { ProviderId } from "../types/provider";
+import type { RunTags } from "../types/route";
+import type { TelemetryStore } from "../types/telemetry";
+/** The `web_search` pseudo-model the native-search cost row records under (spec
+ * N3) — parallels the inject rung's synthetic search provider, but the ROW's
+ * provider is the real dispatch provider so the surcharge is attributed to it. */
+export declare const NATIVE_WEB_SEARCH_MODEL = "web_search";
+export interface RawSearchCostArgs {
+    /** The real dispatch provider (openai / grok) — the row's `provider`. An
+     * OBS-1 recorded call may name a provider ModelRig has no rate for (⇒ $0). */
+    readonly provider: ProviderId | string;
+    /** The `provider/model` handle the caller used — the row's `route`. */
+    readonly rawModelId: string;
+    /** The effective tags already stamped on the primary raw row (lane:"raw",
+     * run_id, step) — the search row rides the same set + `rung:"search"`. */
+    readonly tags: RunTags;
+    /** The `call_id` shared with the primary raw row (ladder correlation, R0). */
+    readonly callId: string;
+    /** Native `web_search` tool calls billed on this attempt (from the Responses
+     * usage when present, else 1 — disclosed). Clamped to ≥ 1. */
+    readonly searchCalls: number;
+}
+/**
+ * Record the raw-lane native-search cost row. `costEstimateUsd =
+ * webSearchPerCallUsd(provider) × searchCalls`. Zero tokens (the surcharge is not
+ * token-metered), `rung:"search"`, `attemptSeq: 2` so it never collides with the
+ * primary raw row's `attemptSeq: 1` on the shared `call_id`.
+ */
+export declare function recordRawSearchCostRow(telemetry: TelemetryStore, args: RawSearchCostArgs): void;
+//# sourceMappingURL=raw-search-cost.d.ts.map

package/dist/run/raw-search-cost.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"raw-search-cost.d.ts","sourceRoot":"","sources":["../../src/run/raw-search-cost.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAGH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,KAAK,EAAgB,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAIvE;;kFAEkF;AAClF,eAAO,MAAM,uBAAuB,eAAe,CAAC;AAEpD,MAAM,WAAW,iBAAiB;IAChC;kFAC8E;IAC9E,QAAQ,CAAC,QAAQ,EAAE,UAAU,GAAG,MAAM,CAAC;IACvC,uEAAuE;IACvE,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B;8EAC0E;IAC1E,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,8EAA8E;IAC9E,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB;kEAC8D;IAC9D,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;CAC9B;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,cAAc,EAAE,IAAI,EAAE,iBAAiB,GAAG,IAAI,CA0C/F"}

package/dist/run/raw-search-cost.js

@@ -0,0 +1,79 @@
+"use strict";
+/**
+ * Native-search cost row for the RAW lane (Native Web Search lane, spec N3) —
+ * ZERO DDL. On a successful native-grounded raw attempt (openai/grok Responses
+ * API), the model's token cost rides the normal raw row while the `web_search`
+ * tool SURCHARGE rides one extra, distinct, legible line here — exactly like the
+ * inject rung's synthetic search-cost row (`dispatch.ts recordSearchCostRow`),
+ * but shaped for the raw lane (which has no `RouteBundle` / `LadderKeyMinter`):
+ * the row records the REAL provider id and a `web_search` pseudo-model under
+ * `rung:"search"`, reusing the existing `inferences` telemetry family — no new
+ * table, no schema change (spec §2, conservative-schema).
+ *
+ * Search cost is never folded into token cost. The rate is a static, drift-locked
+ * ESTIMATE (`WEB_SEARCH_PRICING`, `web-search-pricing.ts`) — placeholders until the
+ * post-merge live-invoice reconciliation (spec §6 live gate) un-tags it.
+ *
+ * Extracted into its own module (not inlined in `raw.ts`) to keep `raw.ts` under
+ * its 700-LOC ceiling (P-cap); the recorder mirrors `recordRawRow`'s minimal
+ * telemetry shape so a raw search-cost line reads identically to a raw token line.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NATIVE_WEB_SEARCH_MODEL = void 0;
+exports.recordRawSearchCostRow = recordRawSearchCostRow;
+const node_crypto_1 = require("node:crypto");
+const telemetry_row_1 = require("./telemetry-row");
+const web_search_pricing_1 = require("./web-search-pricing");
+/** The `web_search` pseudo-model the native-search cost row records under (spec
+ * N3) — parallels the inject rung's synthetic search provider, but the ROW's
+ * provider is the real dispatch provider so the surcharge is attributed to it. */
+exports.NATIVE_WEB_SEARCH_MODEL = "web_search";
+/**
+ * Record the raw-lane native-search cost row. `costEstimateUsd =
+ * webSearchPerCallUsd(provider) × searchCalls`. Zero tokens (the surcharge is not
+ * token-metered), `rung:"search"`, `attemptSeq: 2` so it never collides with the
+ * primary raw row's `attemptSeq: 1` on the shared `call_id`.
+ */
+function recordRawSearchCostRow(telemetry, args) {
+    const searchCalls = Math.max(1, args.searchCalls);
+    // An unknown provider has no WEB_SEARCH_PRICING entry ⇒ webSearchPerCallUsd's `?.` yields 0.
+    const costEstimateUsd = (0, web_search_pricing_1.webSearchPerCallUsd)(args.provider) * searchCalls;
+    // U4: assembled by the ONE shared builder (./telemetry-row.ts). `rung:"search"`
+    // and `attemptSeq: 2` (so it never collides with the primary raw row's
+    // attemptSeq 1 on the shared call_id) are explicit inputs; `meta: null` matches
+    // the former row's shape exactly (present, null).
+    const row = (0, telemetry_row_1.buildTelemetryRow)({
+        id: (0, node_crypto_1.randomUUID)(),
+        route: args.rawModelId,
+        routeVersion: 0,
+        provider: args.provider,
+        model: exports.NATIVE_WEB_SEARCH_MODEL,
+        requestedTier: "standard",
+        servedTier: "standard",
+        tokensIn: 0,
+        tokensOut: 0,
+        tokensCached: 0,
+        tokensCacheWrite: 0,
+        tokensCacheWrite1h: 0,
+        costEstimateUsd,
+        latencyMs: 0,
+        ttfbMs: null,
+        failureClass: null,
+        attemptsJson: "{}",
+        baseTags: args.tags,
+        rung: "search",
+        fingerprintCell: null,
+        servedVariant: null,
+        repairedBy: null,
+        // A static list-rate estimate is never "pricing missing" — the drift test /
+        // live gate catches an absent entry for a supported provider.
+        pricingMissing: false,
+        cacheKey: null,
+        prefixFingerprint: null,
+        callId: args.callId,
+        attemptSeq: 2,
+        candidateIndex: 0,
+        meta: null,
+    });
+    telemetry.record(row);
+}

package/dist/run/raw-support.d.ts

@@ -1,6 +1,11 @@
 /**
- * CE-9 (spec R5) — the raw-lane provider × knob support matrix, the SINGLE
- * source of truth for which knobs each provider honors on `rig.runRaw`.
+ * CE-9 (spec R5) / Unified Route U1 — **the one provider × capability
+ * vocabulary**. Originally the raw-lane knob support matrix, this table is now
+ * the SINGLE source of truth BOTH lanes and the route contract consult for what
+ * each provider can do: which knobs it honors on `rig.runRaw`, AND which serving
+ * `destination`s it can be reached through (`direct` / `modelrig-served`, ruling
+ * D-2). One table, so the guard, the docs matrix, and the destination lookups
+ * (`src/run/destination.ts`) can never disagree.
  *
  * BOTH the runtime guard (`assertRawKnobsSupported`, run/raw.ts) and the docs
  * generator (scripts/build-docs-site.ts) import `RAW_KNOB_SUPPORT` — so the
@@ -9,10 +14,14 @@
  * inline literals; adding a provider (or widening a knob) is one edit here.
  *
  * The knob discipline this table encodes (spec R1/R2/R4):
- *  - grounding: gemini honors native web grounding (grok's Live Search was retired by
- *    xAI — 410 on the CE-9 live gate — so grok is fail-closed until CE-9b lands the
- *    Responses-API web_search path); every other provider
- *    FAILS CLOSED pre-dispatch (guarded).
+ *  - grounding: gemini, openai, and grok honor native web grounding — gemini via
+ *    Google Search, openai + grok via the native `web_search` tool on the Responses
+ *    API (Native Web Search MVP; grok's replacement for the retired Live Search
+ *    surface). Both openai AND grok are RELEASED (each cleared its own live
+ *    recency+citations+price gate — openai 2026-09-09, grok 2026-09-09: 15/15
+ *    dispatched, 100% citation presence, avg 3.80 cites/response, 15/15 recency,
+ *    clearing the ≥50% bar and retiring the prior ~20-27% flag). Every other
+ *    provider FAILS CLOSED pre-dispatch (guarded).
  *  - reasoning: NO per-model allowlist outside gemini (the drift cost the
  *    customer flagged). openai/deepinfra/fireworks forward `level` verbatim as
  *    `reasoning_effort` and let the provider enforce (a rejection is classified
@@ -24,11 +33,21 @@
  *    (mime-shaping only) honor it; anthropic FAILS CLOSED (guarded). This is
  *    mime-shaping, NOT schema enforcement — F4 stands (no validation/repair,
  *    `meta.validated` stays false).
+ *  - responseSchema (R2, issue #6): a JSON Schema forwarded as the provider's
+ *    NATIVE structured-output directive — gemini `responseJsonSchema` + JSON
+ *    mime, openai/grok strict `json_schema`, anthropic a forced tool call
+ *    (strict-first) — and checked client-side by the SAME Ajv the routed lane
+ *    uses: a miss is `content_invalid` (terminal on this lane — never repaired,
+ *    never retried). deepseek (json_object only — the schema would be DROPPED)
+ *    and the OpenAI-compat hosts (deepinfra/fireworks/zai — the raw profile has
+ *    no probed `structured_native`, so the schema would degrade to json_object
+ *    plus a prompt guard) FAIL CLOSED pre-dispatch.
  *  - cache + serviceTier are INFORMATIONAL here (never a hard fail): the cache
  *    directive is provider-neutral (a resource HANDLE on gemini, a routing HINT
  *    on the prompt_cache_key providers) and serviceTier forwards everywhere.
  */
 import type { ProviderId, ReasoningLevel } from "../types/provider";
+import type { Destination } from "./destination";
 /** How a provider treats a declared `reasoning.level` on the raw lane (R1). */
 export type ReasoningSupportKind = 
 /** openai / deepinfra / fireworks — `level` → `reasoning_effort` 1:1,
@@ -78,6 +97,22 @@ export interface CacheFact {
     readonly semantics: CacheSemantics;
     readonly note: string;
 }
+/**
+ * Which serving `destination`s a provider can be reached through (Unified Route
+ * U1, ruling D-2) — the ONE source of truth the `src/run/destination.ts` lookups
+ * read. `direct` for every provider (today's behavior; ABSENT ⇒ byte-identical);
+ * `modelrig-served` additionally for the ModelRig-keyed hosts (fireworks,
+ * deepinfra — `config.ts` `PROVIDER_KEY_ENV`). INFORMATIONAL in U1 — this is a
+ * vocabulary cell only; no dispatch reads it here. Managed serving is gated
+ * behind the `config.managedServing` flag (set in code via createRig, NOT an env
+ * var; default off), wired in U3 (run/resolve-destination.ts).
+ */
+export interface ServingFact {
+    /** The destinations this provider supports, `direct` always first. */
+    readonly destinations: readonly Destination[];
+    /** Human teaching string rendered in the docs matrix `destination` cell. */
+    readonly note: string;
+}
 export interface RawKnobSupport {
     /** GUARDED — a declared `grounding` on an unsupported provider throws. */
     readonly grounding: KnobFact;
@@ -85,11 +120,21 @@ export interface RawKnobSupport {
     readonly reasoning: ReasoningFact;
     /** GUARDED — a declared `responseFormat` on an unsupported provider throws. */
     readonly responseFormat: KnobFact;
+    /** GUARDED — a declared `responseSchema` (JSON Schema) on a provider whose
+     * adapter has no NATIVE schema path throws (R2). Where supported the schema is
+     * ALSO validated client-side (Ajv) — a miss is `content_invalid`. */
+    readonly responseSchema: KnobFact;
     /** INFORMATIONAL — the cache directive never hard-fails on the raw lane. */
     readonly cache: CacheFact;
     /** INFORMATIONAL — serviceTier forwards to every adapter; the served tier
      * reports the truth. */
     readonly serviceTier: KnobFact;
+    /** VOCABULARY + RELEASED capability — which serving `destination`s the
+     * provider supports (`direct` / `modelrig-served`, ruling D-2). Read by
+     * `destination.ts`. Managed serving is RELEASED (GA), gated by
+     * `config.managedServing` (default off); the guard + dispatch wiring lives in
+     * run/resolve-destination.ts. */
+    readonly serving: ServingFact;
 }
 /**
  * The grok reasoning coarsening (R1): xAI's `reasoning_effort` accepts only
@@ -113,6 +158,19 @@ export declare function rawKnobSupport(provider: ProviderId): RawKnobSupport;
  * can never drift from the table). */
 export declare function groundingSupportedProviders(): readonly ProviderId[];
 export declare function responseFormatSupportedProviders(): readonly ProviderId[];
+/** R2: providers whose adapter carries a NATIVE schema path on the raw lane. */
+export declare function responseSchemaSupportedProviders(): readonly ProviderId[];
+/**
+ * The serving `destination` cell for a provider (Unified Route U1) — the raw
+ * capability fact from the one table. The typed vocabulary lookups
+ * (`servedDestinations` / `destinationSupported`, `src/run/destination.ts`) read
+ * this, so there is no second serving list to drift. VOCABULARY only in U1.
+ */
+export declare function destinationSupport(provider: ProviderId): ServingFact;
+/** Providers that can be served through a given destination, in PROVIDER_IDS
+ * order — the matrix source for the eventual (U3) fail-closed fixHint that names
+ * the served-capable set. `direct` returns every provider. VOCABULARY only. */
+export declare function providersServing(destination: Destination): readonly ProviderId[];
 /** Matrix-level notes rendered below the table (spec §3.2 restated in docs). */
 export declare const RAW_KNOB_MATRIX_NOTES: readonly string[];
 /** Render the provider × knob matrix as a Markdown table + notes, FROM the

package/dist/run/raw-support.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"raw-support.d.ts","sourceRoot":"","sources":["../../src/run/raw-support.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAGH,OAAO,KAAK,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAEpE,+EAA+E;AAC/E,MAAM,MAAM,oBAAoB;AAC9B;;wDAEwD;AACtD,SAAS;AACX;6EAC6E;GAC3E,SAAS;AACX;mEACmE;GACjE,aAAa;AACf;iDACiD;GAC/C,aAAa,CAAC;AAElB;uDACuD;AACvD,MAAM,MAAM,cAAc;AACxB;mDACmD;AACjD,QAAQ;AACV;2EAC2E;GACzE,MAAM;AACR,8DAA8D;GAC5D,UAAU;AACZ;2CAC2C;GACzC,QAAQ,CAAC;AAEb;;yEAEyE;AACzE,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,8DAA8D;IAC9D,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED;yCACyC;AACzC,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,IAAI,EAAE,oBAAoB,CAAC;IACpC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,0EAA0E;IAC1E,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,SAAS,EAAE,cAAc,CAAC;IACnC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,cAAc;IAC7B,0EAA0E;IAC1E,QAAQ,CAAC,SAAS,EAAE,QAAQ,CAAC;IAC7B,uEAAuE;IACvE,QAAQ,CAAC,SAAS,EAAE,aAAa,CAAC;IAClC,+EAA+E;IAC/E,QAAQ,CAAC,cAAc,EAAE,QAAQ,CAAC;IAClC,4EAA4E;IAC5E,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC;IAC1B;4BACwB;IACxB,QAAQ,CAAC,WAAW,EAAE,QAAQ,CAAC;CAChC;AAED;;;;;;;;GAQG;AACH,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,cAAc,GAAG,KAAK,GAAG,MAAM,CAEhF;AAED;+EAC+E;AAC/E,eAAO,MAAM,gBAAgB,EAAE,MAAM,CAAC,UAAU,EAAE,cAAc,CA+D/D,CAAC;AAEF;;qBAEqB;AACrB,wBAAgB,cAAc,CAAC,QAAQ,EAAE,UAAU,GAAG,cAAc,CAEnE;AAED;;sCAEsC;AACtC,wBAAgB,2BAA2B,IAAI,SAAS,UAAU,EAAE,CAEnE;AAED,wBAAgB,gCAAgC,IAAI,SAAS,UAAU,EAAE,CAExE;AAED,gFAAgF;AAChF,eAAO,MAAM,qBAAqB,EAAE,SAAS,MAAM,EAKlD,CAAC;AAEF;;;kCAGkC;AAClC,wBAAgB,mBAAmB,IAAI,MAAM,CAQ5C"}
+{"version":3,"file":"raw-support.d.ts","sourceRoot":"","sources":["../../src/run/raw-support.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AAGH,OAAO,KAAK,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAGpE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAEjD,+EAA+E;AAC/E,MAAM,MAAM,oBAAoB;AAC9B;;wDAEwD;AACtD,SAAS;AACX;6EAC6E;GAC3E,SAAS;AACX;mEACmE;GACjE,aAAa;AACf;iDACiD;GAC/C,aAAa,CAAC;AAElB;uDACuD;AACvD,MAAM,MAAM,cAAc;AACxB;mDACmD;AACjD,QAAQ;AACV;2EAC2E;GACzE,MAAM;AACR,8DAA8D;GAC5D,UAAU;AACZ;2CAC2C;GACzC,QAAQ,CAAC;AAEb;;yEAEyE;AACzE,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,8DAA8D;IAC9D,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED;yCACyC;AACzC,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,IAAI,EAAE,oBAAoB,CAAC;IACpC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,0EAA0E;IAC1E,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,SAAS,EAAE,cAAc,CAAC;IACnC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,WAAW;IAC1B,sEAAsE;IACtE,QAAQ,CAAC,YAAY,EAAE,SAAS,WAAW,EAAE,CAAC;IAC9C,4EAA4E;IAC5E,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,cAAc;IAC7B,0EAA0E;IAC1E,QAAQ,CAAC,SAAS,EAAE,QAAQ,CAAC;IAC7B,uEAAuE;IACvE,QAAQ,CAAC,SAAS,EAAE,aAAa,CAAC;IAClC,+EAA+E;IAC/E,QAAQ,CAAC,cAAc,EAAE,QAAQ,CAAC;IAClC;;yEAEqE;IACrE,QAAQ,CAAC,cAAc,EAAE,QAAQ,CAAC;IAClC,4EAA4E;IAC5E,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC;IAC1B;4BACwB;IACxB,QAAQ,CAAC,WAAW,EAAE,QAAQ,CAAC;IAC/B;;;;qCAIiC;IACjC,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC;CAC/B;AAED;;;;;;;;GAQG;AACH,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,cAAc,GAAG,KAAK,GAAG,MAAM,CAEhF;AAED;+EAC+E;AAC/E,eAAO,MAAM,gBAAgB,EAAE,MAAM,CAAC,UAAU,EAAE,cAAc,CA4F/D,CAAC;AAEF;;qBAEqB;AACrB,wBAAgB,cAAc,CAAC,QAAQ,EAAE,UAAU,GAAG,cAAc,CAEnE;AAED;;sCAEsC;AACtC,wBAAgB,2BAA2B,IAAI,SAAS,UAAU,EAAE,CAEnE;AAED,wBAAgB,gCAAgC,IAAI,SAAS,UAAU,EAAE,CAExE;AAED,gFAAgF;AAChF,wBAAgB,gCAAgC,IAAI,SAAS,UAAU,EAAE,CAExE;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,UAAU,GAAG,WAAW,CAEpE;AAED;;+EAE+E;AAC/E,wBAAgB,gBAAgB,CAAC,WAAW,EAAE,WAAW,GAAG,SAAS,UAAU,EAAE,CAEhF;AAED,gFAAgF;AAChF,eAAO,MAAM,qBAAqB,EAAE,SAAS,MAAM,EAOlD,CAAC;AAEF;;;kCAGkC;AAClC,wBAAgB,mBAAmB,IAAI,MAAM,CAU5C"}

package/dist/run/raw-support.js

@@ -1,7 +1,12 @@
 "use strict";
 /**
- * CE-9 (spec R5) — the raw-lane provider × knob support matrix, the SINGLE
- * source of truth for which knobs each provider honors on `rig.runRaw`.
+ * CE-9 (spec R5) / Unified Route U1 — **the one provider × capability
+ * vocabulary**. Originally the raw-lane knob support matrix, this table is now
+ * the SINGLE source of truth BOTH lanes and the route contract consult for what
+ * each provider can do: which knobs it honors on `rig.runRaw`, AND which serving
+ * `destination`s it can be reached through (`direct` / `modelrig-served`, ruling
+ * D-2). One table, so the guard, the docs matrix, and the destination lookups
+ * (`src/run/destination.ts`) can never disagree.
  *
  * BOTH the runtime guard (`assertRawKnobsSupported`, run/raw.ts) and the docs
  * generator (scripts/build-docs-site.ts) import `RAW_KNOB_SUPPORT` — so the
@@ -10,10 +15,14 @@
  * inline literals; adding a provider (or widening a knob) is one edit here.
  *
  * The knob discipline this table encodes (spec R1/R2/R4):
- *  - grounding: gemini honors native web grounding (grok's Live Search was retired by
- *    xAI — 410 on the CE-9 live gate — so grok is fail-closed until CE-9b lands the
- *    Responses-API web_search path); every other provider
- *    FAILS CLOSED pre-dispatch (guarded).
+ *  - grounding: gemini, openai, and grok honor native web grounding — gemini via
+ *    Google Search, openai + grok via the native `web_search` tool on the Responses
+ *    API (Native Web Search MVP; grok's replacement for the retired Live Search
+ *    surface). Both openai AND grok are RELEASED (each cleared its own live
+ *    recency+citations+price gate — openai 2026-09-09, grok 2026-09-09: 15/15
+ *    dispatched, 100% citation presence, avg 3.80 cites/response, 15/15 recency,
+ *    clearing the ≥50% bar and retiring the prior ~20-27% flag). Every other
+ *    provider FAILS CLOSED pre-dispatch (guarded).
  *  - reasoning: NO per-model allowlist outside gemini (the drift cost the
  *    customer flagged). openai/deepinfra/fireworks forward `level` verbatim as
  *    `reasoning_effort` and let the provider enforce (a rejection is classified
@@ -25,6 +34,15 @@
  *    (mime-shaping only) honor it; anthropic FAILS CLOSED (guarded). This is
  *    mime-shaping, NOT schema enforcement — F4 stands (no validation/repair,
  *    `meta.validated` stays false).
+ *  - responseSchema (R2, issue #6): a JSON Schema forwarded as the provider's
+ *    NATIVE structured-output directive — gemini `responseJsonSchema` + JSON
+ *    mime, openai/grok strict `json_schema`, anthropic a forced tool call
+ *    (strict-first) — and checked client-side by the SAME Ajv the routed lane
+ *    uses: a miss is `content_invalid` (terminal on this lane — never repaired,
+ *    never retried). deepseek (json_object only — the schema would be DROPPED)
+ *    and the OpenAI-compat hosts (deepinfra/fireworks/zai — the raw profile has
+ *    no probed `structured_native`, so the schema would degrade to json_object
+ *    plus a prompt guard) FAIL CLOSED pre-dispatch.
  *  - cache + serviceTier are INFORMATIONAL here (never a hard fail): the cache
  *    directive is provider-neutral (a resource HANDLE on gemini, a routing HINT
  *    on the prompt_cache_key providers) and serviceTier forwards everywhere.
@@ -35,6 +53,9 @@ exports.coarsenGrokReasoningEffort = coarsenGrokReasoningEffort;
 exports.rawKnobSupport = rawKnobSupport;
 exports.groundingSupportedProviders = groundingSupportedProviders;
 exports.responseFormatSupportedProviders = responseFormatSupportedProviders;
+exports.responseSchemaSupportedProviders = responseSchemaSupportedProviders;
+exports.destinationSupport = destinationSupport;
+exports.providersServing = providersServing;
 exports.renderRawKnobMatrix = renderRawKnobMatrix;
 const provider_1 = require("../types/provider");
 /**
@@ -56,22 +77,28 @@ exports.RAW_KNOB_SUPPORT = {
         grounding: { supported: true, note: "native — Google Search (`googleSearch` tool)" },
         reasoning: { kind: "model-gated", note: "`level` → `thinkingConfig.thinkingLevel`, thinking-capable models only (see `GEMINI_THINKING_CAPABLE_MODELS`)" },
         responseFormat: { supported: true, note: "`responseMimeType: application/json` (mime-shaping only — no schema, `validated` stays false)" },
+        responseSchema: { supported: true, note: "`responseJsonSchema` + `responseMimeType: application/json` (native); output Ajv-checked, a miss is `content_invalid`" },
         cache: { semantics: "handle", note: "`cache.key` = a `cachedContent` resource handle (customer-owned lifecycle)" },
         serviceTier: { supported: true, note: "`flex` / `standard` / `priority` honored" },
+        serving: { destinations: ["direct"], note: "`direct` only — vendor key (BYOK / configured)" },
     },
     openai: {
-        grounding: { supported: false, note: "fail-closed" },
+        grounding: { supported: true, note: "native — `web_search` tool (Responses API) — released (live gate passed 2026-09-09)" },
         reasoning: { kind: "forward", note: "`level` → `reasoning_effort` (1:1); a non-reasoning model's rejection is classified teachably" },
         responseFormat: { supported: true, note: "`response_format: { type: json_object }`" },
+        responseSchema: { supported: true, note: "`response_format: { type: json_schema, strict: true }` (native; strict needs an object root — a non-object root is warned pre-dispatch); output Ajv-checked" },
         cache: { semantics: "hint", note: "`cache.key` → `prompt_cache_key`; `ttlSeconds ≥ 86400` → `prompt_cache_retention: 24h`" },
         serviceTier: { supported: true, note: "`flex` (allowlist) / `priority`; flex→standard is a customer-side degrade (§3.2)" },
+        serving: { destinations: ["direct"], note: "`direct` only — vendor key (BYOK / configured)" },
     },
     grok: {
-        grounding: { supported: false, note: "fail-closed — xAI retired Live Search (HTTP 410, 2026-08-21); native `web_search` needs the Responses API, tracked as CE-9b" },
+        grounding: { supported: true, note: "native — `web_search` tool (xAI Agent Tools / Responses API); replaces retired Live Search — released (live gate passed 2026-09-09)" },
         reasoning: { kind: "coarsen", note: 'coarsened (disclosed): `minimal,low → "low"`; `medium,high → "high"` → `reasoning_effort`' },
         responseFormat: { supported: true, note: "`response_format: { type: json_object }`" },
+        responseSchema: { supported: true, note: "`response_format: { type: json_schema, strict: true }` (native); output Ajv-checked" },
         cache: { semantics: "hint", note: "`cache.key` → `prompt_cache_key` (routing hint)" },
         serviceTier: { supported: false, note: "no tiers — always `standard`" },
+        serving: { destinations: ["direct"], note: "`direct` only — vendor key (BYOK / configured)" },
     },
     deepseek: {
         grounding: { supported: false, note: "fail-closed" },
@@ -81,8 +108,10 @@ exports.RAW_KNOB_SUPPORT = {
             fixHint: "DeepSeek has no reasoning-effort control — select the deepseek-reasoner model instead and remove reasoning",
         },
         responseFormat: { supported: true, note: "`response_format: { type: json_object }` — the prompt must contain the word \"JSON\" (caller's responsibility on the raw lane)" },
+        responseSchema: { supported: false, note: "fail-closed — json_object only; a schema would be silently dropped" },
         cache: { semantics: "implicit", note: "automatic prefix cache — the key is not used" },
         serviceTier: { supported: false, note: "no tiers — always `standard`" },
+        serving: { destinations: ["direct"], note: "`direct` only — vendor key (BYOK / configured)" },
     },
     anthropic: {
         grounding: { supported: false, note: "fail-closed" },
@@ -95,22 +124,43 @@ exports.RAW_KNOB_SUPPORT = {
             supported: false,
             note: "fail-closed — no json_object equivalent (structured output is a forced tool call)",
         },
+        responseSchema: { supported: true, note: "forced tool call carrying the schema as `input_schema` (strict-first via the structured-outputs beta, advisory on a strict compile rejection); output Ajv-checked" },
         cache: { semantics: "marker", note: "prefix caching via `cache_control` markers — the key is not used" },
         serviceTier: { supported: false, note: "no tiers — always `standard`" },
+        serving: { destinations: ["direct"], note: "`direct` only — vendor key (BYOK / configured)" },
     },
     deepinfra: {
         grounding: { supported: false, note: "fail-closed" },
         reasoning: { kind: "forward", note: "`level` → `reasoning_effort` (1:1); a non-reasoning model's rejection is classified teachably" },
         responseFormat: { supported: true, note: "`response_format: { type: json_object }`" },
+        responseSchema: { supported: false, note: "fail-closed — the raw compat profile has no probed `structured_native`; the schema would degrade to json_object + a prompt guard" },
         cache: { semantics: "hint", note: "`cache.key` → `prompt_cache_key` (routing hint)" },
         serviceTier: { supported: false, note: "no tiers — always `standard`" },
+        serving: { destinations: ["direct", "modelrig-served"], note: "`direct` · `modelrig-served` — ModelRig-owned key (managed serving RELEASED — GA, gated by `config.managedServing`, default off)" },
     },
     fireworks: {
         grounding: { supported: false, note: "fail-closed" },
         reasoning: { kind: "forward", note: "`level` → `reasoning_effort` (1:1); a non-reasoning model's rejection is classified teachably" },
         responseFormat: { supported: true, note: "`response_format: { type: json_object }`" },
+        responseSchema: { supported: false, note: "fail-closed — the raw compat profile has no probed `structured_native`; the schema would degrade to json_object + a prompt guard" },
         cache: { semantics: "hint", note: "`cache.key` → `prompt_cache_key` (routing hint; caching is automatic host-side)" },
         serviceTier: { supported: false, note: "no tiers — always `standard`" },
+        serving: { destinations: ["direct", "modelrig-served"], note: "`direct` · `modelrig-served` — ModelRig-owned key (managed serving RELEASED — GA, gated by `config.managedServing`, default off)" },
+    },
+    // Z.ai / Zhipu (B4a) — the GLM family via the OpenAI-compat adapter (same row
+    // shape as fireworks/deepinfra). Grounding FAILS CLOSED this phase: native GLM
+    // `web_search` is B4b (not built), so a declared `grounding` on zai is rejected
+    // pre-dispatch with the teaching fixHint that names the supported set. Serving
+    // is `direct` only — `modelrig-served` for zai is deferred (U3/B2), so ABSENT ⇒
+    // byte-identical to every other direct-only provider.
+    zai: {
+        grounding: { supported: false, note: "fail-closed — native GLM web_search wired in B4b" },
+        reasoning: { kind: "forward", note: "`level` → `reasoning_effort` (1:1); a non-reasoning model's rejection is classified teachably" },
+        responseFormat: { supported: true, note: "response_format json_object" },
+        responseSchema: { supported: false, note: "fail-closed — the raw compat profile has no probed `structured_native`; the schema would degrade to json_object + a prompt guard" },
+        cache: { semantics: "hint", note: "`cache.key` → `prompt_cache_key` (routing hint)" },
+        serviceTier: { supported: false, note: "no tiers — always `standard`" },
+        serving: { destinations: ["direct"], note: "`direct` only — vendor key (BYOK / configured)" },
     },
 };
 /** Pure lookup into the matrix (spec R6, exported from the package root). A
@@ -128,23 +178,46 @@ function groundingSupportedProviders() {
 function responseFormatSupportedProviders() {
     return provider_1.PROVIDER_IDS.filter((p) => exports.RAW_KNOB_SUPPORT[p].responseFormat.supported);
 }
+/** R2: providers whose adapter carries a NATIVE schema path on the raw lane. */
+function responseSchemaSupportedProviders() {
+    return provider_1.PROVIDER_IDS.filter((p) => exports.RAW_KNOB_SUPPORT[p].responseSchema.supported);
+}
+/**
+ * The serving `destination` cell for a provider (Unified Route U1) — the raw
+ * capability fact from the one table. The typed vocabulary lookups
+ * (`servedDestinations` / `destinationSupported`, `src/run/destination.ts`) read
+ * this, so there is no second serving list to drift. VOCABULARY only in U1.
+ */
+function destinationSupport(provider) {
+    return exports.RAW_KNOB_SUPPORT[provider].serving;
+}
+/** Providers that can be served through a given destination, in PROVIDER_IDS
+ * order — the matrix source for the eventual (U3) fail-closed fixHint that names
+ * the served-capable set. `direct` returns every provider. VOCABULARY only. */
+function providersServing(destination) {
+    return provider_1.PROVIDER_IDS.filter((p) => exports.RAW_KNOB_SUPPORT[p].serving.destinations.includes(destination));
+}
 /** Matrix-level notes rendered below the table (spec §3.2 restated in docs). */
 exports.RAW_KNOB_MATRIX_NOTES = [
     "**Fail-closed is discoverable, not a surprise.** A knob a provider cannot honor throws `RigFailureError` `invariant_violation` PRE-DISPATCH (no meter, no provider call, no telemetry row) — read this table before you call, not after.",
     "**reasoning has NO per-model allowlist outside gemini.** openai/deepinfra/fireworks forward `level` verbatim and let the provider enforce; a rejection surfaces as a classified failure that names the fix. grok coarsens (disclosed above). deepseek reasoning is model selection (`deepseek-reasoner`); anthropic extended thinking is unwired.",
     "**responseFormat is mime-shaping, not schema enforcement.** `json_object` forces syntactic JSON only — the raw lane still never validates or repairs, and `meta.validated` stays `false` (F4).",
+    "**responseSchema validates, never repairs.** A JSON Schema on `rig.runRaw` is forwarded as the provider's NATIVE structured-output directive AND checked client-side by the same Ajv the routed lane uses: a miss is thrown as `content_invalid` (a billed row with that class, `fixHint` naming the first errors) — the raw lane never repairs, never retries, never falls through, and `meta.validated` stays `false` (no ladder stands behind it). The row's `meta.schema_sha` is the sha256 of the canonical (sorted-key) schema JSON, so declared-vs-served drift is queryable. Declare ONE of `responseFormat` / `responseSchema`, not both.",
     "**§3.2 flex degrade is customer-side.** ModelRig does not replicate the gemini direct-path infra-retry wrapper on the raw lane; under `flex` a capacity rejection surfaces classified (`capacity_shed`) for your own `→ standard` retry ladder — a NAMED difference for your migration record, not a silent one.",
+    "**`destination` (managed serving) is RELEASED (GA).** The serving-destination column names which providers *can* be `modelrig-served` (reached on ModelRig's own key) vs `direct` only. Managed serving is gated behind a config flag (`config.managedServing`, default off, set in code — not an env var); it defaults off, so until you enable it every call is `direct` (ABSENT ⇒ byte-identical).",
 ];
 /** Render the provider × knob matrix as a Markdown table + notes, FROM the
  * matrix (never a hand-written table — R5). Consumed by the docs generator
  * (scripts/build-docs-site.ts) so the published matrix and the runtime guard
  * derive from the same source. */
 function renderRawKnobMatrix() {
-    const header = "| Provider | grounding | reasoning | responseFormat | cache | serviceTier |";
-    const sep = "|---|---|---|---|---|---|";
+    // `destination` (managed serving) is RELEASED (GA, gated by
+    // `config.managedServing`, default off) — detailed in the notes below.
+    const header = "| Provider | grounding | reasoning | responseFormat | responseSchema | cache | serviceTier | destination |";
+    const sep = "|---|---|---|---|---|---|---|---|";
     const rows = provider_1.PROVIDER_IDS.map((p) => {
         const s = exports.RAW_KNOB_SUPPORT[p];
-        return `| \`${p}\` | ${s.grounding.note} | ${s.reasoning.note} | ${s.responseFormat.note} | ${s.cache.note} | ${s.serviceTier.note} |`;
+        return `| \`${p}\` | ${s.grounding.note} | ${s.reasoning.note} | ${s.responseFormat.note} | ${s.responseSchema.note} | ${s.cache.note} | ${s.serviceTier.note} | ${s.serving.note} |`;
     });
     return [header, sep, ...rows, "", ...exports.RAW_KNOB_MATRIX_NOTES].join("\n");
 }