@bivelio/savings-layer 0.4.31 → 0.4.33

package/dist/index.d.ts

@@ -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.31";
+declare const BV_SALA_VERSION = "0.4.33";
 
 /**
  * Environment-agnostic UUID generation.
@@ -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;
     /**
@@ -1107,6 +1125,23 @@ interface SavingsRequest {
     /** Sampling controls that participate in the exact-cache key. */
     temperature?: number;
     seed?: number;
+    /**
+     * How hard a reasoning model should think, sent as OpenAI's `reasoning_effort`
+     * by the OpenAI-compatible adapter (`"none"`, `"minimal"`, `"low"`,
+     * `"medium"`, `"high"`, `"xhigh"`; the value travels as written). Nothing is
+     * sent when absent: the layer never picks an effort for you.
+     *
+     * Required for the gpt-5.6 family with tools on Chat Completions: OpenAI
+     * rejects function tools there unless it is `"none"` («Function tools with
+     * reasoning_effort are not supported for gpt-5.6-sol in
+     * /v1/chat/completions … set reasoning_effort to 'none'»). Gemini's
+     * OpenAI-compatible endpoint maps it to its thinking level. A compatible
+     * endpoint that rejects the field by name gets the request once more without
+     * it (OpenAI's own API never: there its 400 is the answer). It is part of the
+     * cache identity, like `temperature` and `seed`. The Anthropic adapter
+     * ignores it.
+     */
+    reasoningEffort?: ReasoningEffort;
     /**
      * Hard ceiling on generated tokens for this request, with or without an
      * output contract. It travels to every adapter: Anthropic `max_tokens`,
@@ -1126,11 +1161,22 @@ interface SavingsRequest {
     structuredData?: unknown;
 }
 /** A tool invocation the model requested (the provider-neutral shape). */
+/** OpenAI's `reasoning_effort` values; any other string travels as written. */
+type ReasoningEffort = "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | (string & {});
 interface ToolCallRequest {
     id?: string;
     name: string;
     /** Argumentos tal cual los serializó el modelo (JSON en crudo). */
     arguments: string;
+    /**
+     * Provider data attached to this call that must travel back, untouched, when
+     * the conversation returns it: Gemini 3's
+     * `extra_content.google.thought_signature` through its OpenAI-compatible
+     * endpoint, without which the next turn is rejected with a 400 («Function
+     * call is missing a thought_signature»). Opaque: pass it back as received in
+     * the assistant message's `toolCalls`. It is not part of any cache key.
+     */
+    extraContent?: Record<string, unknown>;
 }
 /** Result returned to the caller. */
 interface SavingsResult<T = unknown> {
@@ -1155,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
@@ -1463,6 +1531,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;
     /**
@@ -1585,6 +1711,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;
     /**
@@ -1608,7 +1745,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.
@@ -1666,6 +1825,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[];
 }
@@ -1716,6 +1881,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;
@@ -1920,6 +2129,8 @@ interface CanonicalRequest {
     contractId: string | null;
     temperature: number | null;
     seed: number | null;
+    /** `reasoning_effort` declared by the caller; absent when it declared none. */
+    reasoningEffort?: string;
     tenantId: string;
     authorizationScope: string;
     /**
@@ -2198,6 +2409,8 @@ interface SemanticRecord {
     temperature: number | null;
     /** Sampling seed of the request, or null when it set none. */
     seed: number | null;
+    /** `reasoning_effort` of the request; absent when it declared none. */
+    reasoningEffort?: string;
     storedAtMs: number;
     /**
      * With calibration on: the highest score at which this stored answer was
@@ -2582,17 +2795,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;
@@ -2860,6 +3078,8 @@ 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;
 
@@ -3050,6 +3270,12 @@ interface ProviderRequest {
     maxOutputTokens?: number;
     temperature?: number;
     seed?: number;
+    /**
+     * `SavingsRequest.reasoningEffort`, as the caller declared it. The
+     * OpenAI-compatible adapter sends it as `reasoning_effort`; absent means
+     * nothing is sent.
+     */
+    reasoningEffort?: string;
     /** Backend id selected by the constraints layer, for observability. */
     constraintBackend?: string;
     /**
@@ -3061,6 +3287,9 @@ interface ProviderRequest {
      * boundary; adapters that cache automatically (OpenAI) may ignore it. The
      * count is a claim about byte-for-byte stability, so a caller that rewrites an
      * earlier turn must lower it.
+     *
+     * `0` claims only what renders BEFORE the messages: the tool catalogue. The
+     * Anthropic adapter then marks the end of the `tools` block (its last tool).
      */
     stablePrefixMessages?: number;
     /**
@@ -3225,6 +3454,17 @@ interface ProviderResponse {
      * podía distinguirlo y hacía exactamente eso.
      */
     finishReason?: "stop" | "length" | "content_filter" | "tool_calls" | (string & {});
+    /**
+     * The provider's own reason behind `finishReason`, when it gave one: Gemini's
+     * 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"`. 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;
     /**
      * The refusal message the model returned INSTEAD of an answer, exactly as the
      * provider wrote it: OpenAI's `message.refusal` (Chat Completions with
@@ -3390,6 +3630,9 @@ 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;
@@ -3544,6 +3787,18 @@ 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`);
+     * when both are given, `semanticCacheStore` wins. Removed in 0.5: see the 0.5
+     * migration guide.
      */
     semanticCache?: InMemorySemanticCache;
     /**
@@ -3551,7 +3806,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
@@ -3673,6 +3928,9 @@ 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. Removed from the public type in 0.5.
      */
     licensePublicKey?: string | LicenseKeyset;
     /**
@@ -3681,6 +3939,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;
     /**
@@ -3799,6 +4060,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.
      */
     devUnlicensed?: boolean;
     /** Per-model cost models; falls back to `defaultCostModel`. */
@@ -4361,6 +4625,13 @@ interface Policy {
      * así que sin esto "hour" y "day" no significaban nada operativamente.
      */
     maxCacheAgeMs: number | null;
+    /**
+     * The user turns touch a sensitive topic (self-harm or suicide, a mental
+     * health crisis, a medical emergency), or null. With a topic, neither the
+     * exact nor the semantic cache is used and no reference record is left: the
+     * answer is measured and served, never replayed or credited as a saving.
+     */
+    sensitiveTopic: "self-harm" | "mental-health-crisis" | "medical-emergency" | null;
     reasons: string[];
 }
 declare function evaluatePolicy(c: CanonicalRequest): Policy;
@@ -4402,6 +4673,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[];
 /**
@@ -4410,6 +4684,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.
@@ -4420,6 +4696,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;
 
 /**
@@ -4610,6 +4888,21 @@ declare function createMockProvider(options?: MockProviderOptions): Provider;
  * `constraints.backend: "none"` rather than claiming a guarantee the provider
  * never gave.
  *
+ * OpenAI-only request fields are sent only to OpenAI's own API
+ * (`prompt_cache_key`, see {@link OpenAICompatibleOptions.sendPromptCacheKey}).
+ * An optional field an endpoint still rejects by name with a 400/422
+ * (`prompt_cache_key`, `service_tier`, `seed`) is dropped and the request
+ * repeated once, and the model is remembered, as with `response_format`.
+ *
+ * Output is counted as the provider bills it: where `total_tokens` exceeds
+ * `prompt_tokens + completion_tokens` (Gemini's OpenAI-compatible endpoint
+ * leaves its thinking tokens out of `completion_tokens`), the difference is
+ * added to the output and reported as reasoning. Against OpenAI's own API,
+ * whose `completion_tokens` already include reasoning, nothing is added. A
+ * content-filter stop with a reason (Gemini's `"content_filter: OTHER"`) is
+ * reported as `finishReason: "content_filter"`, the reason in
+ * `finishReasonDetail`.
+ *
  * Network calls use global `fetch` (Node >= 18) so there is no SDK dependency.
  */
 interface OpenAICompatibleOptions {
@@ -4619,8 +4912,11 @@ interface OpenAICompatibleOptions {
      * Strip the `provider/` prefix from model ids before sending (`openai/gpt-4o-mini`
      * → `gpt-4o-mini`).
      *
-     * Default (undefined): strip when `baseUrl` is OpenAI's own API or an Azure
-     * OpenAI endpoint, keep otherwise. OpenAI rejects a prefixed id with a 404
+     * Default (undefined): strip when `baseUrl` is OpenAI's own API, an Azure
+     * OpenAI endpoint or Google's own Gemini API
+     * (https://generativelanguage.googleapis.com, whose OpenAI-compatible
+     * endpoint answers 404 «models/google/gemini-… is not found» to a prefixed
+     * id), keep otherwise. OpenAI rejects a prefixed id with a 404
      * ("model does not exist"), so the qualified ids the layer uses everywhere
      * else — pricing, cache keys, the report — would break the very first call
      * that reaches the provider. A gateway or a self-hosted server with a
@@ -4660,6 +4956,20 @@ interface OpenAICompatibleOptions {
      * explicit value always wins and is never switched.
      */
     maxTokensParam?: "max_tokens" | "max_completion_tokens";
+    /**
+     * Whether to send `prompt_cache_key`, the routing hint OpenAI uses to land
+     * requests that share a prefix on the same cache instance.
+     *
+     * Default (undefined): only when `baseUrl` is OpenAI's own API
+     * (https://api.openai.com). The field is OpenAI's, and strict endpoints
+     * reject what they do not know: Gemini's OpenAI-compatible endpoint answers
+     * 400 «Unknown name "prompt_cache_key"», so from 0.4.1 to 0.4.31 every
+     * request with a cached prefix failed there. Set `true` for a proxy or router
+     * in front of OpenAI that forwards it (if the endpoint rejects it anyway,
+     * the request is repeated once without it and the model is remembered), or
+     * `false` to never send it.
+     */
+    sendPromptCacheKey?: boolean;
 }
 /**
  * ¿Cumple este esquema las reglas del modo `strict` de OpenAI?
@@ -4677,9 +4987,12 @@ interface OpenAICompatibleOptions {
 declare function isStrictCompatible(schema: unknown): boolean;
 /**
  * Decides the id that travels on the wire. Explicit option wins; otherwise the
- * endpoint decides: OpenAI/Azure get the bare id, everything else keeps what
- * the caller wrote. Exported for the pipeline-level test that pins the README
+ * 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 {
@@ -4690,6 +5003,7 @@ declare class OpenAICompatibleProvider implements Provider {
     private readonly sinResponseFormat;
     private streamOptionsRejected;
     private readonly campoDeTopeAprendido;
+    private readonly camposRechazados;
     private readonly origen;
     constructor(opts: OpenAICompatibleOptions);
     generate(req: ProviderRequest, options?: ProviderStreamOptions): Promise<ProviderResponse>;
@@ -4705,6 +5019,8 @@ declare class OpenAICompatibleProvider implements Provider {
     generateStream(req: ProviderRequest, options?: ProviderStreamOptions): AsyncGenerator<ProviderStreamEvent, void, undefined>;
     private campoDeTope;
     private corregirCampoDeTope;
+    private corregirCampoOpcional;
+    private campoAdmitido;
     private enviar;
     private construirCuerpo;
     /** Translate a 2xx endpoint response into the provider-neutral shape. */
@@ -4808,6 +5124,8 @@ declare class AnthropicProvider implements Provider {
     private readonly opts;
     private readonly fetchImpl;
     private readonly busquedas;
+    private readonly sinToolChoiceForzado;
+    private readonly sinMuestreo;
     constructor(opts?: AnthropicOptions);
     /** The id Anthropic's API sees: bare at `api.anthropic.com`, as written elsewhere. */
     private modeloEnElCable;
@@ -4822,6 +5140,7 @@ declare class AnthropicProvider implements Provider {
      * as one text event.
      */
     generateStream(req: ProviderRequest, options?: ProviderStreamOptions): AsyncGenerator<ProviderStreamEvent, void, undefined>;
+    private enviarConCorrecciones;
     private enviar;
     private construirCuerpo;
     private reenvioDeBusquedas;
@@ -4833,6 +5152,95 @@ 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
@@ -4950,6 +5358,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;
 }
@@ -5706,4 +6116,42 @@ 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 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 };
+/**
+ * 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 };