@bivelio/savings-layer 0.4.32 → 0.4.34

package/dist/index.d.ts

@@ -48,11 +48,11 @@ interface CostModel {
     cachedInputPer1k?: number;
 }
 /** Oldest provider counter a repeat can be valued against: one billing period. */
-declare const REFERENCE_MAX_AGE_MS: number;
+declare const REFERENCE_MAX_AGE_MS$1: number;
 /** Share of the counted output credited to a repeat: only under deterministic sampling, on a catalog model that does not reason and honors it, when the call that ran carried no hidden reasoning. */
-declare const REFERENCE_OUTPUT_SHARE = 0.95;
+declare const REFERENCE_OUTPUT_SHARE$1 = 0.95;
 /** Input tokens deducted per piece the layer inserted in the call that ran: a message, the wrapper around a native output schema, or half of the empty parameters given to a tool that had none. */
-declare const REFERENCE_MESSAGE_ALLOWANCE = 8;
+declare const REFERENCE_MESSAGE_ALLOWANCE$1 = 8;
 /**
  * Why an avoided call (a cache or coalesced hit) could not be valued by
  * reference, and so stays `estimated`.
@@ -102,7 +102,7 @@ interface ReferenceCredit {
     /** Fraction of the standard price applied: 1, or the discounted tier the call ran on or this request declared. */
     tierFactor: number;
 }
-declare class SavingsLedger {
+declare class SavingsLedger$1 {
     avoidedLlm: number;
     baselineLlm: number;
     actualLlm: number;
@@ -125,6 +125,12 @@ declare class SavingsLedger {
     cacheWritePremiumUsd: number;
     /** Provider-initiated cache-write premium, priced in USD. Adds to baseline and `actual` alike. */
     providerCacheWritePremiumUsd: number;
+    /** Cache-write tokens of the served call, every TTL. Read only for `report.nativeSavings`. */
+    nativeCacheWriteInput: number;
+    /** The one-hour part of `nativeCacheWriteInput`. */
+    nativeCacheWrite1hInput: number;
+    /** Whether the layer placed the cache breakpoint on the served call; `null` when unknown. */
+    nativeCacheMarkedByLayer: boolean | null;
     /** Cuenta LOCAL del prompt que de verdad se envió al proveedor. */
     sentInputLocal: number;
     /** Tokens que la capa quitó de ese prompt, en cuenta LOCAL. */
@@ -230,6 +236,8 @@ declare class SavingsLedger {
     compress(originalTokens: number, compressedTokens: number): void;
     /** Ledger 4: tokens still present but billed/processed as provider-cached. */
     providerCached(tokens: number): void;
+    /** Record the served call's cache writes for `report.nativeSavings`. Never priced into `estimateCost`. */
+    nativeCacheWrite(tokens: number, tokens1h: number): void;
     /** Record the premium for `tokens` of cache write the provider bills at `multiplier`x on its own. */
     providerCacheWritePremium(tokens: number, multiplier: number, price: CostModel): void;
     /** Input tokens of calls the provider documents as not billed; already included in `actualInput`. */
@@ -268,6 +276,8 @@ declare class SavingsLedger {
         baselineEstimate: number;
         actual: number;
         netSavings: number;
+        netSavingsRatio: number;
+        netSavingsUsd: number;
         basis: CostBasis;
     };
 }
@@ -293,8 +303,12 @@ declare class SavingsLedger {
  * discounts, negotiated rates or a different region sets their own and this
  * catalogue stays out of the way.
  */
-/** When these prices were last checked against the providers' public rates. */
-declare const PRECIOS_AL_DIA = "2026-09-27";
+/**
+ * Version of this price catalogue: the UTC day its content last changed (rows,
+ * announced price steps, cache-write premiums, tier rates). Two computations
+ * citing the same version were priced with the same content.
+ */
+declare const PRECIOS_AL_DIA$1 = "2026-09-29";
 /**
  * Key = the model id as the provider publishes it, without a vendor prefix.
  * Lookup tries the exact id, then the id without its provider prefix, then the
@@ -305,7 +319,7 @@ declare const PRECIOS_AL_DIA = "2026-09-27";
  * provider has already announced is applied by {@link precioDeLista} from its
  * effective date, so a request is always priced at the rate of its own day.
  */
-declare const CATALOGO: Readonly<Record<string, CostModel>>;
+declare const CATALOGO$1: Readonly<Record<string, CostModel>>;
 /**
  * The list price for a model on the day of the request, or `undefined` when
  * the catalogue has no price for it in force that day.
@@ -315,7 +329,7 @@ declare const CATALOGO: Readonly<Record<string, CostModel>>;
  *   Prices resolve per UTC day, so a price change the provider has announced
  *   applies from its effective date.
  */
-declare function precioDeLista(model: string, at?: Date | number): CostModel | undefined;
+declare function precioDeLista$1(model: string, at?: Date | number): CostModel | undefined;
 
 /**
  * The version the SDK reports for itself.
@@ -325,7 +339,7 @@ declare function precioDeLista(model: string, at?: Date | number): CostModel | u
  * on the customer's machine. `test/version-declarada.test.ts` ties this
  * constant to package.json so the two can never drift.
  */
-declare const BV_SALA_VERSION = "0.4.32";
+declare const BV_SALA_VERSION = "0.4.34";
 
 /**
  * Environment-agnostic UUID generation.
@@ -335,7 +349,7 @@ declare const BV_SALA_VERSION = "0.4.32";
  * Deno and edge runtimes) and fall back to a v4-shaped id when it is absent, so
  * BV-SALA runs everywhere without a `node:crypto` import that breaks bundlers.
  */
-declare function randomId(): string;
+declare function randomId$1(): string;
 
 /** How the layer served a request that is eligible for a verification check. */
 type VerificationStratum = 
@@ -781,8 +795,12 @@ interface SavingsToggles {
      * When your catalogue declares `risk`, write and destructive tools are still withheld
      * from requests the router does not classify as actions, as with the selector. Each
      * search is a short extra step inside the same call, and the definitions it loads are
-     * billed as normal input. This adapter sends earlier turns as text, so a later turn
-     * that needs a tool searches again.
+     * billed as normal input. Across turns, append the assistant turn with its
+     * `toolCalls` (ids as returned) before the tool results: the adapter then sends that
+     * turn's search results back with it, so the model calls the tools it already found
+     * without searching again. It remembers them in memory, per adapter instance and
+     * bounded; a turn it no longer remembers (another process, say) goes out without them
+     * and the model searches again.
      */
     toolSearch?: ToolSearchMode | ToolSearchOptions;
     /**
@@ -1183,8 +1201,30 @@ interface SavingsResult<T = unknown> {
      * Por qué paró de generar el modelo (`"stop"`, `"length"`, `"tool_calls"`, …).
      * Presente cuando la respuesta viene del proveedor; ausente en los atajos
      * (caché/resolver), que solo sirven respuestas finales completas.
+     *
+     * In 0.5 this becomes a CLOSED set — `"stop"`, `"length"`, `"tool_calls"`,
+     * `"content_filter"` or `"other"` — and the provider's own value (for example
+     * `"stop_sequence"`, `"pause_turn"` or `"content_filter: OTHER"`) moves to
+     * `finishReasonDetail`. Compare against those five values only; see the 0.5
+     * migration guide.
      */
     finishReason?: string;
+    /**
+     * The provider's own reason behind `finishReason`, when it gave one. Present
+     * only on answers the provider returned, and only with a non-empty reason:
+     *
+     * - Gemini (OpenAI-compatible endpoint): a filtered answer stops with
+     *   `finish_reason: "content_filter: OTHER"` (or `PROHIBITED_CONTENT`,
+     *   `SAFETY`…); it arrives as `finishReason: "content_filter"` and
+     *   `finishReasonDetail: "OTHER"`.
+     * - Anthropic: a refusal (`stop_reason: "refusal"`) arrives as `finishReason:
+     *   "content_filter"` and `finishReasonDetail` set to `stop_details.category`
+     *   (for example `"cyber"` or `"bio"`).
+     *
+     * OpenAI's Structured Outputs refusal message travels in `refusal` instead.
+     * Informational: it changes neither what is billed nor what is credited.
+     */
+    finishReasonDetail?: string;
     /**
      * The refusal message the model returned instead of an answer (OpenAI
      * Structured Outputs: `message.refusal`, with `finish_reason: "stop"` and no
@@ -1378,8 +1418,21 @@ interface QualityRepairCheck {
 interface QualityTruncationCheck {
     /** True when the provider reported `finishReason: "length"`. A truncated answer is never cached. */
     truncated: boolean;
-    /** The stop reason exactly as the provider named it; absent when it reported none. */
+    /**
+     * Why the provider stopped, as `SavingsResult.finishReason` reports it;
+     * absent when it reported none.
+     *
+     * In 0.5 this becomes the same CLOSED set as `SavingsResult.finishReason` —
+     * `"stop"`, `"length"`, `"tool_calls"`, `"content_filter"` or `"other"` — and
+     * the provider's own value moves to {@link finishReasonDetail}. Compare
+     * against those five values only; see the 0.5 migration guide.
+     */
     finishReason?: string;
+    /**
+     * The provider's own reason behind `finishReason`, when it gave one: the same
+     * value as `SavingsResult.finishReasonDetail` for the answer that was served.
+     */
+    finishReasonDetail?: string;
     /**
      * Whether you set the limit (`maxOutputTokens` on the request or on
      * `response`). When false, any
@@ -1491,6 +1544,64 @@ interface QualityLedger {
     /** Present when `savings.modelCascade` is not `"off"`. */
     cascade?: QualityCascadeCheck;
 }
+/**
+ * The provider's native prompt-cache saving on the call that produced the
+ * answer: what the provider's own cache took off the invoice, net of the
+ * cache-write premium the provider billed on that same call.
+ *
+ * `netUsd = readDiscountUsd − writePremiumUsd`, where
+ * `readDiscountUsd = cacheReadTokens / 1000 × (inputPer1k − cachedInputPer1k)` and
+ * `writePremiumUsd` is the write tokens at `inputPer1k × (multiplier − 1)`
+ * (Anthropic 1.25× for 5 minutes and 2× for one hour; OpenAI 1.25× from
+ * gpt-5.6 on, 1× before; Gemini 1×). Every input is in this block, so it can be
+ * recomputed without trusting the layer. `netUsd` can be negative: a cold
+ * write pays the premium before any read.
+ *
+ * It is SEPARATE on purpose. The layer can place the breakpoint (Anthropic
+ * `cache_control`), route (OpenAI `prompt_cache_key`) or keep the prefix
+ * stable, but the discount is billed by the provider and much of it would be
+ * there without the layer, so it is never credited as the layer's saving:
+ * it is not in `cost.netSavings`, not in `cost.baselineEstimate`, and not in
+ * any commission base.
+ */
+interface NativeSavingsReport {
+    /** Who billed the cache, inferred from the model id. */
+    provider: "anthropic" | "openai" | "google" | "unknown";
+    /**
+     * How that provider caches: `explicit` (Anthropic, `cache_control`
+     * breakpoints), `automatic` (OpenAI, prefix cache with no marking) or
+     * `implicit` (Gemini implicit caching).
+     */
+    mechanism: "explicit" | "automatic" | "implicit" | "unknown";
+    /** True when the layer placed the cache breakpoint on the call that ran. Absent where the layer does not know. */
+    layerMarked?: boolean;
+    /** Input tokens the provider served from its cache on this call (its own counter). */
+    cacheReadTokens: number;
+    /** Input tokens the provider billed as cache writes on this call (its own counter, every TTL). */
+    cacheWriteTokens: number;
+    /** The part of `cacheWriteTokens` written with a one-hour TTL. */
+    cacheWrite1hTokens: number;
+    /** Input rate applied, per 1K tokens. */
+    inputPer1k: number;
+    /** Cache-read rate applied, per 1K tokens. */
+    cachedInputPer1k: number;
+    /** Write multiplier applied to five-minute (or untyped) writes. */
+    writeMultiplier: number;
+    /** Write multiplier applied to one-hour writes. */
+    write1hMultiplier: number;
+    /** What the cache reads saved against the input rate, USD. */
+    readDiscountUsd: number;
+    /** The premium the provider billed for the cache writes, USD. */
+    writePremiumUsd: number;
+    /** `readDiscountUsd − writePremiumUsd`, USD. Can be negative. */
+    netUsd: number;
+    /**
+     * `measured`: the provider's own counter at list price. `unmeasured`: the
+     * counter was incomplete or there is no cache-read price for the model, and
+     * every USD figure is 0.
+     */
+    basis: "measured" | "unmeasured";
+}
 interface SavingsReport {
     requestId: string;
     /**
@@ -1613,6 +1724,17 @@ interface SavingsReport {
      * `cacheBreakpoints: "auto"` switched this request to explicit mode.
      */
     cacheWrites?: CacheWriteReport;
+    /**
+     * The provider's OWN prompt-cache discount on this call, shown apart. Present
+     * only when a call ran and the provider reported cache reads or writes.
+     *
+     * It is not the layer's saving and it is never part of `cost.netSavings`,
+     * `cost.baselineEstimate`, `basis: "reference"` or the commission base: the
+     * discount is the provider's, and `cost` prices cached tokens at the cached
+     * rate on both sides for exactly that reason. It exists so the report adds up
+     * to your invoice. See {@link NativeSavingsReport}.
+     */
+    nativeSavings?: NativeSavingsReport;
     /** How a streamed request was delivered. Present only on results of `generateStream`. */
     streaming?: StreamingReport;
     /**
@@ -1636,7 +1758,29 @@ interface SavingsReport {
     cost: {
         baselineEstimate: number;
         actual: number;
+        /**
+         * A RATIO, not money: `1 - actual / baselineEstimate`, rounded to six
+         * decimals (0 when nothing was saved, negative when the request cost more).
+         * Do not sum it across requests: it is a ratio, not dollars.
+         *
+         * @deprecated Since 0.4.33, read {@link netSavingsRatio} (the same value) or
+         * {@link netSavingsUsd} (the saving in USD). Removed in 0.5: see the 0.5
+         * migration guide.
+         */
         netSavings: number;
+        /**
+         * The saving as a RATIO of the baseline: `1 - actual / baselineEstimate`,
+         * rounded to six decimals (0 when nothing was saved or there is no baseline,
+         * negative when the request cost more). Do not sum it across requests: sum
+         * {@link netSavingsUsd}.
+         */
+        netSavingsRatio: number;
+        /**
+         * The saving in USD: `baselineEstimate - actual` (negative when the request
+         * cost more). Sum it only within one `basis`: measured and estimated money
+         * are never added together.
+         */
+        netSavingsUsd: number;
         /**
          * Where the baseline comes from. It is what separates measured money from
          * estimated money.
@@ -1694,6 +1838,12 @@ interface SavingsReport {
         preprocessing: number;
         provider: number;
     };
+    /**
+     * Present only when the layer runs on the free «Measure» license (shadow
+     * mode): what the levers would have saved on this request. Nothing was
+     * applied — `cost` is this call's measured spend with no saving claimed.
+     */
+    measure?: MeasureReport;
     /** Ordered pipeline decision breadcrumbs, for debugging and audit. */
     traces: TraceEvent[];
 }
@@ -1744,6 +1894,50 @@ interface LicenseGate {
      * caller; without it, the generic message for that status.
      */
     reason?(): string | undefined;
+    /**
+     * The plan of the license in force, when there is one. `"measure"` (the free
+     * «Measure» license) puts the layer in SHADOW MODE: the request goes to the
+     * provider exactly as you built it, nothing is served from any cache, and
+     * `report.measure` says what the levers would have saved. Optional because a
+     * gate is implemented by the caller; without it, the layer is not in shadow.
+     */
+    plan?(): string | undefined;
+}
+/**
+ * What a layer running on the free «Measure» license would have saved on this
+ * request. Present ONLY in shadow mode. Nothing here was applied: the request
+ * went to your provider untouched and nothing was served from a cache.
+ *
+ * Every figure is HYPOTHETICAL (`basis: "shadow"`): it is never part of
+ * `cost.baselineEstimate`, `cost.actual` or `cost.netSavings`, never in any
+ * commission base, and never added to measured money.
+ */
+interface MeasureReport {
+    mode: "shadow";
+    /** Always false: in shadow mode no lever changes the request or avoids a call. */
+    applied: false;
+    wouldHaveSaved: {
+        /** USD this request would not have cost with the simulated levers on. */
+        usd: number;
+        basis: "shadow";
+        /**
+         * Which lever would have avoided the call entirely, valued with THIS call's
+         * provider counter (`cost.actual`):
+         *   · `exact-repeat`       — a byte-identical, cacheable request already ran
+         *                            in this process within the exact-cache TTL;
+         *   · `in-flight-duplicate`— an identical request was in flight at the same
+         *                            time and would have been coalesced.
+         * `null` when no simulated lever would have avoided it.
+         */
+        avoidedCall: "exact-repeat" | "in-flight-duplicate" | null;
+    };
+    /**
+     * Levers this shadow does NOT simulate, so `wouldHaveSaved` is a LOWER bound:
+     * they need a model call, an embedding, or a paid entitlement to estimate.
+     */
+    notSimulated: string[];
+    /** Where to turn the levers on. */
+    upgradeUrl: string;
 }
 interface TraceEvent {
     stage: string;
@@ -1911,7 +2105,7 @@ declare class InMemoryExactCache implements ExactCache {
  * requests that mean the same thing must canonicalize identically, and two
  * requests that differ in any way that could change the answer must not.
  */
-interface CanonicalRequest {
+interface CanonicalRequest$1 {
     model: string;
     modelFamily: string;
     messages: ChatMessage[];
@@ -1976,10 +2170,10 @@ interface CanonicalRequest {
  * thousands separators, times, dates, units, negations, math operators and any
  * combining mark outside the Latin alphabet.
  */
-declare function normalizeText(text: string): string;
-declare function sha256(input: string): string;
+declare function normalizeText$1(text: string): string;
+declare function sha256$1(input: string): string;
 /** Stable JSON stringify with sorted keys so hashes are order-independent. */
-declare function stableStringify(value: unknown): string;
+declare function stableStringify$1(value: unknown): string;
 /**
  * The version-and-size-independent family of a model id.
  *
@@ -1987,8 +2181,8 @@ declare function stableStringify(value: unknown): string;
  * ANSWER, which is not always the one the caller named. Deriving the family a
  * second time somewhere else is how two rulers start to disagree.
  */
-declare function modelFamilyOf(model: string): string;
-declare function canonicalize(request: SavingsRequest): CanonicalRequest;
+declare function modelFamilyOf$1(model: string): string;
+declare function canonicalize$1(request: SavingsRequest): CanonicalRequest$1;
 
 /**
  * Thrown by `importCalibration` / `exportCalibration` when a calibration state
@@ -2142,7 +2336,7 @@ interface SemanticCalibrationStatus {
     nextTestAt?: number;
 }
 /** Default {@link AnswerJudge}: the stored answer counts as right only if it is the same answer. */
-declare function sameAnswer(stored: CachedAnswer, fresh: CachedAnswer): boolean;
+declare function sameAnswer$1(stored: CachedAnswer, fresh: CachedAnswer): boolean;
 /**
  * Certifies an acceptance floor from labels you already have (your own traffic,
  * or a labeled set scored with your embedder), with the same test the cache
@@ -2323,13 +2517,13 @@ interface SemanticCacheOptions {
      */
     calibration?: SemanticCalibrationOptions;
 }
-declare function cosine(a: number[], b: number[]): number;
-declare function numericTokens(s: string): string[];
-declare function multisetEqual(a: string[], b: string[]): boolean;
-declare function words(s: string): string[];
-declare function negationCount(tokens: string[]): number;
+declare function cosine$1(a: number[], b: number[]): number;
+declare function numericTokens$1(s: string): string[];
+declare function multisetEqual$1(a: string[], b: string[]): boolean;
+declare function words$1(s: string): string[];
+declare function negationCount$1(tokens: string[]): number;
 /** True when two normalized queries agree on the facts an embedding tends to blur. */
-declare function keyTokensMatch(a: string, b: string): boolean;
+declare function keyTokensMatch$1(a: string, b: string): boolean;
 /**
  * In-memory reference implementation. A production build would back this with a
  * real vector store and metadata filters pushed down
@@ -2363,7 +2557,7 @@ declare class InMemorySemanticCache {
      * and labels nothing: without {@link lookup} and {@link observe} (the layer
      * calls both) the calibration never gets a label and never certifies.
      */
-    find(c: CanonicalRequest): Promise<SemanticHit | null>;
+    find(c: CanonicalRequest$1): Promise<SemanticHit | null>;
     /**
      * The best candidate that passes every hard filter, the similarity floor and
      * the fact guard. With `conAceptacion`, also the confidence floor (the path
@@ -2378,7 +2572,7 @@ declare class InMemorySemanticCache {
      * `agentic` picks the traffic segment: calibrations are kept apart for
      * single-shot and agentic requests.
      */
-    lookup(c: CanonicalRequest, opts?: {
+    lookup(c: CanonicalRequest$1, opts?: {
         agentic?: boolean;
     }): Promise<SemanticLookup>;
     /**
@@ -2426,7 +2620,7 @@ declare class InMemorySemanticCache {
     importCalibration(state: SemanticCalibrationState | string | unknown): void;
     private identidad;
     private estadoDe;
-    store(c: CanonicalRequest, answer: CachedAnswer): Promise<void>;
+    store(c: CanonicalRequest$1, answer: CachedAnswer): Promise<void>;
     /** Drop every record for a knowledge epoch (invalidation on re-index). */
     invalidateEpoch(knowledgeEpoch: string): number;
     get size(): number;
@@ -2529,12 +2723,12 @@ interface ResolverResult {
 }
 interface DeterministicResolver {
     readonly name: string;
-    try(c: CanonicalRequest): ResolverResult | null;
+    try(c: CanonicalRequest$1): ResolverResult | null;
 }
 declare class ResolverRegistry {
     private readonly resolvers;
     register(resolver: DeterministicResolver): this;
-    try(c: CanonicalRequest): ResolverResult | null;
+    try(c: CanonicalRequest$1): ResolverResult | null;
     get size(): number;
 }
 /**
@@ -2544,7 +2738,7 @@ declare class ResolverRegistry {
  */
 declare const arithmeticResolver: DeterministicResolver;
 /** Shunting-yard evaluation of a numeric expression. Returns null on any parse issue. */
-declare function evalArithmetic(expr: string): number | null;
+declare function evalArithmetic$1(expr: string): number | null;
 /** A registry seeded with the built-in safe resolvers. */
 declare function createDefaultResolvers(): ResolverRegistry;
 
@@ -2585,7 +2779,7 @@ declare class ExecutionRouter {
         classifier?: LocalClassifier;
         maxRounds?: number;
     });
-    classify(c: CanonicalRequest): RouteDecision;
+    classify(c: CanonicalRequest$1): RouteDecision;
 }
 
 /**
@@ -2614,17 +2808,22 @@ interface ToolSelection {
 }
 interface ToolSelectorOptions {
     /**
-     * Max tools the selector keeps when it has a SIGNAL to select on: a catalogue
-     * whose tools declare `intents` and/or `risk`, with the router on. Default 8.
-     *
-     * It never truncates a catalogue it cannot rank. A catalogue that declares no
-     * `intents` and no `risk` (the usual case: MCP and OpenAI tool lists) and every
-     * request with `savings: { router: false }` go to the provider WHOLE, exactly as
-     * the caller sent them, and the layer credits nothing for the tool block:
-     * cutting by position left the model unable to call the rest (on BFCL
-     * multi-turn, gpt-4o-mini hit the reference call 8/10 times directly and 1/10
-     * through the layer). When the selector does prune a typed catalogue, the
-     * report's `tool-selector` trace lists what was left out and the SDK warns
+     * Cap on the tools the selector keeps by relevance. Unset (the default since
+     * 0.4.33), there is NO cap and NO relevance pruning: every tool the request
+     * may use reaches the provider, and the layer credits nothing for the tool
+     * block. Set it to opt in to pruning a TYPED catalogue (tools that declare
+     * `intents` and/or `risk`, with the router on) down to the `maxTools` most
+     * relevant ones — up to 0.4.32 that was the default, with 8.
+     *
+     * What is never affected by this option: write and destructive tools are
+     * still withheld from a request the router does not classify as an action
+     * (that gate is about safety, not size), and a catalogue that declares no
+     * `intents` and no `risk` (the usual case: MCP and OpenAI tool lists), or any
+     * request with `savings: { router: false }`, goes to the provider WHOLE,
+     * exactly as the caller sent it. Cutting blind left the model unable to call
+     * the rest (on BFCL multi-turn, gpt-4o-mini hit the reference call 8/10 times
+     * directly and 1/10 through the layer). Whenever the selector does leave a
+     * tool out, the report's `tool-selector` trace lists it and the SDK warns
      * (once per process, silenced by `silenceWarnings`).
      */
     maxTools?: number;
@@ -2813,7 +3012,7 @@ interface ConstraintPlan {
  * backend which *claims* support actually enforces every constraint — declared
  * support and empirical coverage are not the same thing.
  */
-declare function resolveConstraintBackend(model: string, schema: JsonSchema, backends: ConstraintBackend[]): ConstraintPlan;
+declare function resolveConstraintBackend$1(model: string, schema: JsonSchema, backends: ConstraintBackend[]): ConstraintPlan;
 /** A permissive backend used when the provider validates structured output natively. */
 declare function providerNativeBackend(isSupported?: (model: string, schema: JsonSchema) => boolean): ConstraintBackend;
 
@@ -2875,7 +3074,7 @@ interface CompressionPolicyInput {
  * Here we model the token side; latency/quality penalties are folded into
  * `compressorCostTokens` and `minimumNetTokens` by the caller.
  */
-declare function shouldCompress(input: CompressionPolicyInput): {
+declare function shouldCompress$1(input: CompressionPolicyInput): {
     compress: boolean;
     reason: string;
 };
@@ -2886,12 +3085,14 @@ declare function shouldCompress(input: CompressionPolicyInput): {
  * back to the ORIGINAL text — a compressor that drops a negation or a number is
  * worse than no compressor at all.
  */
-declare function withProtectedSpans(inner: Compressor): Compressor;
+declare function withProtectedSpans$1(inner: Compressor): Compressor;
 /** No-op compressor: the safe default until a real compressor sidecar is wired in. */
 declare const noopCompressor: Compressor;
 /**
  * Did the compression keep the facts that must not change? Verifies the RESULT —
  * number/date multiset and negation parity — not the compressor's own claim.
+ *
+ * @deprecated Internal check of the compression stage; leaves the public API in 0.5.
  */
 declare function compresionFiel(original: string, comprimido: string): boolean;
 
@@ -3045,13 +3246,13 @@ interface RetrievalOutcome {
     keptCount: number;
 }
 /** Remove exact and near-duplicate docs by normalized text / hash. */
-declare function dedupe(docs: EvidenceDoc[]): EvidenceDoc[];
+declare function dedupe$1(docs: EvidenceDoc[]): EvidenceDoc[];
 /**
  * Adaptive-k: choose how many documents to keep based on the score distribution
  * rather than a fixed cutoff. When the top document dominates, keep fewer; when
  * scores are flat, keep up to the cap. This directly trims input tokens.
  */
-declare function adaptiveK(docs: EvidenceDoc[], opts?: {
+declare function adaptiveK$1(docs: EvidenceDoc[], opts?: {
     maxDocuments: number;
     minDocuments?: number;
 }): EvidenceDoc[];
@@ -3059,7 +3260,7 @@ declare function adaptiveK(docs: EvidenceDoc[], opts?: {
  * Execute a retrieval plan. NO_RETRIEVAL / TOOL_ACTION classes retrieve nothing.
  * Otherwise: retrieve -> dedupe -> rerank -> adaptive-k, bounded by maxRounds.
  */
-declare function executeRetrievalPlan(plan: RetrievalPlan, deps: {
+declare function executeRetrievalPlan$1(plan: RetrievalPlan, deps: {
     retriever?: Retriever;
     reranker?: Reranker;
 }): Promise<RetrievalOutcome>;
@@ -3271,8 +3472,10 @@ interface ProviderResponse {
      * OpenAI-compatible endpoint stops a filtered answer with
      * `finish_reason: "content_filter: OTHER"` (or `PROHIBITED_CONTENT`,
      * `SAFETY`…), which the built-in adapter reports as `finishReason:
-     * "content_filter"` and `finishReasonDetail: "OTHER"`. Informational: the
-     * layer decides on `finishReason` alone.
+     * "content_filter"` and `finishReasonDetail: "OTHER"`. Anthropic's refusal
+     * (`stop_reason: "refusal"`) carries its `stop_details.category` here.
+     * Informational: the layer decides on `finishReason` alone, and passes this
+     * on to the caller as `SavingsResult.finishReasonDetail`.
      */
     finishReasonDetail?: string;
     /**
@@ -3427,10 +3630,10 @@ interface Provider {
  * `licenseKey: "   "` (an empty environment variable, a blank secret file) used
  * to tell the customer their key "does not verify" — there was no key.
  */
-type LicenseStatus = "active" | "grace" | "expired" | "invalid" | "revoked" | "stale" | "none";
+type LicenseStatus$1 = "active" | "grace" | "expired" | "invalid" | "revoked" | "stale" | "none";
 /** Decoded license token body (mirror of `@bivelio/protocol`'s LicensePayload,
  *  declared locally so the SDK stays free of a control-plane dependency). */
-interface LicenseTokenPayload {
+interface LicenseTokenPayload$1 {
     jti: string;
     org_id: string;
     plan: string;
@@ -3440,15 +3643,18 @@ interface LicenseTokenPayload {
     expires_at: number;
     grace_days: number;
     iss?: string;
+    /** Measure licenses only: the REAL term (see `vigenciaEfectiva` in ./vigencia.ts). */
+    measure_expires_at?: number;
+    measure_grace_days?: number;
 }
-interface ResolvedLicense {
-    status: LicenseStatus;
-    payload?: LicenseTokenPayload;
+interface ResolvedLicense$1 {
+    status: LicenseStatus$1;
+    payload?: LicenseTokenPayload$1;
     reason?: string;
 }
-declare const EMBEDDED_PUBLIC_KEY: string;
+declare const EMBEDDED_PUBLIC_KEY$1: string;
 /** Result of verifying a compact `head.body.sig` token's signature. */
-interface CompactVerification {
+interface CompactVerification$1 {
     /** True only if the signature is valid for the given public key. */
     ok: boolean;
     /** Decoded header (present when `ok`), e.g. `{ alg, typ, v }`. */
@@ -3471,7 +3677,7 @@ interface LicenseKeyset {
     defaultKid: string;
 }
 /** Narrow a verification key to a {@link LicenseKeyset} (vs a bare SPKI PEM string). */
-declare function isKeyset(k: string | LicenseKeyset): k is LicenseKeyset;
+declare function isKeyset$1(k: string | LicenseKeyset): k is LicenseKeyset;
 /**
  * Normalize a license key the way it arrives from the real world — ONCE, at the
  * entry point, never inside the verifier.
@@ -3496,7 +3702,7 @@ declare function isKeyset(k: string | LicenseKeyset): k is LicenseKeyset;
  * Anything INSIDE the key is left alone: an interior space is not wrapping, it
  * is a broken key, and {@link licenseKeyShape} reports it as `malformed`.
  */
-declare function normalizeLicenseKey(raw: string): string;
+declare function normalizeLicenseKey$1(raw: string): string;
 /**
  * The SHAPE of an already-normalized key, so the error message can tell apart
  * three problems that used to get the same text:
@@ -3511,9 +3717,9 @@ declare function normalizeLicenseKey(raw: string): string;
  * It is the SAME shape rule {@link verifyCompactSignature} enforces, so that "has
  * the shape" and "verification was attempted" mean the same thing.
  */
-type LicenseKeyShape = "empty" | "malformed" | "token";
+type LicenseKeyShape$1 = "empty" | "malformed" | "token";
 /** Classify a normalized key. See {@link LicenseKeyShape}. */
-declare function licenseKeyShape(normalizedKey: string): LicenseKeyShape;
+declare function licenseKeyShape$1(normalizedKey: string): LicenseKeyShape$1;
 /**
  * Verify the Ed25519 signature of any BV-SALA compact token
  * (`base64url(header).base64url(body).base64url(sig)`, sig over `${head}.${body}`)
@@ -3530,11 +3736,11 @@ declare function licenseKeyShape(normalizedKey: string): LicenseKeyShape;
  * the same answer to the same input, always; a caller that wants to tolerate
  * wrapping normalizes BEFORE calling.
  */
-declare function verifyCompactSignature(token: string, publicKey: string | LicenseKeyset): CompactVerification;
+declare function verifyCompactSignature$1(token: string, publicKey: string | LicenseKeyset): CompactVerification$1;
 /** Verify a token's signature and decode its payload. Does not check expiry. */
-declare function verifyLicenseToken(token: string, publicKey: string | LicenseKeyset): {
+declare function verifyLicenseToken$1(token: string, publicKey: string | LicenseKeyset): {
     signatureValid: boolean;
-    payload?: LicenseTokenPayload;
+    payload?: LicenseTokenPayload$1;
     reason?: string;
 };
 /**
@@ -3547,11 +3753,11 @@ declare function verifyLicenseToken(token: string, publicKey: string | LicenseKe
  *   expires_at < now <= +grace_days      → grace (still entitled)
  *   now > expires_at + grace_days        → expired
  */
-declare function deriveStatus(payload: {
+declare function deriveStatus$1(payload: {
     jti: string;
     expires_at: number;
     grace_days: number;
-}, nowSeconds: number, revoked?: ReadonlySet<string>): LicenseStatus;
+}, nowSeconds: number, revoked?: ReadonlySet<string>): LicenseStatus$1;
 /**
  * Verify + apply the grace policy → a resolved status. Mirrors what the issuing
  * control plane resolves for the same token. Bad signature / malformed
@@ -3560,10 +3766,10 @@ declare function deriveStatus(payload: {
  * A public entry point, so it normalizes like the others (gate and refresher):
  * the same key must resolve the same whichever way it comes in.
  */
-declare function resolveLicense(token: string, publicKey: string | LicenseKeyset, opts?: {
+declare function resolveLicense$1(token: string, publicKey: string | LicenseKeyset, opts?: {
     nowSeconds?: number;
     revoked?: ReadonlySet<string>;
-}): ResolvedLicense;
+}): ResolvedLicense$1;
 
 /**
  * Everything the pipeline depends on. All fields except `provider` and
@@ -3594,6 +3800,19 @@ interface SavingsLayerConfig {
      * it on every request. A layer that has a cache and a request that neither
      * asks for it nor turns it off gets a one-time console warning (silenced by
      * `silenceWarnings`, or by setting `semanticCacheDefault`, `false` included).
+     *
+     * Called `semanticCache` until 0.4.33, so that the store and the per-request
+     * switch (`savings.semanticCache`) no longer share a name. See the 0.5
+     * migration guide.
+     */
+    semanticCacheStore?: InMemorySemanticCache;
+    /**
+     * @deprecated Renamed {@link semanticCacheStore} in 0.4.33, so that the store
+     * and the per-request switch (`savings.semanticCache`) no longer share a name.
+     * It still works, with a one-time warning (silenced by `silenceWarnings` or
+     * `BVSALA_SILENCE_DEPRECATIONS=1`);
+     * when both are given, `semanticCacheStore` wins. Removed in 0.5: see the 0.5
+     * migration guide.
      */
     semanticCache?: InMemorySemanticCache;
     /**
@@ -3601,7 +3820,7 @@ interface SavingsLayerConfig {
      * request's own value always wins, `false` included. Unset, the semantic cache
      * is used only by requests that ask for it.
      *
-     * OPT-IN, and deliberately a separate field from {@link semanticCache}: the
+     * OPT-IN, and deliberately a separate field from {@link semanticCacheStore}: the
      * cache is the backend, this is the decision to serve answers to reworded
      * questions, which can serve a wrong answer. Prefer it with a cache built with
      * `calibration`, which serves nothing until your own traffic certifies a
@@ -3723,6 +3942,11 @@ interface SavingsLayerConfig {
      * to support signing-key rotation — legacy no-kid tokens use `defaultKid`, and
      * an unknown kid fails closed. For self-hosting/self-testing; defaults to the
      * build-embedded BiVelio key.
+     *
+     * @deprecated Has no effect in the published package, which always verifies
+     * against the embedded BiVelio key; passing it there logs a one-time warning
+     * (silenced by `silenceWarnings` or `BVSALA_SILENCE_DEPRECATIONS=1`). Removed
+     * from the public type in 0.5: delete it from your config.
      */
     licensePublicKey?: string | LicenseKeyset;
     /**
@@ -3731,6 +3955,9 @@ interface SavingsLayerConfig {
      * only accepted license — passing a gate there logs a warning and changes
      * nothing. It exists for builds from source (this repo's own tests and
      * benchmarks), where it takes precedence over {@link licenseKey}.
+     *
+     * @deprecated Ignored in the published package. Removed from the public type
+     * in 0.5; license the layer with {@link licenseKey} or `serviceAccountKey`.
      */
     licenseGate?: LicenseGate;
     /**
@@ -3849,6 +4076,9 @@ interface SavingsLayerConfig {
      * distributed build hard-codes the licensing check on, so setting
      * `devUnlicensed` (or `BVSALA_DEV_OPEN`) there has NO effect — the layer still
      * requires a valid `licenseKey`. It is not a way to run the product for free.
+     *
+     * @deprecated No effect in the published package. Removed from the public type
+     * in 0.5: delete it from your config.
      */
     devUnlicensed?: boolean;
     /** Per-model cost models; falls back to `defaultCostModel`. */
@@ -4313,7 +4543,7 @@ declare const registrarTokenizadorExacto: typeof registerExactTokenizer;
  * `modelFamily` is derived from whichever id is used, for the same reason: it is
  * part of the identity of whoever answers.
  */
-declare function buildExactKey(c: CanonicalRequest, opciones?: {
+declare function buildExactKey$1(c: CanonicalRequest$1, opciones?: {
     servedModel?: string;
 }): string;
 /**
@@ -4353,7 +4583,7 @@ declare function buildExactKey(c: CanonicalRequest, opciones?: {
  * A caller who never set `savings.deferrable` must not be made to wait for one
  * who did.
  */
-declare function buildInflightKey(c: CanonicalRequest, opciones?: {
+declare function buildInflightKey$1(c: CanonicalRequest$1, opciones?: {
     servedModel?: string;
     deferrable?: boolean;
     toolDiscovery?: boolean;
@@ -4420,7 +4650,7 @@ interface Policy {
     sensitiveTopic: "self-harm" | "mental-health-crisis" | "medical-emergency" | null;
     reasons: string[];
 }
-declare function evaluatePolicy(c: CanonicalRequest): Policy;
+declare function evaluatePolicy$1(c: CanonicalRequest$1): Policy;
 
 /**
  * A LOCAL EMBEDDING FUNCTION — no network, no API key, no per-call cost.
@@ -4459,6 +4689,9 @@ declare function evaluatePolicy(c: CanonicalRequest): Policy;
  * Term weight is sublinear (`1 + log tf`) so a word repeated forty times does not
  * dominate the direction of the vector, and the result is L2-normalised so cosine
  * similarity is a plain dot product.
+ *
+ * @deprecated Internal detail of {@link localEmbedding}; leaves the public API in 0.5.
+ * Use {@link localEmbedding}, which returns the same vector.
  */
 declare function vectorLocal(texto: string): number[];
 /**
@@ -4467,6 +4700,8 @@ declare function vectorLocal(texto: string): number[];
  * Synchronous by design — it returns the array, not a promise — so a cache lookup
  * adds no await and no latency to the request path.
  */
+declare function localEmbedding(text: string): number[];
+/** @deprecated Spanish name, removed in 0.5. Use {@link localEmbedding}. */
 declare function embebedorLocal(texto: string): number[];
 /**
  * The similarity floor this embedder is calibrated for.
@@ -4477,6 +4712,8 @@ declare function embebedorLocal(texto: string): number[];
  * guessed — see `test/embebedor-local.test.ts`, which fails if the two
  * populations stop being separable.
  */
+declare const LOCAL_EMBEDDING_THRESHOLD = 0.72;
+/** @deprecated Spanish name, removed in 0.5. Use {@link LOCAL_EMBEDDING_THRESHOLD}. */
 declare const UMBRAL_LOCAL = 0.72;
 
 /**
@@ -4513,7 +4750,7 @@ declare function mergeDelta(state: ConversationState, delta: MemoryDelta): Conve
  * relevant, non-empty state is serialized, then the last `rawTurns` messages,
  * then the current message.
  */
-declare function projectContext(opts: {
+declare function projectContext$1(opts: {
     state: ConversationState;
     history: ChatMessage[];
     current: ChatMessage;
@@ -4551,7 +4788,7 @@ interface CompactRowsOptions {
 }
 declare function encodeCompactRows(value: unknown, options?: CompactRowsOptions): string;
 /** Return shared column names iff every element is a flat, scalar-valued object with identical keys. */
-declare function uniformColumns(arr: unknown[]): string[] | null;
+declare function uniformColumns$1(arr: unknown[]): string[] | null;
 /**
  * The instruction a model needs to read the compact encoder. Kept short on purpose — this text
  * is the per-request overhead the selector must amortize before it wins.
@@ -4763,12 +5000,15 @@ interface OpenAICompatibleOptions {
  * incumple la segunda y el proveedor responde 400. No es un fallo del cliente:
  * es una restricción de OpenAI que JSON Schema no tiene.
  */
-declare function isStrictCompatible(schema: unknown): boolean;
+declare function isStrictCompatible$1(schema: unknown): boolean;
 /**
  * Decides the id that travels on the wire. Explicit option wins; otherwise the
  * endpoint decides: OpenAI/Azure and Google's own Gemini API get the bare id,
  * everything else keeps what the caller wrote. Exported for the pipeline-level test that pins the README
  * snippet; not part of the public API.
+ *
+ * @deprecated Not part of the public API; leaves it in 0.5. Use the adapter option
+ * `stripProviderPrefix`.
  */
 declare function quitarPrefijoDeProveedor(model: string, explicito: boolean | undefined, baseUrl: string): string;
 declare class OpenAICompatibleProvider implements Provider {
@@ -4928,12 +5168,101 @@ declare class AnthropicProvider implements Provider {
     private leerMensaje;
 }
 
+/** Gemini's `ThinkingConfig`, as its API reference defines it. */
+interface GoogleThinkingConfig {
+    thinkingLevel?: "MINIMAL" | "LOW" | "MEDIUM" | "HIGH" | (string & {});
+    thinkingBudget?: number;
+    includeThoughts?: boolean;
+}
+
+/**
+ * Options for {@link GoogleProvider}, the adapter for Gemini's native API
+ * (`generateContent` / `streamGenerateContent`, v1beta).
+ */
+interface GoogleOptions {
+    /** Gemini API key, sent in the `x-goog-api-key` header. */
+    apiKey?: string;
+    /**
+     * Defaults to `https://generativelanguage.googleapis.com/v1beta`, Google's
+     * own API. Override for a gateway or a proxy that speaks the same shape;
+     * repeats of calls that went anywhere else are never valued by reference.
+     */
+    baseUrl?: string;
+    /** Extra headers (e.g. for a gateway). */
+    headers?: Record<string, string>;
+    /** Injectable fetch for testing. */
+    fetchImpl?: typeof fetch;
+    /**
+     * When true (recommended for measurement), a response without the prompt
+     * and output counters in `usageMetadata` is a hard error instead of being
+     * counted as 0 tokens, which would otherwise fabricate a saving.
+     */
+    requireUsage?: boolean;
+    /**
+     * Default `generationConfig.thinkingConfig` for every request, sent as
+     * written (`{ thinkingLevel: "LOW" }`, `{ thinkingBudget: 0 }`,
+     * `{ includeThoughts: true }`). A request's `reasoningEffort` replaces its
+     * level or budget. Thought summaries (`includeThoughts`) are billed output
+     * and never part of `text`.
+     */
+    thinkingConfig?: GoogleThinkingConfig;
+    /** `safetySettings`, sent as written with every request. */
+    safetySettings?: unknown[];
+}
+/**
+ * Adapter for Gemini's NATIVE API (`models/{model}:generateContent` and
+ * `:streamGenerateContent?alt=sse`, v1beta). Recommended for Gemini; use
+ * {@link OpenAICompatibleProvider} for every other provider.
+ *
+ * Unlike Gemini's OpenAI-compatible endpoint, the native API documents what the
+ * layer measures: the system prompt travels in `systemInstruction`; tools are
+ * `functionDeclarations` and calls come back as `functionCall` parts whose
+ * `thoughtSignature` is returned in `ToolCallRequest.extraContent` (the same
+ * shape as the compatible endpoint's) and sent back untouched; `usageMetadata`
+ * separates prompt, cached prompt (implicit caching), visible output and
+ * thinking (`thoughtsTokenCount`, billed as output); and a blocked prompt
+ * (`promptFeedback.blockReason`) or a filtered answer (`finishReason` `SAFETY`,
+ * `PROHIBITED_CONTENT`, `BLOCKLIST`…) is reported as
+ * `finishReason: "content_filter"` with the native reason in
+ * `finishReasonDetail`, so it is measured, never cached and never credited.
+ *
+ * The output contract travels in `responseJsonSchema` with
+ * `responseMimeType: "application/json"`; `maxOutputTokens`, `temperature` and
+ * `seed` in `generationConfig`; `reasoningEffort` becomes `thinkingLevel`
+ * (Gemini 3) or `thinkingBudget` (Gemini 2.5); a deferrable request asks for
+ * `serviceTier: "flex"`. Explicit context caching (`cachedContents`) is not
+ * used.
+ *
+ * Network calls use global `fetch` (Node >= 18) so there is no SDK dependency.
+ */
+declare class GoogleProvider implements Provider {
+    readonly id: string;
+    private readonly opts;
+    private readonly fetchImpl;
+    private readonly base;
+    private readonly oficial;
+    private readonly nivelAprendido;
+    constructor(opts?: GoogleOptions);
+    generate(req: ProviderRequest, options?: ProviderStreamOptions): Promise<ProviderResponse>;
+    /**
+     * Streaming variant of generate() over `streamGenerateContent?alt=sse`.
+     * Requests with an output contract or a deferrable tier are served by
+     * generate() and yielded as one text event.
+     */
+    generateStream(req: ProviderRequest, options?: ProviderStreamOptions): AsyncGenerator<ProviderStreamEvent, void, undefined>;
+    private enviarConCorrecciones;
+    private enviar;
+    private cuerpo;
+    private pensamiento;
+    private cerrar;
+}
+
 /**
  * Trace collector: an ordered log of pipeline decisions with elapsed timings.
  * Every stage records why it did what it did, so a SavingsReport can be audited
  * and so ablations can attribute savings to a specific module.
  */
-declare class TraceCollector {
+declare class TraceCollector$1 {
     private readonly events;
     private readonly start;
     private readonly now;
@@ -4967,14 +5296,14 @@ declare class LicenseError extends Error {
 }
 
 /** Decoded revocation-list body (mirror of @bivelio/protocol's RevocationListPayload). */
-interface RevocationListBody {
+interface RevocationListBody$1 {
     v: number;
     asOf: number;
     seq: number;
     revoked: string[];
     iss?: string;
 }
-interface RevocationListVerification {
+interface RevocationListVerification$1 {
     /** True only if signature + typ + monotonic-seq + skew all pass. */
     ok: boolean;
     /** List revision (monotonic). -1 when not ok. */
@@ -4993,11 +5322,11 @@ interface RevocationListVerification {
  * ANY failure returns `ok:false` with an empty set; the poller then keeps its
  * sticky last-known-good (fail-open), never dropping known revocations.
  */
-declare function verifyRevocationList(token: string, publicKey: string | LicenseKeyset, opts?: {
+declare function verifyRevocationList$1(token: string, publicKey: string | LicenseKeyset, opts?: {
     minSeq?: number;
     nowSeconds?: number;
     maxSkewSeconds?: number;
-}): RevocationListVerification;
+}): RevocationListVerification$1;
 /**
  * The SDK's live, sticky, monotonic view of the revocation set. It only ever
  * GROWS (a jti, once seen revoked, stays revoked for the process lifetime) and
@@ -5005,7 +5334,7 @@ declare function verifyRevocationList(token: string, publicKey: string | License
  * list can never un-revoke a license. The live gate reads {@link snapshot} on
  * every request; the poller feeds it via {@link apply}.
  */
-declare class RevocationSnapshot {
+declare class RevocationSnapshot$1 {
     private _seq;
     private _asOf;
     private _lastContactAt;
@@ -5033,9 +5362,9 @@ declare class RevocationSnapshot {
 }
 
 /** A resolved gate that also exposes overall status + a refresh horizon. */
-interface ResolvedGate extends LicenseGate {
+interface ResolvedGate$1 extends LicenseGate {
     isActive(): boolean;
-    status(): LicenseStatus;
+    status(): LicenseStatus$1;
     /**
      * Why the key does not open, when it does not; `undefined` when it verified.
      * Under `status() === "invalid"` it tells a key that does NOT EVEN HAVE THE
@@ -5045,6 +5374,8 @@ interface ResolvedGate extends LicenseGate {
      * branching does not change — but the advice given to the customer differs.
      */
     reason(): string | undefined;
+    /** The signed plan while the license grants (`"measure"` = shadow mode). */
+    plan?(): string | undefined;
     /** Unix seconds after which the online status should be re-checked (poller anchor). */
     refreshAfter?(): number | undefined;
 }
@@ -5060,8 +5391,8 @@ interface ResolvedGate extends LicenseGate {
  * The offline path passes a fresh, never-updated snapshot (live clock, zero
  * network); the online path passes a snapshot a {@link RevocationPoller} feeds.
  */
-declare function liveGateFromKey(licenseKey: string, publicKey: string | LicenseKeyset, opts: {
-    revocation: RevocationSnapshot;
+declare function liveGateFromKey$1(licenseKey: string, publicKey: string | LicenseKeyset, opts: {
+    revocation: RevocationSnapshot$1;
     now?: () => number;
     /** Online staleness ceiling, seconds. If the gate goes this long without a
      *  confirmed authorized heartbeat, it stops granting (closes the block-egress
@@ -5069,7 +5400,7 @@ declare function liveGateFromKey(licenseKey: string, publicKey: string | License
     maxStalenessSeconds?: number;
     /** Freshness anchor (unix seconds); defaults to construction time (boot). */
     startedAt?: number;
-}): ResolvedGate;
+}): ResolvedGate$1;
 
 /**
  * Build the SDK's structural {@link import("../contracts/types.js").LicenseGate}
@@ -5084,9 +5415,9 @@ declare function liveGateFromKey(licenseKey: string, publicKey: string | License
  * Online revocation is added by pairing {@link liveGateFromKey} with a
  * poller-fed snapshot, which `createSavingsLayer` wires up for you.
  */
-declare function gateFromKey(licenseKey: string, publicKey: string | LicenseKeyset, now?: () => number): ResolvedGate;
+declare function gateFromKey$1(licenseKey: string, publicKey: string | LicenseKeyset, now?: () => number): ResolvedGate$1;
 
-type RevocationPollEvent = {
+type RevocationPollEvent$1 = {
     type: "applied";
     seq: number;
     size: number;
@@ -5102,14 +5433,14 @@ type RevocationPollEvent = {
 } | {
     type: "no-fetch";
 };
-interface RevocationPollerOptions {
+interface RevocationPollerOptions$1 {
     /** Absolute URL of GET /licenses/revocations. */
     url: string;
     /** SPKI PEM (or a kid-addressed {@link LicenseKeyset}) used to verify the signed
      *  list — the same key/keyset that verifies license tokens. */
     publicKeyPem: string | LicenseKeyset;
     /** The sticky snapshot to feed. */
-    snapshot: RevocationSnapshot;
+    snapshot: RevocationSnapshot$1;
     /** Anchor cadence to the license refresh horizon (unix seconds). */
     getRefreshAfter?: () => number | undefined;
     /** Injectable clock (unix seconds). */
@@ -5125,7 +5456,7 @@ interface RevocationPollerOptions {
     /** Injectable RNG in [0,1) for jitter. Default Math.random. */
     random?: () => number;
     /** Optional observer (telemetry/tests). */
-    onEvent?: (e: RevocationPollEvent) => void;
+    onEvent?: (e: RevocationPollEvent$1) => void;
     /**
      * Silencia los avisos por consola. Por defecto están ENCENDIDOS, y ese defecto
      * es la corrección: el sondeo es fail-open, así que un call-home roto no rompe
@@ -5147,7 +5478,7 @@ interface RevocationPollerOptions {
  * failure it backs off exponentially (a revocation can't land during an outage
  * anyway), capped, still jittered, never below the floor.
  */
-declare function computeNextDelay(opts: {
+declare function computeNextDelay$1(opts: {
     refreshAfter?: number;
     nowSeconds: number;
     consecutiveFailures: number;
@@ -5157,7 +5488,7 @@ declare function computeNextDelay(opts: {
     jitterRatio: number;
     random?: () => number;
 }): number;
-declare class RevocationPoller {
+declare class RevocationPoller$1 {
     private readonly opts;
     private timer;
     private controller;
@@ -5168,7 +5499,7 @@ declare class RevocationPoller {
     private lastEtag;
     /** 304 seguidos; al llegar al tope se fuerza una descarga firmada. */
     private consecutive304;
-    constructor(opts: RevocationPollerOptions);
+    constructor(opts: RevocationPollerOptions$1);
     private now;
     private resolveFetch;
     /**
@@ -5202,7 +5533,7 @@ declare class RevocationPoller {
     stop(): void;
 }
 
-interface UsageEmitterOptions {
+interface UsageEmitterOptions$1 {
     /** Full ingest URL, e.g. `https://savings.bivelio.com/api/metering/usage`. */
     url: string;
     /** Service-account key (`bvk_…`) sent as a Bearer token; the server derives the org from it. */
@@ -5253,7 +5584,7 @@ interface UsageEmitterOptions {
  * neither block nor crash the customer's request path. The buffer is hard-capped
  * so a sustained outage can never grow memory without bound.
  */
-declare class UsageEmitter {
+declare class UsageEmitter$1 {
     private readonly options;
     private readonly now;
     private readonly flushIntervalMs;
@@ -5271,7 +5602,7 @@ declare class UsageEmitter {
      * only confuse whoever reads the logs.
      */
     private fallosSeguidos;
-    constructor(options: UsageEmitterOptions);
+    constructor(options: UsageEmitterOptions$1);
     /** Set the resolved seat identity (derivation is async; records emitted before
      *  it resolves are stamped at flush time, so none are lost). */
     setSeat(seatId: string | undefined, ci: boolean): void;
@@ -5312,17 +5643,17 @@ declare class UsageEmitter {
 }
 
 /** True when running in a CI / ephemeral environment. */
-declare function detectCi(): boolean;
+declare function detectCi$1(): boolean;
 /**
  * Derive the machine seat id for a service-account key. Resolves to `undefined`
  * when no machine fingerprint is available (e.g. a browser) — the caller then
  * reports no seatId and the server counts the request under an "unknown" seat.
  * The id (`m-<32 hex>`) matches the control plane's identity charset.
  */
-declare function deriveSeatId(serviceAccountKey: string): Promise<string | undefined>;
+declare function deriveSeatId$1(serviceAccountKey: string): Promise<string | undefined>;
 
 /** Fully-resolved, non-optional dependency set the pipeline runs against. */
-interface ResolvedDeps {
+interface ResolvedDeps$1 {
     exactCache: ExactCache;
     semanticCache: InMemorySemanticCache | undefined;
     singleflight: Singleflight;
@@ -5338,9 +5669,9 @@ interface ResolvedDeps {
  * in-memory, dependency-free implementation, so `createSavingsLayer({ provider,
  * tokenizer })` is a working layer, and each piece can be replaced à la carte.
  */
-declare function resolveDependencies(config: SavingsLayerConfig): ResolvedDeps;
+declare function resolveDependencies$1(config: SavingsLayerConfig): ResolvedDeps$1;
 
-declare const DEFAULT_MAX_STALENESS_SECONDS: number;
+declare const DEFAULT_MAX_STALENESS_SECONDS$1: number;
 /** The public handle returned by {@link createSavingsLayer}. */
 interface SavingsLayer {
     generate<T = unknown>(request: SavingsRequest): Promise<SavingsResult<T>>;
@@ -5801,4 +6132,179 @@ declare function toCsv(rows: readonly Readonly<Record<string, CsvValue>>[], opti
     columns?: readonly string[];
 }): string;
 
-export { type AnswerJudge, type AnswerSource, type AnthropicOptions, AnthropicProvider, BV_SALA_VERSION, type BatchCounts, type BatchItemResult, type BatchJob, type BatchJobStatus, type BatchRequest, type BatchResults, BatchSubmitError, type BatchSubmitOptions, type BatchSummary, type BivelioHandoff, CATALOGO, COMPACTION_TRANSFORMS, COMPACT_ROWS_INSTRUCTION, type CacheBreakpointStore, type CacheOutcome, type CachePlacement, type CacheTier, type CacheWriteReport, type CachedAnswer, type CalibrationObservation, CalibrationStateError, type CanonicalRequest, type ChatMessage, type CompactRowsDecodeOptions, type CompactRowsOptions, type CompactVerification, type CompactionTransform, type CompressionEconomics, type CompressionPolicyInput, type CompressionRequest, type CompressionResult, type Compressor, type ConstraintBackend, type ConstraintBackendId, type ConstraintPlan, type ConversationState, type CostBasis, type CostModel, type CsvValue, DEFAULT_COST_MODEL, DEFAULT_MAX_STALENESS_SECONDS, DEFAULT_MIN_SAVED_CHARS, type DeferredExecutionReport, type DeterministicResolver, EMBEDDED_PUBLIC_KEY, type EmbeddingFn, type EvidenceDoc, type ExactCache, ExactTokenizer, type ExecutionClass, ExecutionRouter, type FocusExportOptions, type FocusRow, type FormatChoice, FormatSelector, type FormatSelectorOptions, type HandoffFact, HeuristicEstimator, InMemoryCacheBreakpointStore, InMemoryExactCache, InMemorySemanticCache, InMemoryToolSetFreezer, type JsonSchema, type LangfuseGenerationUpdate, LicenseError, type LicenseGate, type LicenseKeyShape, type LicenseKeyset, type LicenseStatus, type LicenseTokenPayload, type LocalClassifier, MODELOS_POR_CODIFICACION, MODELS_BY_ENCODING, type MemoryDelta, type MessageRole, MockProvider, type MockProviderOptions, type ModelCascadeMode, type ModelCascadeReport, type ModelCascadeSettings, type OpenAICompatibleOptions, OpenAICompatibleProvider, type OutputContract, PRECIOS_AL_DIA, type Policy, type PriceLeverSaving, type PriceLeverSettings, type ProtectedSpan, type Provider, type ProviderRequest, type ProviderResponse, type ProviderStreamEvent, type ProviderStreamOptions, type ProviderToolSearch, type ProviderToolSearchUsage, type ProviderUsage, QUALITY_STATUSES, type QualityCacheMatch, type QualityCascadeCheck, type QualityLedger, type QualityRepairCheck, type QualitySchemaCheck, type QualityStatus, type QualityTruncationCheck, REFERENCE_MAX_AGE_MS, REFERENCE_MESSAGE_ALLOWANCE, REFERENCE_OUTPUT_SHARE, type ReasoningEffort, type ReferenceCredit, type ReferenceRejection, type RequestContext, type Reranker, type ResolvedDeps, type ResolvedGate, type ResolvedLicense, ResolverRegistry, type ResolverResult, type RetrievalOptions, type RetrievalOutcome, type RetrievalPlan, type Retriever, type RevocationListBody, type RevocationListVerification, type RevocationPollEvent, RevocationPoller, type RevocationPollerOptions, RevocationSnapshot, type RouteDecision, type SavingsAdapterLevers, type SavingsAdapterOptions, type SavingsAttributeOptions, type SavingsBatches, type SavingsCallOptions, type SavingsLayer, type SavingsLayerConfig, SavingsLedger, type SavingsRecord, type SavingsReport, type SavingsReportForExport, type SavingsRequest, type SavingsResult, type SavingsSeriesOptions, type SavingsSeriesRow, type SavingsSpanAttributes, type SavingsSpanOptions, type SavingsStream, type SavingsStreamEvent, type SavingsStreamOptions, type SavingsToggles, type SavingsTracingOptions, SchemaRegistry, type SemanticCacheOptions, type SemanticCalibrationBound, type SemanticCalibrationOptions, type SemanticCalibrationSegmentState, type SemanticCalibrationState, type SemanticCalibrationStatus, type SemanticHit, type SemanticLookup, type SemanticProbe, type SemanticRecord, type SemanticVerifier, type SerializationFormat, type Serializer, Singleflight, type SpanAttributeValue, type SpanLike, type SpanStartOptionsLike, StreamAbortedError, type StreamingReport, type TokenEstimator, TokenizerRegistry, type ToolCallRequest, type ToolDescriptor, type ToolOutputCompaction, type ToolOutputCompactionSettings, type ToolRisk, type ToolSearchMode, type ToolSearchOptions, type ToolSelection, ToolSelector, type ToolSelectorOptions, type ToolSetFreezer, TraceCollector, type TraceEvent, type TracerLike, type TracerProviderLike, UMBRAL_LOCAL, UsageEmitter, type UsageEmitterOptions, type ValidationError, type ValidationResult, type VerificationCheck, type VerificationExclusion, type VerificationOutcome, type VerificationReport, type VerificationSettings, type VerificationSide, type VerificationStratum, adaptiveK, arithmeticResolver, buildExactKey, buildInflightKey, calibrateSemanticFloor, canonicalize, compactRowsSerializer, compactToolOutput, compresionFiel, computeNextDelay, cosine, createCompactRowsSerializer, createDefaultResolvers, createHandoff, createMockProvider, createSavingsLayer, csvSerializer, decodeCompactRows, dedupe, defaultTokenizerRegistry, deriveSeatId, deriveStatus, detectCi, embebedorLocal, emptyState, encodeCompactRows, evalArithmetic, evaluatePolicy, executeRetrievalPlan, gateFromKey, heuristicEstimator, instrumentSavingsLayer, isKeyset, isStrictCompatible, jsonCompactSerializer, keyTokensMatch, licenseKeyShape, liveGateFromKey, mergeDelta, modelFamilyOf, multisetEqual, negationCount, noopCompressor, normalizeLicenseKey, normalizeText, numericTokens, precioDeLista, projectContext, providerNativeBackend, quitarPrefijoDeProveedor, randomId, recordSavingsOnSpan, registerExactTokenizer, registrarTokenizadorExacto, renderState, resolveConstraintBackend, resolveDependencies, resolveLicense, sameAnswer, savingsSpanAttributes, sha256, shouldCompress, stableStringify, toCsv, toFocusRows, toLangfuseGeneration, toSavingsSeries, uniformColumns, validateAgainstSchema, vectorLocal, verifyCompactSignature, verifyLicenseToken, verifyRevocationList, withProtectedSpans, words };
+/** @deprecated Internal pipeline helper, removed from the public API in 0.5: no replacement. */
+type CanonicalRequest = CanonicalRequest$1;
+/** @deprecated Internal pipeline helper, removed from the public API in 0.5: no replacement. */
+declare const canonicalize: typeof canonicalize$1;
+/** @deprecated Internal pipeline helper, removed from the public API in 0.5: no replacement. */
+declare const modelFamilyOf: typeof modelFamilyOf$1;
+/** @deprecated Internal pipeline helper, removed from the public API in 0.5: no replacement. */
+declare const normalizeText: typeof normalizeText$1;
+/** @deprecated Internal helper, removed from the public API in 0.5. Use `createHash("sha256").update(text).digest("hex")` from `node:crypto`. */
+declare const sha256: typeof sha256$1;
+/** @deprecated Internal pipeline helper, removed from the public API in 0.5: no replacement. */
+declare const stableStringify: typeof stableStringify$1;
+/** @deprecated Internal pipeline helper, removed from the public API in 0.5: no replacement. */
+declare const buildExactKey: typeof buildExactKey$1;
+/** @deprecated Internal pipeline helper, removed from the public API in 0.5: no replacement. */
+declare const buildInflightKey: typeof buildInflightKey$1;
+/** @deprecated Internal license machinery, removed from the public API in 0.5: no replacement. In the published package a license enters only through `licenseKey` / `serviceAccountKey`. */
+type CompactVerification = CompactVerification$1;
+/** @deprecated Internal license machinery, removed from the public API in 0.5: no replacement. In the published package a license enters only through `licenseKey` / `serviceAccountKey`. */
+declare const EMBEDDED_PUBLIC_KEY: typeof EMBEDDED_PUBLIC_KEY$1;
+/** @deprecated Internal license machinery, removed from the public API in 0.5: no replacement. In the published package a license enters only through `licenseKey` / `serviceAccountKey`. */
+type LicenseKeyShape = LicenseKeyShape$1;
+/** @deprecated Internal license machinery, removed from the public API in 0.5: no replacement. In the published package a license enters only through `licenseKey` / `serviceAccountKey`. */
+type LicenseStatus = LicenseStatus$1;
+/** @deprecated Internal license machinery, removed from the public API in 0.5: no replacement. In the published package a license enters only through `licenseKey` / `serviceAccountKey`. */
+type LicenseTokenPayload = LicenseTokenPayload$1;
+/** @deprecated Internal license machinery, removed from the public API in 0.5: no replacement. In the published package a license enters only through `licenseKey` / `serviceAccountKey`. */
+type ResolvedGate = ResolvedGate$1;
+/** @deprecated Internal license machinery, removed from the public API in 0.5: no replacement. In the published package a license enters only through `licenseKey` / `serviceAccountKey`. */
+type ResolvedLicense = ResolvedLicense$1;
+/** @deprecated Internal license machinery, removed from the public API in 0.5: no replacement. In the published package a license enters only through `licenseKey` / `serviceAccountKey`. */
+type RevocationListBody = RevocationListBody$1;
+/** @deprecated Internal license machinery, removed from the public API in 0.5: no replacement. In the published package a license enters only through `licenseKey` / `serviceAccountKey`. */
+type RevocationListVerification = RevocationListVerification$1;
+/** @deprecated Internal license machinery, removed from the public API in 0.5: no replacement. In the published package a license enters only through `licenseKey` / `serviceAccountKey`. */
+type RevocationPollEvent = RevocationPollEvent$1;
+/** @deprecated Internal license machinery, removed from the public API in 0.5: no replacement. In the published package a license enters only through `licenseKey` / `serviceAccountKey`. */
+declare const RevocationPoller: typeof RevocationPoller$1;
+/** @deprecated Internal license machinery, removed from the public API in 0.5: no replacement. In the published package a license enters only through `licenseKey` / `serviceAccountKey`. */
+type RevocationPoller = RevocationPoller$1;
+/** @deprecated Internal license machinery, removed from the public API in 0.5: no replacement. In the published package a license enters only through `licenseKey` / `serviceAccountKey`. */
+type RevocationPollerOptions = RevocationPollerOptions$1;
+/** @deprecated Internal license machinery, removed from the public API in 0.5: no replacement. In the published package a license enters only through `licenseKey` / `serviceAccountKey`. */
+declare const RevocationSnapshot: typeof RevocationSnapshot$1;
+/** @deprecated Internal license machinery, removed from the public API in 0.5: no replacement. In the published package a license enters only through `licenseKey` / `serviceAccountKey`. */
+type RevocationSnapshot = RevocationSnapshot$1;
+/** @deprecated Internal license machinery, removed from the public API in 0.5: no replacement. In the published package a license enters only through `licenseKey` / `serviceAccountKey`. */
+declare const computeNextDelay: typeof computeNextDelay$1;
+/** @deprecated Internal license machinery, removed from the public API in 0.5: no replacement. In the published package a license enters only through `licenseKey` / `serviceAccountKey`. */
+declare const deriveStatus: typeof deriveStatus$1;
+/** @deprecated Internal license machinery, removed from the public API in 0.5: no replacement. In the published package a license enters only through `licenseKey` / `serviceAccountKey`. */
+declare const gateFromKey: typeof gateFromKey$1;
+/** @deprecated Internal license machinery, removed from the public API in 0.5: no replacement. In the published package a license enters only through `licenseKey` / `serviceAccountKey`. */
+declare const isKeyset: typeof isKeyset$1;
+/** @deprecated Internal license machinery, removed from the public API in 0.5: no replacement. In the published package a license enters only through `licenseKey` / `serviceAccountKey`. */
+declare const licenseKeyShape: typeof licenseKeyShape$1;
+/** @deprecated Internal license machinery, removed from the public API in 0.5: no replacement. In the published package a license enters only through `licenseKey` / `serviceAccountKey`. */
+declare const liveGateFromKey: typeof liveGateFromKey$1;
+/** @deprecated Internal license machinery, removed from the public API in 0.5: no replacement. In the published package a license enters only through `licenseKey` / `serviceAccountKey`. */
+declare const normalizeLicenseKey: typeof normalizeLicenseKey$1;
+/** @deprecated Internal license machinery, removed from the public API in 0.5: no replacement. In the published package a license enters only through `licenseKey` / `serviceAccountKey`. */
+declare const resolveLicense: typeof resolveLicense$1;
+/** @deprecated Internal license machinery, removed from the public API in 0.5: no replacement. In the published package a license enters only through `licenseKey` / `serviceAccountKey`. */
+declare const verifyCompactSignature: typeof verifyCompactSignature$1;
+/** @deprecated Internal license machinery, removed from the public API in 0.5: no replacement. In the published package a license enters only through `licenseKey` / `serviceAccountKey`. */
+declare const verifyLicenseToken: typeof verifyLicenseToken$1;
+/** @deprecated Internal license machinery, removed from the public API in 0.5: no replacement. In the published package a license enters only through `licenseKey` / `serviceAccountKey`. */
+declare const verifyRevocationList: typeof verifyRevocationList$1;
+/** @deprecated Internal license machinery, removed from the public API in 0.5: no replacement. In the published package a license enters only through `licenseKey` / `serviceAccountKey`. */
+declare const UsageEmitter: typeof UsageEmitter$1;
+/** @deprecated Internal license machinery, removed from the public API in 0.5: no replacement. In the published package a license enters only through `licenseKey` / `serviceAccountKey`. */
+type UsageEmitter = UsageEmitter$1;
+/** @deprecated Internal license machinery, removed from the public API in 0.5: no replacement. In the published package a license enters only through `licenseKey` / `serviceAccountKey`. */
+type UsageEmitterOptions = UsageEmitterOptions$1;
+/** @deprecated Internal license machinery, removed from the public API in 0.5: no replacement. In the published package a license enters only through `licenseKey` / `serviceAccountKey`. */
+declare const deriveSeatId: typeof deriveSeatId$1;
+/** @deprecated Internal license machinery, removed from the public API in 0.5: no replacement. In the published package a license enters only through `licenseKey` / `serviceAccountKey`. */
+declare const detectCi: typeof detectCi$1;
+/** @deprecated Internal constant, removed from the public API in 0.5. The default is documented on `licenseRevocation.maxStalenessSeconds`; set that option to change it. */
+declare const DEFAULT_MAX_STALENESS_SECONDS: typeof DEFAULT_MAX_STALENESS_SECONDS$1;
+/** @deprecated Internal pipeline helper, removed from the public API in 0.5: no replacement. */
+type ResolvedDeps = ResolvedDeps$1;
+/** @deprecated Internal pipeline helper, removed from the public API in 0.5: no replacement. */
+declare const resolveDependencies: typeof resolveDependencies$1;
+/** @deprecated Internal constant of the reference-commission rule, removed from the public API in 0.5: no replacement (the rule is described in the documentation, not frozen as API). */
+declare const REFERENCE_MAX_AGE_MS: typeof REFERENCE_MAX_AGE_MS$1;
+/** @deprecated Internal constant of the reference-commission rule, removed from the public API in 0.5: no replacement (the rule is described in the documentation, not frozen as API). */
+declare const REFERENCE_MESSAGE_ALLOWANCE: typeof REFERENCE_MESSAGE_ALLOWANCE$1;
+/** @deprecated Internal constant of the reference-commission rule, removed from the public API in 0.5: no replacement (the rule is described in the documentation, not frozen as API). */
+declare const REFERENCE_OUTPUT_SHARE: typeof REFERENCE_OUTPUT_SHARE$1;
+/** @deprecated Internal ledger of the pipeline, removed from the public API in 0.5. Read the four ledgers from the `SavingsReport` each call returns. */
+declare const SavingsLedger: typeof SavingsLedger$1;
+/** @deprecated Internal ledger of the pipeline, removed from the public API in 0.5. Read the four ledgers from the `SavingsReport` each call returns. */
+type SavingsLedger = SavingsLedger$1;
+/** @deprecated Internal pipeline helper, removed from the public API in 0.5. Read the stage traces from `report.traces`. */
+declare const TraceCollector: typeof TraceCollector$1;
+/** @deprecated Internal pipeline helper, removed from the public API in 0.5. Read the stage traces from `report.traces`. */
+type TraceCollector = TraceCollector$1;
+/** @deprecated Internal pipeline helper, removed from the public API in 0.5: no replacement. */
+declare const adaptiveK: typeof adaptiveK$1;
+/** @deprecated Internal pipeline helper, removed from the public API in 0.5: no replacement. */
+declare const dedupe: typeof dedupe$1;
+/** @deprecated Internal pipeline helper, removed from the public API in 0.5: no replacement. */
+declare const executeRetrievalPlan: typeof executeRetrievalPlan$1;
+/** @deprecated Internal pipeline helper, removed from the public API in 0.5: no replacement. */
+declare const cosine: typeof cosine$1;
+/** @deprecated Internal pipeline helper, removed from the public API in 0.5: no replacement. */
+declare const keyTokensMatch: typeof keyTokensMatch$1;
+/** @deprecated Internal pipeline helper, removed from the public API in 0.5: no replacement. */
+declare const multisetEqual: typeof multisetEqual$1;
+/** @deprecated Internal pipeline helper, removed from the public API in 0.5: no replacement. */
+declare const negationCount: typeof negationCount$1;
+/** @deprecated Internal pipeline helper, removed from the public API in 0.5: no replacement. */
+declare const numericTokens: typeof numericTokens$1;
+/** @deprecated Internal pipeline helper, removed from the public API in 0.5: no replacement. */
+declare const words: typeof words$1;
+/** @deprecated Internal pipeline helper, removed from the public API in 0.5: no replacement. */
+declare const sameAnswer: typeof sameAnswer$1;
+/** @deprecated Internal helper, removed from the public API in 0.5. Arithmetic questions are still answered locally by `arithmeticResolver` / `createDefaultResolvers()`. */
+declare const evalArithmetic: typeof evalArithmetic$1;
+/** @deprecated Internal pipeline helper, removed from the public API in 0.5: no replacement. */
+declare const evaluatePolicy: typeof evaluatePolicy$1;
+/** @deprecated Internal pipeline helper, removed from the public API in 0.5: no replacement. */
+declare const isStrictCompatible: typeof isStrictCompatible$1;
+/** @deprecated Internal pipeline helper, removed from the public API in 0.5: no replacement. */
+declare const projectContext: typeof projectContext$1;
+/** @deprecated Internal pipeline helper, removed from the public API in 0.5: no replacement. */
+declare const resolveConstraintBackend: typeof resolveConstraintBackend$1;
+/** @deprecated Internal pipeline helper, removed from the public API in 0.5: no replacement. */
+declare const shouldCompress: typeof shouldCompress$1;
+/** @deprecated Internal pipeline helper, removed from the public API in 0.5: no replacement. */
+declare const withProtectedSpans: typeof withProtectedSpans$1;
+/** @deprecated Internal pipeline helper, removed from the public API in 0.5: no replacement. */
+declare const uniformColumns: typeof uniformColumns$1;
+/** @deprecated Internal helper, removed from the public API in 0.5. Use `crypto.randomUUID()`. */
+declare const randomId: typeof randomId$1;
+
+/**
+ * bivelio-savings-layer (BV-SALA)
+ * ---------------------------------------------------------------------------
+ * PROPRIETARY AND CONFIDENTIAL. Copyright (c) 2026 BiVelio Inc.
+ * All Rights Reserved. Unauthorized copying, distribution, or use of this
+ * software, in whole or in part, is strictly prohibited. See LICENSE.
+ * ---------------------------------------------------------------------------
+ *
+ * A provider-neutral LLM execution optimizer. For every request it answers, in
+ * order: Can I avoid this call? Can I avoid retrieval? Can I send fewer tools?
+ * What context is actually needed? Should I compress it? Which format costs
+ * least for this tokenizer? What is the minimal output contract? Is the saving
+ * still positive after all infrastructure is counted?
+ *
+ * It keeps FOUR separate ledgers — avoided_calls, eliminated_tokens,
+ * compressed_tokens, provider_cached_tokens — because mixing them produces
+ * misleading metrics.
+ */
+
+/**
+ * The list-price catalogue: model id (without vendor prefix) → USD per 1K
+ * tokens. `costModels` on the layer config always wins over it.
+ */
+declare const PRICE_CATALOG: typeof CATALOGO$1;
+/**
+ * The list price for a model on the day of the request, or `undefined` when the
+ * catalogue has no price for it in force that day.
+ */
+declare const listPrice: typeof precioDeLista$1;
+/** When the catalogue prices were last checked against the providers' public rates (YYYY-MM-DD). */
+declare const PRICES_AS_OF: typeof PRECIOS_AL_DIA$1;
+/** @deprecated Spanish name, removed in 0.5. Use {@link PRICE_CATALOG}. */
+declare const CATALOGO: typeof CATALOGO$1;
+/** @deprecated Spanish name, removed in 0.5. Use {@link listPrice}. */
+declare const precioDeLista: typeof precioDeLista$1;
+/** @deprecated Spanish name, removed in 0.5. Use {@link PRICES_AS_OF}. */
+declare const PRECIOS_AL_DIA: typeof PRECIOS_AL_DIA$1;
+
+export { type AnswerJudge, type AnswerSource, type AnthropicOptions, AnthropicProvider, BV_SALA_VERSION, type BatchCounts, type BatchItemResult, type BatchJob, type BatchJobStatus, type BatchRequest, type BatchResults, BatchSubmitError, type BatchSubmitOptions, type BatchSummary, type BivelioHandoff, CATALOGO, COMPACTION_TRANSFORMS, COMPACT_ROWS_INSTRUCTION, type CacheBreakpointStore, type CacheOutcome, type CachePlacement, type CacheTier, type CacheWriteReport, type CachedAnswer, type CalibrationObservation, CalibrationStateError, type CanonicalRequest, type ChatMessage, type CompactRowsDecodeOptions, type CompactRowsOptions, type CompactVerification, type CompactionTransform, type CompressionEconomics, type CompressionPolicyInput, type CompressionRequest, type CompressionResult, type Compressor, type ConstraintBackend, type ConstraintBackendId, type ConstraintPlan, type ConversationState, type CostBasis, type CostModel, type CsvValue, DEFAULT_COST_MODEL, DEFAULT_MAX_STALENESS_SECONDS, DEFAULT_MIN_SAVED_CHARS, type DeferredExecutionReport, type DeterministicResolver, EMBEDDED_PUBLIC_KEY, type EmbeddingFn, type EvidenceDoc, type ExactCache, ExactTokenizer, type ExecutionClass, ExecutionRouter, type FocusExportOptions, type FocusRow, type FormatChoice, FormatSelector, type FormatSelectorOptions, type GoogleOptions, GoogleProvider, type GoogleThinkingConfig, type HandoffFact, HeuristicEstimator, InMemoryCacheBreakpointStore, InMemoryExactCache, InMemorySemanticCache, InMemoryToolSetFreezer, type JsonSchema, LOCAL_EMBEDDING_THRESHOLD, type LangfuseGenerationUpdate, LicenseError, type LicenseGate, type LicenseKeyShape, type LicenseKeyset, type LicenseStatus, type LicenseTokenPayload, type LocalClassifier, MODELOS_POR_CODIFICACION, MODELS_BY_ENCODING, type MeasureReport, type MemoryDelta, type MessageRole, MockProvider, type MockProviderOptions, type ModelCascadeMode, type ModelCascadeReport, type ModelCascadeSettings, type NativeSavingsReport, type OpenAICompatibleOptions, OpenAICompatibleProvider, type OutputContract, PRECIOS_AL_DIA, PRICES_AS_OF, PRICE_CATALOG, type Policy, type PriceLeverSaving, type PriceLeverSettings, type ProtectedSpan, type Provider, type ProviderRequest, type ProviderResponse, type ProviderStreamEvent, type ProviderStreamOptions, type ProviderToolSearch, type ProviderToolSearchUsage, type ProviderUsage, QUALITY_STATUSES, type QualityCacheMatch, type QualityCascadeCheck, type QualityLedger, type QualityRepairCheck, type QualitySchemaCheck, type QualityStatus, type QualityTruncationCheck, REFERENCE_MAX_AGE_MS, REFERENCE_MESSAGE_ALLOWANCE, REFERENCE_OUTPUT_SHARE, type ReasoningEffort, type ReferenceCredit, type ReferenceRejection, type RequestContext, type Reranker, type ResolvedDeps, type ResolvedGate, type ResolvedLicense, ResolverRegistry, type ResolverResult, type RetrievalOptions, type RetrievalOutcome, type RetrievalPlan, type Retriever, type RevocationListBody, type RevocationListVerification, type RevocationPollEvent, RevocationPoller, type RevocationPollerOptions, RevocationSnapshot, type RouteDecision, type SavingsAdapterLevers, type SavingsAdapterOptions, type SavingsAttributeOptions, type SavingsBatches, type SavingsCallOptions, type SavingsLayer, type SavingsLayerConfig, SavingsLedger, type SavingsRecord, type SavingsReport, type SavingsReportForExport, type SavingsRequest, type SavingsResult, type SavingsSeriesOptions, type SavingsSeriesRow, type SavingsSpanAttributes, type SavingsSpanOptions, type SavingsStream, type SavingsStreamEvent, type SavingsStreamOptions, type SavingsToggles, type SavingsTracingOptions, SchemaRegistry, type SemanticCacheOptions, type SemanticCalibrationBound, type SemanticCalibrationOptions, type SemanticCalibrationSegmentState, type SemanticCalibrationState, type SemanticCalibrationStatus, type SemanticHit, type SemanticLookup, type SemanticProbe, type SemanticRecord, type SemanticVerifier, type SerializationFormat, type Serializer, Singleflight, type SpanAttributeValue, type SpanLike, type SpanStartOptionsLike, StreamAbortedError, type StreamingReport, type TokenEstimator, TokenizerRegistry, type ToolCallRequest, type ToolDescriptor, type ToolOutputCompaction, type ToolOutputCompactionSettings, type ToolRisk, type ToolSearchMode, type ToolSearchOptions, type ToolSelection, ToolSelector, type ToolSelectorOptions, type ToolSetFreezer, TraceCollector, type TraceEvent, type TracerLike, type TracerProviderLike, UMBRAL_LOCAL, UsageEmitter, type UsageEmitterOptions, type ValidationError, type ValidationResult, type VerificationCheck, type VerificationExclusion, type VerificationOutcome, type VerificationReport, type VerificationSettings, type VerificationSide, type VerificationStratum, adaptiveK, arithmeticResolver, buildExactKey, buildInflightKey, calibrateSemanticFloor, canonicalize, compactRowsSerializer, compactToolOutput, compresionFiel, computeNextDelay, cosine, createCompactRowsSerializer, createDefaultResolvers, createHandoff, createMockProvider, createSavingsLayer, csvSerializer, decodeCompactRows, dedupe, defaultTokenizerRegistry, deriveSeatId, deriveStatus, detectCi, embebedorLocal, emptyState, encodeCompactRows, evalArithmetic, evaluatePolicy, executeRetrievalPlan, gateFromKey, heuristicEstimator, instrumentSavingsLayer, isKeyset, isStrictCompatible, jsonCompactSerializer, keyTokensMatch, licenseKeyShape, listPrice, liveGateFromKey, localEmbedding, mergeDelta, modelFamilyOf, multisetEqual, negationCount, noopCompressor, normalizeLicenseKey, normalizeText, numericTokens, precioDeLista, projectContext, providerNativeBackend, quitarPrefijoDeProveedor, randomId, recordSavingsOnSpan, registerExactTokenizer, registrarTokenizadorExacto, renderState, resolveConstraintBackend, resolveDependencies, resolveLicense, sameAnswer, savingsSpanAttributes, sha256, shouldCompress, stableStringify, toCsv, toFocusRows, toLangfuseGeneration, toSavingsSeries, uniformColumns, validateAgainstSchema, vectorLocal, verifyCompactSignature, verifyLicenseToken, verifyRevocationList, withProtectedSpans, words };