@bivelio/savings-layer 0.3.1 → 0.4.1

package/README.md

@@ -1,31 +1,61 @@
-# @bivelio/savings-layer — BV‑SALA
+# BV‑SALA — the savings layer for your LLM bill
 
-**A provider‑neutral LLM execution optimizer.** BV‑SALA sits in front of any LLM
-provider and, for every request, picks the **cheapest execution that still meets
-your quality bar** — then hands you a full, auditable `SavingsReport`.
+<p align="center">
+  <img src="https://savings.bivelio.com/en/how-it-works/opengraph-image" alt="Your application → BV-SALA → provider API. The bill drops from $330 to $160 a month, measured." width="720">
+</p>
 
-It is **not** a prompt compressor. Compression is the *fourth* thing it tries, not
-the first.
+<p align="center">
+  <a href="https://www.npmjs.com/package/@bivelio/savings-layer"><img src="https://img.shields.io/npm/v/%40bivelio%2Fsavings-layer?color=2F63D8&label=npm" alt="npm version"></a>
+  <img src="https://img.shields.io/badge/node-%E2%89%A520-14A06F" alt="Node ≥ 20">
+  <img src="https://img.shields.io/badge/license-commercial-0F1218" alt="Commercial license">
+</p>
+
+**One layer inside your code, right where your app calls the OpenAI or Anthropic API.**
+For every request it picks the cheapest execution that still meets your quality bar —
+avoiding calls that don't need to happen and trimming what must be sent — and hands
+you an auditable `SavingsReport`. Your bill drops, and you can verify why.
 
 > **Commercial software — © 2026 BiVelio Inc.** Free to install, **paid to run**:
-> BV‑SALA is **fail‑closed** and executes only with a valid, active BiVelio license
-> key. Verification is **offline** (no phone‑home to answer a request) and **your
-> prompts never leave your infrastructure** — only counts and cost are ever reported.
-> Use is governed by the [LICENSE](./LICENSE) and the BiVelio Terms. Not affiliated
-> with, and not a wrapper around, any third‑party library.
+> BV‑SALA is fail‑closed and executes only with an active BiVelio license key.
+> License checks are **offline** and **your prompts never leave your infrastructure** —
+> only counts and cost are ever reported. Use is governed by the [LICENSE](./LICENSE)
+> and the BiVelio Terms. Not a wrapper around any third‑party library.
+
+## Where it installs
+
+Your application → **BV‑SALA** → provider API. Traffic always goes straight from
+your app to your provider — BV‑SALA is a library inside your code, never a
+middleman server, and it works with any OpenAI‑compatible endpoint (OpenAI, Azure,
+vLLM, SGLang, a gateway) as well as Anthropic.
+
+**Only use ChatGPT or Claude?** Then there is nothing to install: those products
+charge a flat subscription, so there is no per‑token bill to cut. BV‑SALA is for
+applications that call the API with their own key. The whole story, in plain words:
+**[Where does the saving install?](https://savings.bivelio.com/en/how-it-works)**
+
+## Try it before you install
+
+Run the real optimizer **free in your browser** — pick an example or paste your own
+data and watch the meter — at **[savings.bivelio.com](https://savings.bivelio.com)**.
 
-## Install
+## Install in three steps
+
+**1 · The package**
 
 ```bash
 pnpm add @bivelio/savings-layer
 # or: npm i @bivelio/savings-layer  ·  yarn add @bivelio/savings-layer
 ```
 
-You also need a **license key**. Try the optimizer **free in your browser** — paste
-your own data and watch the meter — at **[savings.bivelio.com](https://savings.bivelio.com)**,
-then subscribe (**€4 / seat / month** or **€39 / seat / year**, EUR) to get your key.
+**2 · The license** — from your [dashboard](https://savings.bivelio.com/dashboard/install)
+(**€4 / seat / month** or **€39 / seat / year**, EUR)
+
+```bash
+export BIVELIO_LICENSE_KEY=…   # your license key
+export BIVELIO_SERVICE_KEY=…   # service-account key: auto-renewal + seat metering
+```
 
-## Quick start
+**3 · Wrap the call** — this is the entire code change:
 
 ```ts
 import { createSavingsLayer, OpenAICompatibleProvider } from "@bivelio/savings-layer";
@@ -54,8 +84,30 @@ console.log(report.calls.avoidedLlm); // → whole calls you never paid for
 console.log(report.cost.netSavings);  // → verified savings, per request
 ```
 
-Ask for a **structured contract** and you also get `data`, validated against your
-schema — the JSON-repair and output contracts levers switch on here:
+That's it. From the first request, `report` carries the saving — measured, not
+estimated.
+
+## What you get on every request
+
+A `SavingsReport` with the numbers behind every claim, kept in **four separate
+ledgers** that are never summed into one flattering figure:
+
+| Ledger | Meaning |
+| --- | --- |
+| `avoided_calls` | LLM / retrieval / tool calls that never executed |
+| `eliminated_tokens` | information dropped because it was not needed |
+| `compressed_tokens` | information kept, but encoded with fewer tokens |
+| `provider_cached_tokens` | tokens still in the prompt, billed/processed more cheaply |
+
+And a promise you can hold it to: **never worse than your JSON.** Payload encodings
+are chosen by counting real tokens with the destination model's own tokenizer, and
+BV‑SALA only moves away from plain JSON when the saving clearly clears the bar —
+`report.serialization` shows what was chosen and what each candidate would have cost.
+
+<details>
+<summary><b>Structured output — validated <code>data</code>, not just text</b></summary>
+
+Ask for a response contract and you also get `data`, validated against your schema:
 
 ```ts
 const { data, text } = await layer.generate<{ answer: number }>({
@@ -76,42 +128,10 @@ const { data, text } = await layer.generate<{ answer: number }>({
 console.log(data.answer); // 8
 ```
 
-The hard requirements are a `provider` and a valid `licenseKey`: BV‑SALA is a paid
-product and **refuses to run unlicensed, expired, or tampered** (it throws
-`LicenseError` at the `generate()` entry, carrying a `status` of `none`,
-`invalid`, `expired`, `grace`, `revoked` or `stale`). Your key — and this snippet
-with the key already filled in — is at
-[savings.bivelio.com/dashboard/install](https://savings.bivelio.com/dashboard/install).
-
-> **Set `serviceAccountKey` on every long‑running deployment.** Your licence token
-> expires at the end of the billing period; each renewal mints a **new** token. With
-> a service‑account key (`bvk_…`, same dashboard) the SDK picks the renewed token up
-> by itself and swaps it in without a restart. **Without it there is no machine
-> pickup**, so somebody has to paste the new token by hand every cycle — and if
-> nobody does, the deployment stops with `LicenseError` once the grace period ends,
-> while the subscription is paid and current. The key also enables seat metering
-> (counts only — never prompts or completions).
-
-### Seats (how you are billed)
-
-A **seat is a machine**, never a person. The SDK derives a stable, opaque id per
-machine + service-account key and reports it with the counts; the control plane
-bills a seat only once it has been seen on **3 separate days**.
-
-**Set `BVSALA_SEAT_ID` (one value per replica or service) whenever the machine
-identity can't be deduced** — Kubernetes, or any fleet where the hostname is
-assigned dynamically. Without it, every pod of a deployment shares one fingerprint
-and the whole deployment counts as a **single** seat. It is also the way to keep
-seat ids stable across an SDK upgrade: the fingerprint changed in v0.1.x, so a
-fleet that never set it may be counted twice in the month it upgrades.
-
-```bash
-BVSALA_SEAT_ID=worker-03   # stable per replica; [A-Za-z0-9._:/-], max 128 chars
-```
-
-CI runners are auto-detected and excluded from billable seats.
+</details>
 
-### Tool calls
+<details>
+<summary><b>Tool calls</b></summary>
 
 When you pass `tools` and the model asks to invoke one, the reply is not the final
 answer: `text` is empty by design and the request is in `toolCalls`. Execute it,
@@ -155,92 +175,45 @@ if (res.toolCalls?.length) {
 A tool‑call turn is never served from cache and never counted as an avoided call:
 an action that has not run yet cannot be a saving.
 
-> The `devUnlicensed` flag and `BVSALA_DEV_OPEN=1` are development‑only, honored
-> **only when building from source** (this repo's tests and benchmarks). They are
-> **disabled in this published package** — a valid `licenseKey` is the only way to
-> run it. They are not a way to use the product for free.
-
-Every component ships with an in‑memory default and is independently swappable:
-plug in your own cache, vector store, tokenizer, compressor or constraint backend
-behind the same interfaces.
-
-## The optimization order (cheapest first)
+</details>
 
-1. **Avoid the call entirely** when the answer can be produced or reused safely.
-2. **Avoid auxiliary calls** — the retrievals, tool hops and retries around it.
-3. **Eliminate unnecessary context** before trying to shrink what remains.
-4. **Shrink** the tokens that genuinely must be sent.
-5. **Constrain generation** to emit only the structure and length required.
+<details>
+<summary><b>Running a fleet? Seats and renewals</b></summary>
 
-The order is the point: work removed at step 1 costs nothing to compress at step 4.
+- **A seat is a machine, never a person.** A seat is billed only once it has been
+  seen on 3 separate days, and CI runners are auto‑detected and excluded.
+- **Set `serviceAccountKey` on every long‑running deployment.** Renewals mint a new
+  license token each billing period; with the service‑account key (`bvk_…`, same
+  dashboard) the SDK picks the renewed token up by itself, without a restart.
+- **Set `BVSALA_SEAT_ID` (one stable value per replica) on Kubernetes or any fleet
+  with dynamic hostnames**, so each replica counts as what it is:
 
-Provider prompt/KV caching is treated as a cost/latency saving — **never** as a
-reduction of the logical prompt size.
-
-## Four separate ledgers (never summed)
-
-Mixing these produces misleading metrics, so BV‑SALA keeps them apart:
-
-| Ledger | Meaning |
-| --- | --- |
-| `avoided_calls` | LLM / retrieval / tool calls that never executed |
-| `eliminated_tokens` | information dropped because it was not needed |
-| `compressed_tokens` | information kept, but encoded with fewer tokens |
-| `provider_cached_tokens` | tokens still in the prompt, billed/processed more cheaply |
-
-A cache hit removes a whole call. A re‑encode makes a payload smaller. Compression
-drops redundant words. A prefix cache makes tokens cheaper without removing them.
-Four different things — summing them would lie to you, so the report never does.
-
-## The decision cascade
-
-```
-Request
-  → Canonicalize + Policy (risk & freshness)
-  → Deterministic resolvers ─────────────► answer (0 calls)
-  → Exact cache ─────────────────────────► answer (0 calls)
-  → Concurrent duplicates coalesced ─────► answer (0 calls)
-      → Near-duplicate reuse ────────────► answer (0 calls)
-      → Execution planning (how much work this really needs)
-      → Context reduction (only when it pays for itself)
-      → Payload encoding chosen by measurement, not by default
-      → Output contract enforced
-      → ONE primary LLM call
-      → Structural + semantic validation (+ ≤1 repair)
-      → Local render / transcode / cache write
-  → SavingsReport + traces
+```bash
+BVSALA_SEAT_ID=worker-03   # stable per replica; [A-Za-z0-9._:/-], max 128 chars
 ```
 
-## Why formats are chosen, not assumed
-
-A compact encoding can be *larger* than plain JSON on nested or non‑uniform data,
-so BV‑SALA never assumes one. It counts the candidates with the destination
-model's own tokenizer — including the cost of explaining the encoding to the
-model — and only moves away from JSON when the saving clears a margin worth the
-change.
-
-On a wide, uniform table that is a large reduction. On a small nested object it
-leaves JSON alone. Whichever it picks, `report.serialization` tells you what was
-chosen and what each candidate would have cost, so the decision is auditable
-rather than promised.
+</details>
 
-## What's inside
+<details>
+<summary><b>Requirements</b></summary>
 
-Safe cache keys and a risk/freshness policy · several independent ways to answer
-without spending a call · execution planning · context reduction that must pay for
-itself · measured payload encoding · output contracts with validation · a
-provider‑neutral adapter · and a trace collector that builds the `SavingsReport`.
+- **Node ≥ 20.** The package is **ESM‑only** (`"type": "module"`); from CommonJS,
+  `require()` works on Node ≥ 22.
+- Optional peer `gpt-tokenizer` for exact OpenAI token counts — without it a
+  built‑in estimator is used, so it is not required to get started.
+- Every component (cache, vector store, tokenizer, compressor, constraint backend)
+  ships with an in‑memory default and is independently swappable behind the same
+  interfaces.
 
-Every piece is pluggable, and every saving it claims is reported per request with
-the token counts behind it.
+</details>
 
 ## Licensing & privacy
 
 BV‑SALA is commercial, per‑seat software (**€4 / seat / month** or **€39 / seat /
 year**, EUR). The license is a signed token your SDK verifies **offline**; the
-managed control plane (semantic cache, learned thresholds, dashboards) and the
-revocation kill‑switch are served from BiVelio. Your LLM traffic goes **straight to
-your provider** — BiVelio sees counts and cost, never prompts or completions.
+managed control plane and the revocation kill‑switch are served from BiVelio. Your
+LLM traffic goes **straight to your provider** — BiVelio sees counts and cost,
+never prompts or completions.
 
 Get a key and read the terms at **[savings.bivelio.com](https://savings.bivelio.com)**.
 Onboarding & general questions: **support@bivelio.com** · licensing & compliance:

package/dist/index.d.ts

@@ -1348,7 +1348,21 @@ interface SemanticHit {
     ageMs: number;
 }
 interface SemanticCacheOptions {
-    embed: EmbeddingFn;
+    /**
+     * How text becomes a vector. OPTIONAL: omit it and {@link embebedorLocal} is
+     * used — no network, no API key, no per-call cost.
+     *
+     * It used to be required, and the package shipped NO implementation, so this
+     * cache could not be constructed without bringing your own embedding provider.
+     * That is why the benchmark reported it as unmeasurable run after run: not that
+     * it saved little, but that it never got to run at all.
+     *
+     * Pass your own for true semantics; the local one only sees LEXICAL closeness.
+     * Either way the deterministic guard below still rejects a candidate whose
+     * numbers, negation or entities differ, so a weaker vector can only cost you a
+     * cache miss — never a wrong answer.
+     */
+    embed?: EmbeddingFn;
     verify?: SemanticVerifier;
     /** Cosine similarity floor for a candidate to be considered at all. */
     similarityThreshold?: number;
@@ -1376,7 +1390,7 @@ declare class InMemorySemanticCache {
     private readonly ttlMs;
     private readonly maxRecords;
     private readonly now;
-    constructor(opts: SemanticCacheOptions);
+    constructor(opts?: SemanticCacheOptions);
     /**
      * Find a safe hit for a canonical request, or null. Metadata filters run
      * FIRST and hard — a candidate from another tenant, scope, or knowledge epoch
@@ -1389,6 +1403,63 @@ declare class InMemorySemanticCache {
     get size(): number;
 }
 
+/**
+ * A LOCAL EMBEDDING FUNCTION — no network, no API key, no per-call cost.
+ *
+ * The semantic cache needs a way to compare meaning. Wiring it to a hosted
+ * embedding endpoint is the obvious answer and a bad default: it makes every
+ * miss cost a network round-trip and money, and it forces a provider choice onto
+ * a customer who never asked for one. So the cache shipped with no embedder at
+ * all, which means it never matched anything.
+ *
+ * This is the third option: a deterministic bag-of-features vector computed in
+ * microseconds from the text itself. It captures LEXICAL closeness — the same
+ * question asked with different filler words — which is the overwhelming majority
+ * of real repeat traffic. It does NOT capture deep semantics: "what is a CDN"
+ * and "explain content delivery networks" share no tokens and will not match.
+ *
+ * WHY THAT IS SAFE, AND THIS IS THE PART THAT MATTERS. A semantic cache's one
+ * unforgivable failure is confidently answering a NEARBY BUT DIFFERENT question.
+ * This vector never gets the chance: the cache runs a deterministic precision
+ * guard beneath the embedding — matching numbers and dates, negation parity and a
+ * content-overlap floor — and every isolation field (tenant, principal, model,
+ * schema, attached data) is a hard filter applied before similarity is scored.
+ * A weak embedding can only cause a MISS, which costs one real call. It cannot
+ * produce a wrong answer.
+ *
+ * Pass your own `embed` to {@link InMemorySemanticCache} to get true semantics.
+ * This one exists so that the feature is worth something with zero setup.
+ */
+/**
+ * The vector for a piece of text.
+ *
+ * Features are unigrams plus adjacent bigrams: bigrams are what keep word ORDER
+ * from being free. Without them "does A cause B" and "does B cause A" are the
+ * same point in space.
+ *
+ * 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.
+ */
+declare function vectorLocal(texto: string): number[];
+/**
+ * The default embedding function for {@link InMemorySemanticCache}.
+ *
+ * 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 embebedorLocal(texto: string): number[];
+/**
+ * The similarity floor this embedder is calibrated for.
+ *
+ * A lexical vector sits lower than a sentence-transformer on genuine paraphrases,
+ * so the 0.9 default that suits a hosted embedder would reject almost everything
+ * here. This value was measured on paraphrase pairs against near-miss pairs, not
+ * guessed — see `test/embebedor-local.test.ts`, which fails if the two
+ * populations stop being separable.
+ */
+declare const UMBRAL_LOCAL = 0.72;
+
 /**
  * Deterministic resolvers.
  *
@@ -2231,6 +2302,18 @@ interface AnthropicOptions {
      * pointless: the extra breakpoints are rejected by the API, not ignored.
      */
     maxCacheBreakpoints?: number;
+    /**
+     * Whether a request carrying BOTH the caller's tools and an output contract
+     * may send `tool_choice: {type: "any"}`, which obliges the model to answer
+     * through SOME tool — its pick — instead of writing prose.
+     *
+     * Defaults to `true`, and the default is the point: without it this exact
+     * combination measured 62% MORE expensive than sending no layer at all, every
+     * single time, because prose forces a second full call to repair. Turning it
+     * off restores the old behaviour for a caller who genuinely needs a plain-text
+     * turn to be reachable while a contract is attached.
+     */
+    forceAnswerThroughTool?: boolean;
 }
 declare class AnthropicProvider implements Provider {
     readonly id: string;
@@ -2919,6 +3002,41 @@ interface SavingsLayerConfig {
     defaultCostModel?: CostModel;
     /** TTL for exact-cache writes, in ms. */
     exactCacheTtlMs?: number;
+    /**
+     * Refuse the single repair retry when paying for it would push this request's
+     * cost above what it would have cost WITHOUT the layer. The invalid answer is
+     * then returned as-is with `constraints.structurallyValid: false`, plus a
+     * warning naming the three figures.
+     *
+     * OFF by default, and the default is a deliberate, measured choice rather than
+     * caution — read this before turning it on.
+     *
+     * The bound sounds narrow ("only the worst case") and is not. The baseline of
+     * a call that ran is reconstructed EXCLUDING the repair (see `estimateCost`:
+     * `actualInput - repairInput`), precisely so a retry cannot pay for itself in
+     * the report. That makes the threshold unreachable by construction: the repair
+     * only ever moves `actual`, never the baseline, so ANY repair breaches it
+     * whenever the layer's other books came out flat. On a request where nothing
+     * was compressed, cached or eliminated, `baseline === actual` exactly and the
+     * gate suppresses every repair, however cheap.
+     *
+     * So this is not "cap the tail", it is "stop repairing unless the layer has
+     * already banked more than the repair will cost". That is a real quality
+     * policy, not a rounding rule, and it is the caller's contract to decide on —
+     * hence opt-in.
+     *
+     * There is no threshold that fires on the pathological case and spares the
+     * flat one; they are the same arithmetic at different magnitudes. And there is
+     * a genuine argument on the other side: an answer that misses its contract is
+     * a MODEL failure, so the no-layer path would have had to pay for its own
+     * second call too — charging the whole retry against the layer compares one
+     * valid answer to one invalid answer.
+     *
+     * Turn it on when a hard per-request ceiling matters more than contract
+     * compliance — a batch backfill, a cost-capped tenant. Leave it off when the
+     * caller relies on the shape being right.
+     */
+    skipRepairAboveBaseline?: boolean;
     /**
      * Reliability contract. When true (the default), ANY internal optimizer error
      * (a resolver, cache, format selector, compressor, or accounting bug) is
@@ -3075,6 +3193,6 @@ declare function createSavingsLayer(config: Omit<SavingsLayerConfig, "tokenizer"
  * constant to package.json so the two can never drift.
  */
 
-declare const BV_SALA_VERSION = "0.3.1";
+declare const BV_SALA_VERSION = "0.4.1";
 
-export { type AnthropicOptions, AnthropicProvider, BV_SALA_VERSION, type BivelioHandoff, CATALOGO, COMPACT_ROWS_INSTRUCTION, type CacheOutcome, type CacheTier, type CachedAnswer, type CanonicalRequest, type ChatMessage, type CompactRowsDecodeOptions, type CompactRowsOptions, type CompactVerification, type CompressionEconomics, type CompressionPolicyInput, type CompressionRequest, type CompressionResult, type Compressor, type ConstraintBackend, type ConstraintBackendId, type ConstraintPlan, type ConversationState, type CostBasis, type CostModel, DEFAULT_COST_MODEL, type DeferredExecutionReport, type DeterministicResolver, EMBEDDED_PUBLIC_KEY, type EmbeddingFn, type EvidenceDoc, type ExactCache, ExactTokenizer, type ExecutionClass, ExecutionRouter, type FormatChoice, FormatSelector, type FormatSelectorOptions, type HandoffFact, HeuristicEstimator, InMemoryExactCache, InMemorySemanticCache, type JsonSchema, LicenseError, type LicenseGate, 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 ProtectedSpan, type Provider, type ProviderRequest, type ProviderResponse, type ProviderUsage, QUALITY_STATUSES, type QualityStatus, 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 SavingsLayer, type SavingsLayerConfig, SavingsLedger, type SavingsReport, type SavingsRequest, type SavingsResult, type SavingsToggles, SchemaRegistry, type SemanticCacheOptions, type SemanticHit, type SemanticRecord, type SemanticVerifier, type SerializationFormat, type Serializer, Singleflight, type TokenEstimator, TokenizerRegistry, type ToolCallRequest, type ToolDescriptor, type ToolRisk, type ToolSelection, ToolSelector, type ToolSelectorOptions, TraceCollector, type TraceEvent, UsageEmitter, type UsageEmitterOptions, type ValidationError, type ValidationResult, adaptiveK, arithmeticResolver, buildExactKey, buildInflightKey, canonicalize, compactRowsSerializer, computeNextDelay, cosine, createCompactRowsSerializer, createDefaultResolvers, createHandoff, createMockProvider, createSavingsLayer, csvSerializer, decodeCompactRows, dedupe, defaultTokenizerRegistry, deriveSeatId, deriveStatus, detectCi, emptyState, encodeCompactRows, evalArithmetic, evaluatePolicy, executeRetrievalPlan, gateFromKey, heuristicEstimator, isKeyset, isStrictCompatible, jsonCompactSerializer, keyTokensMatch, liveGateFromKey, mergeDelta, modelFamilyOf, noopCompressor, normalizeText, precioDeLista, projectContext, providerNativeBackend, randomId, registerExactTokenizer, registrarTokenizadorExacto, renderState, resolveConstraintBackend, resolveDependencies, resolveLicense, sha256, shouldCompress, stableStringify, uniformColumns, validateAgainstSchema, verifyCompactSignature, verifyLicenseToken, verifyRevocationList, withProtectedSpans };
+export { type AnthropicOptions, AnthropicProvider, BV_SALA_VERSION, type BivelioHandoff, CATALOGO, COMPACT_ROWS_INSTRUCTION, type CacheOutcome, type CacheTier, type CachedAnswer, type CanonicalRequest, type ChatMessage, type CompactRowsDecodeOptions, type CompactRowsOptions, type CompactVerification, type CompressionEconomics, type CompressionPolicyInput, type CompressionRequest, type CompressionResult, type Compressor, type ConstraintBackend, type ConstraintBackendId, type ConstraintPlan, type ConversationState, type CostBasis, type CostModel, DEFAULT_COST_MODEL, type DeferredExecutionReport, type DeterministicResolver, EMBEDDED_PUBLIC_KEY, type EmbeddingFn, type EvidenceDoc, type ExactCache, ExactTokenizer, type ExecutionClass, ExecutionRouter, type FormatChoice, FormatSelector, type FormatSelectorOptions, type HandoffFact, HeuristicEstimator, InMemoryExactCache, InMemorySemanticCache, type JsonSchema, LicenseError, type LicenseGate, 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 ProtectedSpan, type Provider, type ProviderRequest, type ProviderResponse, type ProviderUsage, QUALITY_STATUSES, type QualityStatus, 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 SavingsLayer, type SavingsLayerConfig, SavingsLedger, type SavingsReport, type SavingsRequest, type SavingsResult, type SavingsToggles, SchemaRegistry, type SemanticCacheOptions, type SemanticHit, type SemanticRecord, type SemanticVerifier, type SerializationFormat, type Serializer, Singleflight, type TokenEstimator, TokenizerRegistry, type ToolCallRequest, type ToolDescriptor, type ToolRisk, type ToolSelection, ToolSelector, type ToolSelectorOptions, TraceCollector, type TraceEvent, UMBRAL_LOCAL, UsageEmitter, type UsageEmitterOptions, type ValidationError, type ValidationResult, adaptiveK, arithmeticResolver, buildExactKey, buildInflightKey, canonicalize, compactRowsSerializer, computeNextDelay, cosine, createCompactRowsSerializer, createDefaultResolvers, createHandoff, createMockProvider, createSavingsLayer, csvSerializer, decodeCompactRows, dedupe, defaultTokenizerRegistry, deriveSeatId, deriveStatus, detectCi, embebedorLocal, emptyState, encodeCompactRows, evalArithmetic, evaluatePolicy, executeRetrievalPlan, gateFromKey, heuristicEstimator, isKeyset, isStrictCompatible, jsonCompactSerializer, keyTokensMatch, liveGateFromKey, mergeDelta, modelFamilyOf, noopCompressor, normalizeText, precioDeLista, projectContext, providerNativeBackend, randomId, registerExactTokenizer, registrarTokenizadorExacto, renderState, resolveConstraintBackend, resolveDependencies, resolveLicense, sha256, shouldCompress, stableStringify, uniformColumns, validateAgainstSchema, vectorLocal, verifyCompactSignature, verifyLicenseToken, verifyRevocationList, withProtectedSpans };