modelrig 0.0.1 → 0.2.0

package/dist/routes/template.js

@@ -0,0 +1,94 @@
+"use strict";
+/**
+ * Template renderer — spec §3, plan §4.
+ * Supports {{var}} substitution and capability-conditional blocks:
+ *   {{#if capability.grounded_native}}...{{/if}}
+ *   {{#unless capability.structured_native}}...{{/unless}}
+ * Deliberately hand-rolled and tiny — NO external template engine (jinja-class
+ * engines are a documented CVE surface; see litellm-vendoring-strategy.md §3).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderTemplate = renderTemplate;
+exports.scanTemplateVariables = scanTemplateVariables;
+const provider_1 = require("../types/provider");
+const CAPABILITY_FLAGS = new Set(provider_1.ALL_CAPABILITY_FLAGS);
+const OPEN_TAG = /\{\{#(if|unless)\s+capability\.([A-Za-z_][A-Za-z0-9_]*)\s*\}\}/g;
+const CLOSE_TAG = /\{\{\/(if|unless)\}\}/g;
+const VAR_TAG = /\{\{\s*([A-Za-z_][A-Za-z0-9_]*)\s*\}\}/g;
+function scanTags(template) {
+    const tags = [];
+    for (const m of template.matchAll(OPEN_TAG)) {
+        tags.push({
+            kind: "open",
+            block: m[1],
+            flag: m[2],
+            start: m.index,
+            end: m.index + m[0].length,
+        });
+    }
+    for (const m of template.matchAll(CLOSE_TAG)) {
+        tags.push({ kind: "close", block: m[1], start: m.index, end: m.index + m[0].length });
+    }
+    return tags.sort((a, b) => a.start - b.start);
+}
+/** Pass 1: resolve conditional blocks (flat only — nesting is rejected). */
+function resolveConditionals(template, capabilities) {
+    const tags = scanTags(template);
+    let out = "";
+    let cursor = 0;
+    let open = null;
+    for (const tag of tags) {
+        if (tag.kind === "open") {
+            if (open) {
+                throw new Error(`template error: nested {{#${tag.block}}} block at index ${tag.start} — nesting is not supported in Phase 1`);
+            }
+            if (tag.flag === undefined || !CAPABILITY_FLAGS.has(tag.flag)) {
+                throw new Error(`template error: unknown capability flag "${tag.flag ?? ""}" at index ${tag.start}`);
+            }
+            out += template.slice(cursor, tag.start);
+            open = tag;
+            cursor = tag.end;
+        }
+        else {
+            if (!open) {
+                throw new Error(`template error: unmatched {{/${tag.block}}} at index ${tag.start}`);
+            }
+            if (open.block !== tag.block) {
+                throw new Error(`template error: {{#${open.block}}} at index ${open.start} closed by {{/${tag.block}}} at index ${tag.start}`);
+            }
+            const present = capabilities.has(open.flag);
+            const keep = open.block === "if" ? present : !present;
+            if (keep)
+                out += template.slice(open.end, tag.start);
+            open = null;
+            cursor = tag.end;
+        }
+    }
+    if (open) {
+        throw new Error(`template error: unclosed {{#${open.block}}} block at index ${open.start}`);
+    }
+    return out + template.slice(cursor);
+}
+/** Pass 2: substitute {{var}} from ctx.variables; missing variables throw. */
+function substituteVariables(template, variables) {
+    return template.replace(VAR_TAG, (_match, name) => {
+        if (!(name in variables)) {
+            throw new Error(`template error: missing variable "${name}"`);
+        }
+        const value = variables[name];
+        if (typeof value === "string")
+            return value;
+        return JSON.stringify(value);
+    });
+}
+function renderTemplate(template, ctx) {
+    return substituteVariables(resolveConditionals(template, ctx.capabilities), ctx.variables);
+}
+/** Distinct {{var}} names referenced anywhere in the template (loader
+ * validation: every reference must be a declared variable). */
+function scanTemplateVariables(template) {
+    const names = new Set();
+    for (const m of template.matchAll(VAR_TAG))
+        names.add(m[1]);
+    return [...names];
+}

package/dist/run/ajv.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Shared Ajv instance factory — JSON-Schema 2020-12 primary, draft-07 still
+ * accepted (onboarding-redesign follow-up #1, decision A).
+ *
+ * We compile output schemas authored in the modern 2020-12 dialect (what most
+ * schema tooling emits today) while remaining back-compatible with the draft-07
+ * schemas already in the corpus. `ajv/dist/2020` is the 2020-12 instance; it
+ * does NOT bundle the draft-07 meta-schema, so we `addMetaSchema` it explicitly
+ * — otherwise any schema declaring `$schema: draft-07` fails to compile.
+ *
+ * `format` stays annotation-only: neither dialect enforces it without
+ * `ajv-formats`, and no committed schema relies on format *assertion*. If a
+ * fixture ever needs it, register `ajv-formats` here AND in the probe harness
+ * (packages/modelrig-probes/src/harness.ts) so gateway and harness agree.
+ */
+import Ajv from "ajv/dist/2020";
+/** The one place the modelrig gateway's Ajv options live. The probe harness in
+ * packages/modelrig-probes constructs an identical instance by hand (separate
+ * package, no modelrig dependency by design) — the two MUST stay in lockstep,
+ * or a fixture would score differently than it serves. */
+export declare function createModelrigAjv(): Ajv;
+//# sourceMappingURL=ajv.d.ts.map

package/dist/run/ajv.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ajv.d.ts","sourceRoot":"","sources":["../../src/run/ajv.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,GAAG,MAAM,eAAe,CAAC;AAGhC;;;0DAG0D;AAC1D,wBAAgB,iBAAiB,IAAI,GAAG,CAIvC"}

package/dist/run/ajv.js

@@ -0,0 +1,32 @@
+"use strict";
+/**
+ * Shared Ajv instance factory — JSON-Schema 2020-12 primary, draft-07 still
+ * accepted (onboarding-redesign follow-up #1, decision A).
+ *
+ * We compile output schemas authored in the modern 2020-12 dialect (what most
+ * schema tooling emits today) while remaining back-compatible with the draft-07
+ * schemas already in the corpus. `ajv/dist/2020` is the 2020-12 instance; it
+ * does NOT bundle the draft-07 meta-schema, so we `addMetaSchema` it explicitly
+ * — otherwise any schema declaring `$schema: draft-07` fails to compile.
+ *
+ * `format` stays annotation-only: neither dialect enforces it without
+ * `ajv-formats`, and no committed schema relies on format *assertion*. If a
+ * fixture ever needs it, register `ajv-formats` here AND in the probe harness
+ * (packages/modelrig-probes/src/harness.ts) so gateway and harness agree.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createModelrigAjv = createModelrigAjv;
+const _2020_1 = __importDefault(require("ajv/dist/2020"));
+const json_schema_draft_07_json_1 = __importDefault(require("ajv/dist/refs/json-schema-draft-07.json"));
+/** The one place the modelrig gateway's Ajv options live. The probe harness in
+ * packages/modelrig-probes constructs an identical instance by hand (separate
+ * package, no modelrig dependency by design) — the two MUST stay in lockstep,
+ * or a fixture would score differently than it serves. */
+function createModelrigAjv() {
+    const ajv = new _2020_1.default({ strict: false, allErrors: true, allowUnionTypes: true });
+    ajv.addMetaSchema(json_schema_draft_07_json_1.default);
+    return ajv;
+}

package/dist/run/cache-handle.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Customer cache-handle resolution — Customer Efficiency CE-1 (spec §2).
+ *
+ * A CUSTOMER-managed cache handle (`RunOptions.cache`) is a provider-native
+ * resource the customer created and owns — a gemini `cachedContents/<id>`, or a
+ * `prompt_cache_key` value for a key-hint provider. This module is the ONE pure
+ * decision consumed in TWO places so the request wire and the telemetry row can
+ * never disagree — exactly the pattern `cache-stamp.ts` uses for GENERATED keys:
+ *   • the request builder (`dispatch.ts:buildAdapterRequest`) reads the handle
+ *     and sets `AdapterRequest.cache`, WINNING over the WS-C generated stamp;
+ *   • the run loop (`run.ts`) reads the SAME handle to stamp the customer key
+ *     onto the telemetry row's `cache_key` (provenance is then derivable — no
+ *     new column; see {@link cacheKeyProvenance}).
+ *
+ * PRECEDENCE (spec §2.2). The customer handle is provider-scoped, so it applies
+ * ONLY to a candidate whose provider matches `cache.provider`:
+ *   1. handle present AND `candidate.provider === cache.provider` AND not
+ *      suppressed → the handle (customer wins — including on gemini: a customer
+ *      handle is a REAL `cachedContents` resource, the adapter's original
+ *      consumption path; the WS-C gemini exclusion covers GENERATED keys only);
+ *   2. non-matching candidate → null (fail-safe: an uncached correct call beats
+ *      dispatching a fallback provider a handle it would reject);
+ *   3. suppressed → null (retry-drop: after a `cache_invalid` on a dispatch that
+ *      carried the handle, the same candidate's retry re-dispatches WITHOUT it —
+ *      a gemini fallback to a different model can fail the model+version-scoped
+ *      cache, and an uncached retry beats a second cache_invalid).
+ *
+ * Absent `RunOptions.cache`, every call here returns null and the request +
+ * recorder fall through to WS-C behavior byte-for-byte (the regression pin).
+ */
+import type { ProviderId } from "../types/provider";
+import type { RunOptions } from "../types/route";
+/** The resolved cache directive for one candidate on one dispatch, shaped for
+ * `AdapterRequest.cache`, or null when no customer handle applies. */
+export type ResolvedCustomerCache = {
+    readonly key: string;
+    readonly ttlSeconds?: number;
+} | null;
+/**
+ * Resolve the customer cache handle for `candidate` on this dispatch. Pure and
+ * total. `suppressed` carries the retry-drop signal (rule 3 above).
+ */
+export declare function customerCacheHandle(cache: RunOptions["cache"] | undefined, candidate: {
+    readonly provider: ProviderId;
+}, suppressed: boolean): ResolvedCustomerCache;
+/** A telemetry row's cache-key origin (spec §2.3), derived — NEVER stored. WS-C
+ * stamps `cache_key === prefix_fingerprint` for key-hint providers, so a row's
+ * origin is recoverable from the two existing columns with no new DDL:
+ *   • `cache_key` null                    → "none"    (no key sent)
+ *   • `cache_key === prefix_fingerprint`  → "generated" (ModelRig `cache: auto`)
+ *   • otherwise (non-null, differs)       → "customer"  (a passed-through handle)
+ * The `pf_`-prefixed fingerprint never collides with a customer opaque key
+ * (cache-stamp.ts), so the equality split is exact. WS-B's derived ledger groups
+ * by (candidate, fingerprint, key) and is indifferent to origin; the WS-D
+ * cache-stats surface MAY label the two origins with this rule. */
+export type CacheKeyProvenance = "none" | "generated" | "customer";
+export declare function cacheKeyProvenance(cacheKey: string | null, prefixFingerprint: string | null): CacheKeyProvenance;
+//# sourceMappingURL=cache-handle.d.ts.map

package/dist/run/cache-handle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache-handle.d.ts","sourceRoot":"","sources":["../../src/run/cache-handle.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAEjD;sEACsE;AACtE,MAAM,MAAM,qBAAqB,GAAG;IAAE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAAC;AAElG;;;GAGG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,UAAU,CAAC,OAAO,CAAC,GAAG,SAAS,EACtC,SAAS,EAAE;IAAE,QAAQ,CAAC,QAAQ,EAAE,UAAU,CAAA;CAAE,EAC5C,UAAU,EAAE,OAAO,GAClB,qBAAqB,CAKvB;AAED;;;;;;;;;mEASmE;AACnE,MAAM,MAAM,kBAAkB,GAAG,MAAM,GAAG,WAAW,GAAG,UAAU,CAAC;AAEnE,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,MAAM,GAAG,IAAI,EACvB,iBAAiB,EAAE,MAAM,GAAG,IAAI,GAC/B,kBAAkB,CAIpB"}

package/dist/run/cache-handle.js

@@ -0,0 +1,54 @@
+"use strict";
+/**
+ * Customer cache-handle resolution — Customer Efficiency CE-1 (spec §2).
+ *
+ * A CUSTOMER-managed cache handle (`RunOptions.cache`) is a provider-native
+ * resource the customer created and owns — a gemini `cachedContents/<id>`, or a
+ * `prompt_cache_key` value for a key-hint provider. This module is the ONE pure
+ * decision consumed in TWO places so the request wire and the telemetry row can
+ * never disagree — exactly the pattern `cache-stamp.ts` uses for GENERATED keys:
+ *   • the request builder (`dispatch.ts:buildAdapterRequest`) reads the handle
+ *     and sets `AdapterRequest.cache`, WINNING over the WS-C generated stamp;
+ *   • the run loop (`run.ts`) reads the SAME handle to stamp the customer key
+ *     onto the telemetry row's `cache_key` (provenance is then derivable — no
+ *     new column; see {@link cacheKeyProvenance}).
+ *
+ * PRECEDENCE (spec §2.2). The customer handle is provider-scoped, so it applies
+ * ONLY to a candidate whose provider matches `cache.provider`:
+ *   1. handle present AND `candidate.provider === cache.provider` AND not
+ *      suppressed → the handle (customer wins — including on gemini: a customer
+ *      handle is a REAL `cachedContents` resource, the adapter's original
+ *      consumption path; the WS-C gemini exclusion covers GENERATED keys only);
+ *   2. non-matching candidate → null (fail-safe: an uncached correct call beats
+ *      dispatching a fallback provider a handle it would reject);
+ *   3. suppressed → null (retry-drop: after a `cache_invalid` on a dispatch that
+ *      carried the handle, the same candidate's retry re-dispatches WITHOUT it —
+ *      a gemini fallback to a different model can fail the model+version-scoped
+ *      cache, and an uncached retry beats a second cache_invalid).
+ *
+ * Absent `RunOptions.cache`, every call here returns null and the request +
+ * recorder fall through to WS-C behavior byte-for-byte (the regression pin).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.customerCacheHandle = customerCacheHandle;
+exports.cacheKeyProvenance = cacheKeyProvenance;
+/**
+ * Resolve the customer cache handle for `candidate` on this dispatch. Pure and
+ * total. `suppressed` carries the retry-drop signal (rule 3 above).
+ */
+function customerCacheHandle(cache, candidate, suppressed) {
+    if (cache === undefined)
+        return null;
+    if (suppressed)
+        return null;
+    if (candidate.provider !== cache.provider)
+        return null;
+    return cache.ttlSeconds !== undefined ? { key: cache.key, ttlSeconds: cache.ttlSeconds } : { key: cache.key };
+}
+function cacheKeyProvenance(cacheKey, prefixFingerprint) {
+    if (cacheKey === null)
+        return "none";
+    if (cacheKey === prefixFingerprint)
+        return "generated";
+    return "customer";
+}

package/dist/run/cache-stamp.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Request-path cache stamping — cache-aware-routing WS-C (spec §5.3, §6).
+ *
+ * ONE pure decision, consumed in TWO places so the request wire and the
+ * telemetry row can never disagree:
+ *   • the run/dispatch path (`buildAdapterRequest`) reads `.request` and sets
+ *     `AdapterRequest.cache`, which each adapter maps to its native mechanism;
+ *   • the recorder (`record-attempt.ts`) reads `.cacheKey` + `.prefixFingerprint`
+ *     and stamps them onto every telemetry row (substrate for WS-B's derived
+ *     ledger and the §5.6 streak alert).
+ *
+ * THE STAMPING GATE (spec §6, the QA hazard the plan calls out): a route only
+ * caches when it opts in (`cache: auto` in its bundle), and even then the cache
+ * KEY is stamped ONLY for providers whose `cache_key_param` accepts an arbitrary
+ * key. This is NOT blanket stamping:
+ *   • openai / grok  → `prompt_cache_key` (a routing hint) — key = fingerprint;
+ *   • anthropic      → top-level `cache_control` (prefix-based, no key) — the
+ *     request carries the directive so the adapter enables cache_control, but no
+ *     key is "sent", so the telemetry `cacheKey` is null;
+ *   • gemini         → EXCLUDED. `gemini.ts` treats any `cache.key` as a
+ *     `cachedContents` RESOURCE NAME and drops systemInstruction+tools
+ *     (gemini.ts:128,145); its `cache_key_param` is null, so this gate never
+ *     stamps it. Gemini relies on automatic implicit caching (no request change);
+ *   • deepseek / fireworks → `cache_key_param` null (pure automatic) — no stamp;
+ *   • deepinfra      → `cache_supported: false` — no stamp.
+ *
+ * The `prefixFingerprint` is stamped into telemetry for EVERY provider on a
+ * `cache: auto` route (gemini included), because a non-null `prefix_fingerprint`
+ * is exactly the "this row came from a cache-opted route" signal WS-B and the
+ * streak alert key off. The fingerprint is v1-scoped (spec §5.3): the run-loop's
+ * stable prefix IS the route template, identified by `(route, version,
+ * toolschema)`. Named variants share a fingerprint in v1 (they share
+ * route/version/schema); hierarchical H1..H5 prefixes land with the gateway phase.
+ */
+import type { CandidateSpec, RouteBundle } from "../types/route";
+/** Hash of the route's structured-output schema — the run-loop's "tool schema"
+ * (structured output is a forced tool call on every adapter). Stable across runs,
+ * distinct across schema edits. Empty schema (unstructured route) hashes to a
+ * fixed constant so those routes still get a stable fingerprint. */
+export declare function toolschemaHash(outputSchema: object | null): string;
+/** v1 prefix fingerprint (spec §5.3): `hash(route, template_version,
+ * toolschema_hash)`. `pf_`-prefixed so it is self-describing in telemetry and
+ * never collides with a customer-supplied opaque key. */
+export declare function computePrefixFingerprint(route: RouteBundle): string;
+/** The stamping decision for one candidate on one route. */
+export interface CacheStamp {
+    /** What to put on `AdapterRequest.cache`, or null to leave it unset (exact
+     * back-compat: an un-stamped request behaves identically to pre-WS-C). */
+    readonly request: {
+        readonly key: string;
+    } | null;
+    /** The key actually SENT as a routing key (telemetry `cache_key`) — non-null
+     * only for `prompt_cache_key` providers; null for cache_control/implicit. */
+    readonly cacheKey: string | null;
+    /** The stable-prefix fingerprint for this row (telemetry `prefix_fingerprint`)
+     * — set for every provider on a `cache: auto` route, null otherwise. */
+    readonly prefixFingerprint: string | null;
+}
+/**
+ * Decide the cache stamp for `candidate` on `route`. Pure and total. Returns
+ * {@link NO_STAMP} unless the route opted into `cache: auto`; otherwise computes
+ * the fingerprint once and applies the per-provider gate above.
+ */
+export declare function cacheStampForCandidate(route: RouteBundle, candidate: Pick<CandidateSpec, "provider">): CacheStamp;
+//# sourceMappingURL=cache-stamp.d.ts.map

package/dist/run/cache-stamp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache-stamp.d.ts","sourceRoot":"","sources":["../../src/run/cache-stamp.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAGH,OAAO,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAcjE;;;oEAGoE;AACpE,wBAAgB,cAAc,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,CAGlE;AAED;;yDAEyD;AACzD,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,WAAW,GAAG,MAAM,CAQnE;AAED,4DAA4D;AAC5D,MAAM,WAAW,UAAU;IACzB;8EAC0E;IAC1E,QAAQ,CAAC,OAAO,EAAE;QAAE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;IAClD;iFAC6E;IAC7E,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC;4EACwE;IACxE,QAAQ,CAAC,iBAAiB,EAAE,MAAM,GAAG,IAAI,CAAC;CAC3C;AAMD;;;;GAIG;AACH,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,WAAW,EAClB,SAAS,EAAE,IAAI,CAAC,aAAa,EAAE,UAAU,CAAC,GACzC,UAAU,CAgBZ"}

package/dist/run/capture-write.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Capture-WRITE gate (settings-plane §1.5 — closes settings-plane gate 5).
+ *
+ * Extracted from the run loop so run.ts stays under the 700-LOC cap. Decides,
+ * once per run, whether that run persists a replay capture to the local capture
+ * store (the SAME store the bake-off/replay machinery reads — S1: extend, don't
+ * twin), and returns a per-attempt writer the loop calls with each output text.
+ *
+ * ── PRECEDENCE ────────────────────────────────────────────────────────────
+ * `effectiveCapture` lets a configured control plane WIN over the YAML `capture:`
+ * flag: a console capture-flip turns capture on/off with NO redeploy (the SDK
+ * refreshes settings on the exporter interval). A local-only rig (no resolver)
+ * keeps the YAML flag, unchanged. Capture OFF ⇒ the writer is a no-op ⇒ nothing
+ * is recorded ⇒ byte-identical behavior.
+ *
+ * ── SCRUB BEFORE PERSIST ──────────────────────────────────────────────────
+ * A capture row carries customer content (the rendered replay input + the
+ * output text), so the task's scrub setting — the SAME ScrubMode the
+ * content-custody path honors — runs BEFORE anything is written: `block` refuses
+ * the whole row when PII is found (persist no content), `redact` masks it,
+ * off/detect are verbatim. A local-only rig has no per-task policy → "off".
+ */
+import type { CaptureStore } from "../telemetry/capture";
+import type { TaskSettingsResolver } from "../settings/task-settings";
+import type { RouteBundle } from "../types/route";
+/** Records one attempt's output as a capture row; a no-op when capture is off. */
+export type CaptureWriter = (inferenceId: string, outputText: string) => void;
+/**
+ * Resolve the effective capture decision for a run and return its writer. Called
+ * once per run; the returned writer is invoked per attempt that produced output.
+ */
+export declare function buildCaptureWriter(resolver: TaskSettingsResolver | null, store: CaptureStore | null | undefined, route: RouteBundle, input: unknown): CaptureWriter;
+//# sourceMappingURL=capture-write.d.ts.map

package/dist/run/capture-write.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capture-write.d.ts","sourceRoot":"","sources":["../../src/run/capture-write.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAGzD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AAEtE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAElD,kFAAkF;AAClF,MAAM,MAAM,aAAa,GAAG,CAAC,WAAW,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,KAAK,IAAI,CAAC;AAI9E;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,oBAAoB,GAAG,IAAI,EACrC,KAAK,EAAE,YAAY,GAAG,IAAI,GAAG,SAAS,EACtC,KAAK,EAAE,WAAW,EAClB,KAAK,EAAE,OAAO,GACb,aAAa,CAoBf"}

package/dist/run/capture-write.js

@@ -0,0 +1,55 @@
+"use strict";
+/**
+ * Capture-WRITE gate (settings-plane §1.5 — closes settings-plane gate 5).
+ *
+ * Extracted from the run loop so run.ts stays under the 700-LOC cap. Decides,
+ * once per run, whether that run persists a replay capture to the local capture
+ * store (the SAME store the bake-off/replay machinery reads — S1: extend, don't
+ * twin), and returns a per-attempt writer the loop calls with each output text.
+ *
+ * ── PRECEDENCE ────────────────────────────────────────────────────────────
+ * `effectiveCapture` lets a configured control plane WIN over the YAML `capture:`
+ * flag: a console capture-flip turns capture on/off with NO redeploy (the SDK
+ * refreshes settings on the exporter interval). A local-only rig (no resolver)
+ * keeps the YAML flag, unchanged. Capture OFF ⇒ the writer is a no-op ⇒ nothing
+ * is recorded ⇒ byte-identical behavior.
+ *
+ * ── SCRUB BEFORE PERSIST ──────────────────────────────────────────────────
+ * A capture row carries customer content (the rendered replay input + the
+ * output text), so the task's scrub setting — the SAME ScrubMode the
+ * content-custody path honors — runs BEFORE anything is written: `block` refuses
+ * the whole row when PII is found (persist no content), `redact` masks it,
+ * off/detect are verbatim. A local-only rig has no per-task policy → "off".
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildCaptureWriter = buildCaptureWriter;
+const scrub_1 = require("../artifacts/scrub");
+const task_settings_1 = require("../settings/task-settings");
+const NO_CAPTURE = () => { };
+/**
+ * Resolve the effective capture decision for a run and return its writer. Called
+ * once per run; the returned writer is invoked per attempt that produced output.
+ */
+function buildCaptureWriter(resolver, store, route, input) {
+    // No store ⇒ never capture, whatever the setting says — and skip the resolver
+    // read entirely (this is the replay path: replay.ts nulls the store so its
+    // outputs never land in captures — the "never replay-of-replay" invariant).
+    if (!store || !(0, task_settings_1.effectiveCapture)(resolver, route.route, route.capture))
+        return NO_CAPTURE;
+    const mode = resolver !== null ? resolver.get(route.route).scrub : "off";
+    return (inferenceId, outputText) => {
+        const variablesJson = JSON.stringify(input);
+        const vars = (0, scrub_1.scrubContent)(variablesJson, mode);
+        const out = (0, scrub_1.scrubContent)(outputText, mode);
+        if (vars.blocked || out.blocked)
+            return; // block mode: persist no content
+        store.record({
+            inferenceId,
+            ts: new Date().toISOString(),
+            route: route.route,
+            routeVersion: route.version,
+            variablesJson: vars.text ?? variablesJson,
+            outputText: out.text ?? outputText,
+        });
+    };
+}

package/dist/run/cost.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Attempt cost accounting — extracted from run.ts (addendum A1 pushed it
+ * past the 700-LOC cap). One rule, applied at every dispatch/settlement
+ * site: a model with no pricing entry NEVER costs $0 against an active
+ * envelope — the envelope is charged a conservative per-token rate instead,
+ * while telemetry keeps the honest $0 with `pricing_missing` flagged.
+ */
+import type { AdapterUsage, ProviderId } from "../types/provider";
+export declare const ESTIMATE_CHARS_PER_TOKEN = 4;
+export declare const ESTIMATE_MAX_OUTPUT_TOKENS = 64000;
+/** Addendum A1 conservative default — above the priciest frontier output
+ * rate, so an unpriced model can only OVER-charge an envelope, never ride
+ * free. Override via MODELRIG_UNPRICED_RATE_USD_PER_MTOK / RigConfig. */
+export declare const DEFAULT_UNPRICED_RATE_USD_PER_MTOK = 100;
+export interface AttemptCost {
+    /** What telemetry records — honest $0 when pricing is missing. */
+    readonly costUsd: number;
+    /** What an active envelope is charged — conservative when unpriced. */
+    readonly envelopeChargeUsd: number;
+    readonly pricingMissing: boolean;
+}
+export declare function attemptCost(provider: ProviderId, model: string, usage: AdapterUsage, unpricedRatePerTok: number): AttemptCost;
+/** Pre-dispatch upper-bound estimate for the envelope precheck: prompt
+ * length + the full output bound, at real pricing or the conservative rate. */
+export declare function dispatchEstimateUsd(provider: ProviderId, model: string, promptChars: number, unpricedRatePerTok: number): number;
+//# sourceMappingURL=cost.d.ts.map

package/dist/run/cost.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cost.d.ts","sourceRoot":"","sources":["../../src/run/cost.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAElE,eAAO,MAAM,wBAAwB,IAAI,CAAC;AAC1C,eAAO,MAAM,0BAA0B,QAAS,CAAC;AAEjD;;yEAEyE;AACzE,eAAO,MAAM,kCAAkC,MAAM,CAAC;AAEtD,MAAM,WAAW,WAAW;IAC1B,kEAAkE;IAClE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,uEAAuE;IACvE,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;IACnC,QAAQ,CAAC,cAAc,EAAE,OAAO,CAAC;CAClC;AAED,wBAAgB,WAAW,CACzB,QAAQ,EAAE,UAAU,EACpB,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,YAAY,EACnB,kBAAkB,EAAE,MAAM,GACzB,WAAW,CAkBb;AAED;+EAC+E;AAC/E,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,UAAU,EACpB,KAAK,EAAE,MAAM,EACb,WAAW,EAAE,MAAM,EACnB,kBAAkB,EAAE,MAAM,GACzB,MAAM,CAOR"}

package/dist/run/cost.js

@@ -0,0 +1,41 @@
+"use strict";
+/**
+ * Attempt cost accounting — extracted from run.ts (addendum A1 pushed it
+ * past the 700-LOC cap). One rule, applied at every dispatch/settlement
+ * site: a model with no pricing entry NEVER costs $0 against an active
+ * envelope — the envelope is charged a conservative per-token rate instead,
+ * while telemetry keeps the honest $0 with `pricing_missing` flagged.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_UNPRICED_RATE_USD_PER_MTOK = exports.ESTIMATE_MAX_OUTPUT_TOKENS = exports.ESTIMATE_CHARS_PER_TOKEN = void 0;
+exports.attemptCost = attemptCost;
+exports.dispatchEstimateUsd = dispatchEstimateUsd;
+const pricing_1 = require("../registry/pricing");
+exports.ESTIMATE_CHARS_PER_TOKEN = 4;
+exports.ESTIMATE_MAX_OUTPUT_TOKENS = 64000;
+/** Addendum A1 conservative default — above the priciest frontier output
+ * rate, so an unpriced model can only OVER-charge an envelope, never ride
+ * free. Override via MODELRIG_UNPRICED_RATE_USD_PER_MTOK / RigConfig. */
+exports.DEFAULT_UNPRICED_RATE_USD_PER_MTOK = 100;
+function attemptCost(provider, model, usage, unpricedRatePerTok) {
+    const pricing = (0, pricing_1.getPricing)(provider, model);
+    if (pricing === null) {
+        return {
+            costUsd: 0,
+            envelopeChargeUsd: (usage.tokensIn + usage.tokensOut) * unpricedRatePerTok,
+            pricingMissing: true,
+        };
+    }
+    const costUsd = (0, pricing_1.estimateCostUsd)(pricing, usage.tokensIn, usage.tokensOut, usage.tokensCached, usage.tokensCacheWrite ?? 0, usage.tokensCacheWrite1h ?? 0);
+    return { costUsd, envelopeChargeUsd: costUsd, pricingMissing: false };
+}
+/** Pre-dispatch upper-bound estimate for the envelope precheck: prompt
+ * length + the full output bound, at real pricing or the conservative rate. */
+function dispatchEstimateUsd(provider, model, promptChars, unpricedRatePerTok) {
+    const promptTokens = Math.ceil(promptChars / exports.ESTIMATE_CHARS_PER_TOKEN);
+    const pricing = (0, pricing_1.getPricing)(provider, model);
+    if (pricing === null) {
+        return (promptTokens + exports.ESTIMATE_MAX_OUTPUT_TOKENS) * unpricedRatePerTok;
+    }
+    return (0, pricing_1.estimateCostUsd)(pricing, promptTokens, exports.ESTIMATE_MAX_OUTPUT_TOKENS, 0);
+}

package/dist/run/dispatch.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Dispatch helpers extracted from run.ts (G-1/G-5 Phase A). The run loop is at
+ * its LOC cap, so the tool-passthrough and streaming seams live here — the same
+ * move G-2 made when it pulled applyRunRequirements/candidateFilterFromOptions
+ * into resolve.ts. Pure/near-pure: request shaping, the stream-vs-buffered
+ * dispatch fork, and the tool-call RunResult builder.
+ *
+ * Tool *execution* is never ours (spec §4.4); these helpers normalize the
+ * protocol and surface it — nothing here runs a tool.
+ */
+import type { AdapterRequest, AdapterResult, CandidateRef, ProviderAdapter } from "../types/provider";
+import type { RigFailure } from "../types/failures";
+import type { RouteBundle, RunMeta, RunOptions, RunResult, RunTags } from "../types/route";
+import type { TelemetryStore } from "../types/telemetry";
+/** One telemetry attempt row's inputs — shared with run.ts's recordAttempt so
+ * the tool-call helper here can record through the same closure. */
+export interface AttemptTelemetry {
+    readonly candidate: CandidateRef;
+    readonly servedTier: string;
+    readonly tokensIn: number;
+    readonly tokensOut: number;
+    readonly tokensCached: number;
+    /** Cache-write buckets (WS-A). Optional — absent ⇒ 0 in the recorded row, so
+     * the zero-cost/failure call sites need not set them. */
+    readonly tokensCacheWrite?: number;
+    readonly tokensCacheWrite1h?: number;
+    readonly costUsd: number;
+    readonly latencyMs: number;
+    /** First-body-byte time from the adapter (WS3, Phase 4) — undefined when
+     * nothing arrived. */
+    readonly ttfbMs?: number;
+    readonly failure: RigFailure | null;
+    /** "provider/model" performing a repair call (WS2) — undefined otherwise. */
+    readonly repairedBy?: string;
+    /** Addendum A1: model had no pricing entry (cost recorded as honest 0). */
+    readonly pricingMissing?: boolean;
+}
+/** run.ts's recordAttempt, threaded in so the tool-call path records through
+ * the same ledger/tenancy closure the rest of the loop uses. */
+export type RecordAttempt = (attempt: AttemptTelemetry) => string;
+/** Record the grounding-inject search's own telemetry row (WS3): a $-only line
+ * under the synthetic "search" provider. Extracted from run.ts to keep it under
+ * the LOC cap; behaviour is byte-identical to the prior inline recorder. */
+export declare function recordSearchCostRow(telemetry: TelemetryStore, route: RouteBundle, effectiveTags: RunTags, servedVariant: string | null, searchProviderId: string, costUsd: number): void;
+/** Side-channel for streaming: the run loop hands raw text deltas here as the
+ * serving adapter streams. Absent => buffered dispatch via `adapter.call()`
+ * (identical to pre-Phase-A behavior). */
+export type StreamDeltaSink = (delta: {
+    readonly text: string;
+}) => void;
+export interface PrimaryRequestParts {
+    readonly route: RouteBundle;
+    readonly candidate: CandidateRef;
+    readonly systemPrompt: string;
+    readonly userDirective: string;
+    /** True when this candidate has native grounding AND the route requires it. */
+    readonly nativeGrounded: boolean;
+    readonly opts: RunOptions;
+    /** CE-1 retry-drop: suppress a customer cache handle on THIS dispatch after a
+     * prior `cache_invalid` on the same candidate carried it. Additive; absent /
+     * false = normal (the handle applies when provider matches). */
+    readonly suppressCustomerCache?: boolean;
+}
+/** Build the primary-attempt AdapterRequest — adds the grounding hint and the
+ * unified tools/toolChoice passthrough (spec §4.4). */
+export declare function buildAdapterRequest(parts: PrimaryRequestParts): AdapterRequest;
+/** Build the repair-attempt AdapterRequest (no tools — repair re-asks for the
+ * structured object, never a tool call). */
+export declare function buildRepairAdapterRequest(route: RouteBundle, candidate: CandidateRef, systemPrompt: string, repairDirective: string): AdapterRequest;
+/**
+ * Dispatch a candidate. When a delta sink is supplied AND the adapter can
+ * stream, drain its stream — forwarding raw text deltas to the sink — and
+ * return the terminal `AdapterResult` (identical to what `call()` returns, so
+ * the run loop's cost/validation/telemetry logic is unchanged). Otherwise
+ * buffered `call()`.
+ */
+export declare function dispatchCandidate(adapter: ProviderAdapter, req: AdapterRequest, onDelta?: StreamDeltaSink): Promise<AdapterResult>;
+export interface ToolCallResultParts {
+    readonly route: RouteBundle;
+    readonly candidate: CandidateRef;
+    readonly result: Extract<AdapterResult, {
+        ok: true;
+    }>;
+    readonly costUsd: number;
+    readonly latencyMs: number;
+    readonly attemptsByClass: RunMeta["attemptsByClass"];
+    readonly servedVariant: string | null;
+    readonly pricingMissing: boolean;
+}
+/**
+ * Record a tool-call turn and build its RunResult (spec §4.4). A tool call is
+ * NOT a schema-validated JSON turn: it records a normal (non-failure) telemetry
+ * row, then returns a result with `validated: false`, `output: null` (the caller
+ * reads `meta.toolCalls`, runs the tool, and continues the exchange), and the
+ * normalized calls surfaced on the meta. Recording goes through run.ts's own
+ * `recordAttempt` so the ledger/tenancy stamping is identical to every other row.
+ */
+export declare function emitToolCallResult(record: RecordAttempt, parts: ToolCallResultParts): RunResult;
+//# sourceMappingURL=dispatch.d.ts.map

package/dist/run/dispatch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dispatch.d.ts","sourceRoot":"","sources":["../../src/run/dispatch.ts"],"names":[],"mappings":"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"}