@bymax-one/nest-ai-tokens 1.1.3 → 1.1.4

package/CHANGELOG.md

@@ -8,6 +8,50 @@ The format follows [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) and
 
 ## [Unreleased]
 
+## [1.1.4] - 2026-11-01
+
+**Apply:** `verifyChain` has a new result, `{ valid: false, status: 'never-enabled' }`, which has no
+`brokenAtRecordId`; handle it wherever you read that field. Enable `ledger.hashChain` before the
+first write: records written earlier are reported as unchained and are not protected.
+
+### Fixed
+
+- **Enabling `ledger.hashChain` on a ledger that already has records no longer makes `verifyChain`
+  report the oldest record as tampered.** `verifyChain` required every settled record to carry a
+  hash, so the first record written before the chain was enabled failed verification and ended the
+  walk, and the chained records after it were never checked. It now follows the chain by its links:
+  records without a hash are counted in the new `unchainedCount` and reported as not protected, the
+  hashed records must start at one genesis with no gap in the links, and a record whose hash was
+  removed while its `prevHash` stayed is reported as broken. A ledger with settled records and no
+  hashed one returns `{ valid: false, status: 'never-enabled' }`. The result type gains
+  `unchainedCount` and an optional `chainStartsAtRecordId`; the new `never-enabled` variant has no
+  `brokenAtRecordId`. A `from`/`to` call still checks each record's own hash only. A record that no other
+  record names as its predecessor (the newest one, and a hold that settled while a later-created record
+  was already hashed) can be deleted without detection, and the chain is unkeyed; both limits are in the README.
+
+  **Apply:** code that reads `brokenAtRecordId` after `valid === false` must also handle the
+  `never-enabled` variant, which has none. Enable the chain before the first write; a rise in
+  `unchainedCount` after enabling is worth investigating.
+
+### Changed
+
+- The GitHub Release body is now the tag's own `CHANGELOG.md` section instead of the generated
+  pull-request list, and the release stops before publishing when the version has no section.
+  No change to the package.
+- The release-notes step starts the section only at a line that begins `## [<version>]`, so a
+  version token elsewhere in a heading, such as `## [Unreleased] [1.1.1]`, no longer selects the
+  wrong body.
+- The unused optional peer `@opentelemetry/api` is removed from `peerDependencies` and
+  `peerDependenciesMeta`. The package imports nothing from it; telemetry goes through the
+  `ITelemetrySink` you implement. Consumers lose only an install hint.
+
+### Documentation
+
+- The README says that `MODEL_PRICES_SEED` has no rows for `azure-openai`, `vertex`, `bedrock` or
+  `openrouter`, so with `pricing.strict` on a call through the first three presets throws
+  `AI_TOKENS_PRICE_NOT_FOUND` until the host adds a price (the `openrouter` preset rates from the
+  provider-reported cost), and shows a minimal `upsertPrice` call.
+
 ## [1.1.3] - 2026-10-31
 
 **Billing:** if you set prices with `upsertPrice` for a model the snapshot also prices while
@@ -397,7 +441,8 @@ have regressed from. They are kept because the reasoning is worth having.
 [1.1.0]: https://github.com/bymaxone/nest-ai-tokens/compare/v1.0.4...v1.1.0
 [1.1.2]: https://github.com/bymaxone/nest-ai-tokens/compare/v1.1.1...v1.1.2
 [1.1.3]: https://github.com/bymaxone/nest-ai-tokens/compare/v1.1.2...v1.1.3
+[1.1.4]: https://github.com/bymaxone/nest-ai-tokens/compare/v1.1.3...v1.1.4
 [1.1.1]: https://github.com/bymaxone/nest-ai-tokens/compare/v1.1.0...v1.1.1
 [1.0.4]: https://github.com/bymaxone/nest-ai-tokens/compare/v1.0.3...v1.0.4
 [1.0.3]: https://github.com/bymaxone/nest-ai-tokens/compare/v1.0.2...v1.0.3
-[Unreleased]: https://github.com/bymaxone/nest-ai-tokens/compare/v1.1.3...HEAD
+[Unreleased]: https://github.com/bymaxone/nest-ai-tokens/compare/v1.1.4...HEAD

package/README.md

@@ -337,6 +337,13 @@ when the application boots.
 
 All normalizers are pure functions over plain objects — no provider SDK peer dependency. Pass the raw response object and get back a `NormalizedUsage`.
 
+`MODEL_PRICES_SEED` has no rows for `azure-openai`, `vertex`, `bedrock` or `openrouter`; it covers
+`openai`, `anthropic`, `gemini`, `mistral`, `deepseek`, `xai` and `groq`. With `pricing.strict` on
+(the default), a call through the `azure-openai`, `vertex` or `bedrock` preset throws
+`AI_TOKENS_PRICE_NOT_FOUND` until you add its price. The `openrouter` preset rates from the cost the
+provider reports, so it needs no price unless a call sets `ratingMode: 'rate-table'`. See
+[Pricing & Markup](#-pricing--markup).
+
 ---
 
 ## 💰 Pricing & Markup
@@ -359,6 +366,20 @@ BymaxAiTokensModule.forRootAsync({
 // Margin: $0.015 per call
 ```
 
+A provider or model the snapshot does not price needs a rate before it can be rated. Add one with
+`PricingService.upsertPrice`; the new row closes the previous one at its `effectiveFrom`, which
+defaults to now. Rates are nano-USD per million tokens:
+
+```typescript
+await pricing.upsertPrice({
+  provider: 'bedrock',
+  model: 'my-model', // the model id your calls report
+  operation: 'chat',
+  inputNanoUsdPerMillion: 3_000_000_000n, // $3 per million input tokens
+  outputNanoUsdPerMillion: 15_000_000_000n, // $15 per million output tokens
+})
+```
+
 For per-tenant or per-feature pricing, implement `IMarkupPolicy`:
 
 ```typescript
@@ -564,8 +585,35 @@ The sections above document each of these with a runnable example. This is the i
 | `UsageReportService`   | `summarize` · `export`                                                                                                               |
 | `StreamUsageCollector` | Accumulates streamed chunks; prefers the provider's final usage over its own count                                                   |
 
-`LedgerService.verifyChain(tenantId, from?, to?)` resolves to a `ChainVerification`: `{ valid: true }`
-or `{ valid: false, brokenAtRecordId }`. It checks the chain that `ledger.hashChain: true` writes.
+#### Verifying the hash chain
+
+`LedgerService.verifyChain(tenantId, from?, to?)` resolves to a `ChainVerification`:
+
+- `{ valid: true, unchainedCount, chainStartsAtRecordId? }` — every hashed record recomputes and, on a call
+  without `from`/`to`, the hashed records form one chain. `chainStartsAtRecordId` is the genesis record
+  when the verified records include it.
+- `{ valid: false, brokenAtRecordId, unchainedCount }` — the record that fails: a record whose hash was
+  removed while its link stayed, a changed record, or, without `from`/`to`, a gap (a second chain start)
+  or a chain that does not start at a genesis record (its first head). Those checks run in that order,
+  and within each the earliest record in listing order is reported. Two records may share a predecessor:
+  a hold that settles after a later record links to the record created last, as the next record does.
+- `{ valid: false, status: 'never-enabled', unchainedCount }` — settled records exist and none carries a hash or a link. This
+  is not evidence of tampering; `ledger.hashChain` was simply never on for this tenant.
+
+Enable `ledger.hashChain` before the first write. Records written before it was enabled are **unchained**:
+they are counted in `unchainedCount`, not verified and not protected.
+
+What it does not catch, plainly:
+
+1. A record that no other record names as its predecessor can be deleted without detection. That is
+   the newest record, and a hold that settled while a later-created record was already hashed (a record
+   links to the hashed record created last, so that hold is never linked to). A hold that settles as
+   the newest-created record is linked by the next record and is not affected.
+2. The chain is unkeyed. Someone with write access who recomputes the whole tail is not detected, so
+   anchor the latest hash outside the database.
+3. An `unchainedCount` that rises after the chain was enabled is a signal to investigate. A rolling deploy
+   with mixed `hashChain` settings can also cause it.
+4. A call with `from` or `to` checks each record's own hash only, not the links between records.
 
 ### Decorators, helpers and catalogs
 

package/dist/server/index.cjs

@@ -1371,6 +1371,25 @@ function chainHash(prevHash, record) {
     content: computePayloadHash(record)
   });
 }
+function verifyChainRecords(records, structural) {
+  const hashed = records.filter((record) => record.hash !== void 0);
+  const unchainedCount = records.length - hashed.length;
+  const stripped = records.find((record) => record.hash === void 0 && record.prevHash !== void 0);
+  if (stripped !== void 0) return { valid: false, brokenAtRecordId: stripped.id, unchainedCount };
+  const forged = hashed.find((record) => record.hash !== chainHash(record.prevHash ?? null, record));
+  if (forged !== void 0) return { valid: false, brokenAtRecordId: forged.id, unchainedCount };
+  if (hashed.length === 0) {
+    return records.length === 0 ? { valid: true, unchainedCount } : { valid: false, status: "never-enabled", unchainedCount };
+  }
+  const hashes = new Set(hashed.map((record) => record.hash));
+  const heads = hashed.filter((record) => !hashes.has(record.prevHash));
+  const genesis = heads.find((record) => record.prevHash === void 0);
+  if (structural) {
+    const offending = heads.find((record) => record !== genesis);
+    if (offending !== void 0) return { valid: false, brokenAtRecordId: offending.id, unchainedCount };
+  }
+  return genesis === void 0 ? { valid: true, unchainedCount } : { valid: true, unchainedCount, chainStartsAtRecordId: genesis.id };
+}
 
 // src/server/services/ledger-idempotency-conflict.ts
 function isLedgerIdempotencyConflict(error) {
@@ -1513,33 +1532,39 @@ exports.LedgerService = class LedgerService {
     return this.store.transition(id, from2, to, patch, this.hashChainEnabled);
   }
   /**
-   * Verify a tenant's tamper-evident hash chain (§8.6). Walks its settled records
-   * (`posted` + `reversed`) in append order and recomputes each record's chain hash
-   * from its stored `prevHash` link, comparing it to the stored `hash`; reports the
-   * first record whose hash does not match (a post-hoc content modification).
-   * Recomputing from each record's own stored link makes verification independent
-   * of walk order and of any `from`/`to` window (the first in-range record keeps
-   * its real predecessor link). Always emits an `ai_tokens.audit` hook.
+   * Verify a tenant's tamper-evident hash chain (§8.6) over its settled records (`posted` +
+   * `reversed`). The chain is followed by its links (`prevHash` to `hash`), not by row order.
+   * Every hashed record must recompute from its own `prevHash`; a record that has lost its hash
+   * but kept its `prevHash` is reported as broken. Records with no hash and no `prevHash` were
+   * written before the chain was enabled: they are counted in `unchainedCount`, are not verified
+   * and are not protected. With no `from`/`to` bound the hashed records must also form one chain:
+   * one genesis (no `prevHash`) and no gap. If settled records exist and none carries a hash or a `prevHash`
+   * the result is `{ valid: false, status: 'never-enabled' }`, which is not evidence of tampering.
+   *
+   * Limits: a record that no other record names as its predecessor (the newest one, and a hold that
+   * settled while a later-created record was already hashed) can be deleted without detection;
+   * the chain is unkeyed, so someone with write access who recomputes the whole tail is not
+   * detected (anchor the latest hash outside the database); a bounded call (`from`/`to`) checks
+   * each record's own hash only; and an `unchainedCount` that rises after the chain was enabled is
+   * a signal to investigate (a rolling deploy with mixed `hashChain` settings can also cause it).
+   * Always emits an `ai_tokens.chain.verified` audit hook.
    *
    * @param tenantId The tenant whose chain to verify.
    * @param from Optional inclusive lower bound on `occurredAt`.
    * @param to Optional inclusive upper bound on `occurredAt`.
-   * @returns `{ valid: true }`, or `{ valid: false, brokenAtRecordId }`.
+   * @returns The verification outcome; see {@link ChainVerification}.
    */
   async verifyChain(tenantId, from2, to) {
     const filter = { tenantId, status: ["posted", "reversed"] };
     if (from2 !== void 0) filter.from = from2;
     if (to !== void 0) filter.to = to;
     const settled = await this.store.query(filter);
-    let result = { valid: true };
-    for (const record of settled) {
-      if (record.hash !== chainHash(record.prevHash ?? null, record)) {
-        result = { valid: false, brokenAtRecordId: record.id };
-        break;
-      }
+    const result = verifyChainRecords(settled, from2 === void 0 && to === void 0);
+    const details = { tenantId, valid: result.valid, unchainedCount: result.unchainedCount };
+    if (!result.valid) {
+      if ("status" in result) details.status = result.status;
+      else details.brokenAtRecordId = result.brokenAtRecordId;
     }
-    const details = { tenantId, valid: result.valid };
-    if (!result.valid) details.brokenAtRecordId = result.brokenAtRecordId;
     this.audit("ai_tokens.chain.verified", details);
     return result;
   }

package/dist/server/index.d.cts

@@ -1869,12 +1869,25 @@ declare class PricingService implements OnModuleInit {
  * @layer server
  */
 
-/** The outcome of {@link LedgerService.verifyChain}: intact, or the first broken record. */
+/**
+ * The outcome of {@link LedgerService.verifyChain}. `unchainedCount` is the number of settled
+ * records that carry no chain hash (written before the chain was enabled): they are counted, not
+ * verified, and the chain does not protect them. `chainStartsAtRecordId` is the genesis record when
+ * the verified records include it. The third variant means settled records exist and none carries a hash or a `prevHash`,
+ * i.e. the chain was never enabled for this tenant, which is not evidence of tampering.
+ */
 type ChainVerification = {
     valid: true;
+    unchainedCount: number;
+    chainStartsAtRecordId?: string;
 } | {
     valid: false;
     brokenAtRecordId: string;
+    unchainedCount: number;
+} | {
+    valid: false;
+    status: 'never-enabled';
+    unchainedCount: number;
 };
 
 /**
@@ -2000,18 +2013,27 @@ declare class LedgerService {
      */
     transition(id: string, from: UsageStatus, to: UsageStatus, patch?: Partial<UsageRecord>): Promise<UsageRecord | null>;
     /**
-     * Verify a tenant's tamper-evident hash chain (§8.6). Walks its settled records
-     * (`posted` + `reversed`) in append order and recomputes each record's chain hash
-     * from its stored `prevHash` link, comparing it to the stored `hash`; reports the
-     * first record whose hash does not match (a post-hoc content modification).
-     * Recomputing from each record's own stored link makes verification independent
-     * of walk order and of any `from`/`to` window (the first in-range record keeps
-     * its real predecessor link). Always emits an `ai_tokens.audit` hook.
+     * Verify a tenant's tamper-evident hash chain (§8.6) over its settled records (`posted` +
+     * `reversed`). The chain is followed by its links (`prevHash` to `hash`), not by row order.
+     * Every hashed record must recompute from its own `prevHash`; a record that has lost its hash
+     * but kept its `prevHash` is reported as broken. Records with no hash and no `prevHash` were
+     * written before the chain was enabled: they are counted in `unchainedCount`, are not verified
+     * and are not protected. With no `from`/`to` bound the hashed records must also form one chain:
+     * one genesis (no `prevHash`) and no gap. If settled records exist and none carries a hash or a `prevHash`
+     * the result is `{ valid: false, status: 'never-enabled' }`, which is not evidence of tampering.
+     *
+     * Limits: a record that no other record names as its predecessor (the newest one, and a hold that
+     * settled while a later-created record was already hashed) can be deleted without detection;
+     * the chain is unkeyed, so someone with write access who recomputes the whole tail is not
+     * detected (anchor the latest hash outside the database); a bounded call (`from`/`to`) checks
+     * each record's own hash only; and an `unchainedCount` that rises after the chain was enabled is
+     * a signal to investigate (a rolling deploy with mixed `hashChain` settings can also cause it).
+     * Always emits an `ai_tokens.chain.verified` audit hook.
      *
      * @param tenantId The tenant whose chain to verify.
      * @param from Optional inclusive lower bound on `occurredAt`.
      * @param to Optional inclusive upper bound on `occurredAt`.
-     * @returns `{ valid: true }`, or `{ valid: false, brokenAtRecordId }`.
+     * @returns The verification outcome; see {@link ChainVerification}.
      */
     verifyChain(tenantId: string, from?: Date, to?: Date): Promise<ChainVerification>;
     /**

package/dist/server/index.d.ts

@@ -1869,12 +1869,25 @@ declare class PricingService implements OnModuleInit {
  * @layer server
  */
 
-/** The outcome of {@link LedgerService.verifyChain}: intact, or the first broken record. */
+/**
+ * The outcome of {@link LedgerService.verifyChain}. `unchainedCount` is the number of settled
+ * records that carry no chain hash (written before the chain was enabled): they are counted, not
+ * verified, and the chain does not protect them. `chainStartsAtRecordId` is the genesis record when
+ * the verified records include it. The third variant means settled records exist and none carries a hash or a `prevHash`,
+ * i.e. the chain was never enabled for this tenant, which is not evidence of tampering.
+ */
 type ChainVerification = {
     valid: true;
+    unchainedCount: number;
+    chainStartsAtRecordId?: string;
 } | {
     valid: false;
     brokenAtRecordId: string;
+    unchainedCount: number;
+} | {
+    valid: false;
+    status: 'never-enabled';
+    unchainedCount: number;
 };
 
 /**
@@ -2000,18 +2013,27 @@ declare class LedgerService {
      */
     transition(id: string, from: UsageStatus, to: UsageStatus, patch?: Partial<UsageRecord>): Promise<UsageRecord | null>;
     /**
-     * Verify a tenant's tamper-evident hash chain (§8.6). Walks its settled records
-     * (`posted` + `reversed`) in append order and recomputes each record's chain hash
-     * from its stored `prevHash` link, comparing it to the stored `hash`; reports the
-     * first record whose hash does not match (a post-hoc content modification).
-     * Recomputing from each record's own stored link makes verification independent
-     * of walk order and of any `from`/`to` window (the first in-range record keeps
-     * its real predecessor link). Always emits an `ai_tokens.audit` hook.
+     * Verify a tenant's tamper-evident hash chain (§8.6) over its settled records (`posted` +
+     * `reversed`). The chain is followed by its links (`prevHash` to `hash`), not by row order.
+     * Every hashed record must recompute from its own `prevHash`; a record that has lost its hash
+     * but kept its `prevHash` is reported as broken. Records with no hash and no `prevHash` were
+     * written before the chain was enabled: they are counted in `unchainedCount`, are not verified
+     * and are not protected. With no `from`/`to` bound the hashed records must also form one chain:
+     * one genesis (no `prevHash`) and no gap. If settled records exist and none carries a hash or a `prevHash`
+     * the result is `{ valid: false, status: 'never-enabled' }`, which is not evidence of tampering.
+     *
+     * Limits: a record that no other record names as its predecessor (the newest one, and a hold that
+     * settled while a later-created record was already hashed) can be deleted without detection;
+     * the chain is unkeyed, so someone with write access who recomputes the whole tail is not
+     * detected (anchor the latest hash outside the database); a bounded call (`from`/`to`) checks
+     * each record's own hash only; and an `unchainedCount` that rises after the chain was enabled is
+     * a signal to investigate (a rolling deploy with mixed `hashChain` settings can also cause it).
+     * Always emits an `ai_tokens.chain.verified` audit hook.
      *
      * @param tenantId The tenant whose chain to verify.
      * @param from Optional inclusive lower bound on `occurredAt`.
      * @param to Optional inclusive upper bound on `occurredAt`.
-     * @returns `{ valid: true }`, or `{ valid: false, brokenAtRecordId }`.
+     * @returns The verification outcome; see {@link ChainVerification}.
      */
     verifyChain(tenantId: string, from?: Date, to?: Date): Promise<ChainVerification>;
     /**

package/dist/server/index.mjs

@@ -1369,6 +1369,25 @@ function chainHash(prevHash, record) {
     content: computePayloadHash(record)
   });
 }
+function verifyChainRecords(records, structural) {
+  const hashed = records.filter((record) => record.hash !== void 0);
+  const unchainedCount = records.length - hashed.length;
+  const stripped = records.find((record) => record.hash === void 0 && record.prevHash !== void 0);
+  if (stripped !== void 0) return { valid: false, brokenAtRecordId: stripped.id, unchainedCount };
+  const forged = hashed.find((record) => record.hash !== chainHash(record.prevHash ?? null, record));
+  if (forged !== void 0) return { valid: false, brokenAtRecordId: forged.id, unchainedCount };
+  if (hashed.length === 0) {
+    return records.length === 0 ? { valid: true, unchainedCount } : { valid: false, status: "never-enabled", unchainedCount };
+  }
+  const hashes = new Set(hashed.map((record) => record.hash));
+  const heads = hashed.filter((record) => !hashes.has(record.prevHash));
+  const genesis = heads.find((record) => record.prevHash === void 0);
+  if (structural) {
+    const offending = heads.find((record) => record !== genesis);
+    if (offending !== void 0) return { valid: false, brokenAtRecordId: offending.id, unchainedCount };
+  }
+  return genesis === void 0 ? { valid: true, unchainedCount } : { valid: true, unchainedCount, chainStartsAtRecordId: genesis.id };
+}
 
 // src/server/services/ledger-idempotency-conflict.ts
 function isLedgerIdempotencyConflict(error) {
@@ -1511,33 +1530,39 @@ var LedgerService = class {
     return this.store.transition(id, from2, to, patch, this.hashChainEnabled);
   }
   /**
-   * Verify a tenant's tamper-evident hash chain (§8.6). Walks its settled records
-   * (`posted` + `reversed`) in append order and recomputes each record's chain hash
-   * from its stored `prevHash` link, comparing it to the stored `hash`; reports the
-   * first record whose hash does not match (a post-hoc content modification).
-   * Recomputing from each record's own stored link makes verification independent
-   * of walk order and of any `from`/`to` window (the first in-range record keeps
-   * its real predecessor link). Always emits an `ai_tokens.audit` hook.
+   * Verify a tenant's tamper-evident hash chain (§8.6) over its settled records (`posted` +
+   * `reversed`). The chain is followed by its links (`prevHash` to `hash`), not by row order.
+   * Every hashed record must recompute from its own `prevHash`; a record that has lost its hash
+   * but kept its `prevHash` is reported as broken. Records with no hash and no `prevHash` were
+   * written before the chain was enabled: they are counted in `unchainedCount`, are not verified
+   * and are not protected. With no `from`/`to` bound the hashed records must also form one chain:
+   * one genesis (no `prevHash`) and no gap. If settled records exist and none carries a hash or a `prevHash`
+   * the result is `{ valid: false, status: 'never-enabled' }`, which is not evidence of tampering.
+   *
+   * Limits: a record that no other record names as its predecessor (the newest one, and a hold that
+   * settled while a later-created record was already hashed) can be deleted without detection;
+   * the chain is unkeyed, so someone with write access who recomputes the whole tail is not
+   * detected (anchor the latest hash outside the database); a bounded call (`from`/`to`) checks
+   * each record's own hash only; and an `unchainedCount` that rises after the chain was enabled is
+   * a signal to investigate (a rolling deploy with mixed `hashChain` settings can also cause it).
+   * Always emits an `ai_tokens.chain.verified` audit hook.
    *
    * @param tenantId The tenant whose chain to verify.
    * @param from Optional inclusive lower bound on `occurredAt`.
    * @param to Optional inclusive upper bound on `occurredAt`.
-   * @returns `{ valid: true }`, or `{ valid: false, brokenAtRecordId }`.
+   * @returns The verification outcome; see {@link ChainVerification}.
    */
   async verifyChain(tenantId, from2, to) {
     const filter = { tenantId, status: ["posted", "reversed"] };
     if (from2 !== void 0) filter.from = from2;
     if (to !== void 0) filter.to = to;
     const settled = await this.store.query(filter);
-    let result = { valid: true };
-    for (const record of settled) {
-      if (record.hash !== chainHash(record.prevHash ?? null, record)) {
-        result = { valid: false, brokenAtRecordId: record.id };
-        break;
-      }
+    const result = verifyChainRecords(settled, from2 === void 0 && to === void 0);
+    const details = { tenantId, valid: result.valid, unchainedCount: result.unchainedCount };
+    if (!result.valid) {
+      if ("status" in result) details.status = result.status;
+      else details.brokenAtRecordId = result.brokenAtRecordId;
     }
-    const details = { tenantId, valid: result.valid };
-    if (!result.valid) details.brokenAtRecordId = result.brokenAtRecordId;
     this.audit("ai_tokens.chain.verified", details);
     return result;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bymax-one/nest-ai-tokens",
-  "version": "1.1.3",
+  "version": "1.1.4",
   "description": "AI token metering & usage-based billing for NestJS 11: provider usage normalizer (×9), versioned effective-dated pricing, immutable append-only ledger, prepaid wallets, multi-dimension budgets, and markup/margin. Zero runtime dependencies.",
   "author": "Bymax One <support@bymax.one>",
   "license": "MIT",
@@ -107,8 +107,7 @@
     "rxjs": "^7.8.0",
     "@prisma/client": "^6.0.0 || ^7.0.0",
     "ioredis": "^6.0.0",
-    "@nestjs/event-emitter": ">=2.0.0",
-    "@opentelemetry/api": "^1.9.0"
+    "@nestjs/event-emitter": ">=2.0.0"
   },
   "peerDependenciesMeta": {
     "@nestjs/common": {
@@ -131,9 +130,6 @@
     },
     "@nestjs/event-emitter": {
       "optional": true
-    },
-    "@opentelemetry/api": {
-      "optional": true
     }
   },
   "devDependencies": {
@@ -144,7 +140,6 @@
     "@nestjs/event-emitter": "^3.0.1",
     "@nestjs/platform-express": "^11.1.28",
     "@nestjs/testing": "^11.1.28",
-    "@opentelemetry/api": "^1.9.0",
     "@prisma/adapter-pg": "^7.9.1",
     "@prisma/client": "^7.9.1",
     "@stryker-mutator/core": "^9",