llm-burn 0.0.1 → 1.0.0

package/README.md

@@ -1,2 +1,390 @@
 # llm-burn
-> LLM cost tracking interceptor for NestJS — coming soon.
+
+[![npm version](https://img.shields.io/npm/v/llm-burn.svg)](https://www.npmjs.com/package/llm-burn)
+[![license](https://img.shields.io/npm/l/llm-burn.svg)](LICENSE)
+[![tests](https://img.shields.io/badge/tests-60%20passed-brightgreen)](https://github.com/julioxavier/llm-burn)
+
+**Cost tracking and budget enforcement for LLM calls in NestJS — with a single decorator.**
+
+Every OpenAI and Anthropic call burns money. `llm-burn` tells you exactly how much, per method, per model, in real time — and optionally blocks requests once a spending limit is reached. Zero changes to your business logic required.
+
+---
+
+## Features
+
+- **One decorator** — `@TrackLLMBurn()` is all you need to start tracking a method
+- **Auto-detection** — parses OpenAI, Anthropic, flat, and LangChain response shapes out of the box
+- **Budget enforcement** — `BudgetGuard` throws HTTP 403 before the LLM call is made when a cap is exceeded
+- **Per-method and global budgets** — granular control over individual methods or the entire application
+- **Built-in pricing** — ships with up-to-date prices for all major GPT and Claude models
+- **Extensible** — override prices, add custom models, or write a custom extractor for any SDK
+
+---
+
+## Installation
+
+```bash
+npm install llm-burn
+```
+
+**Peer dependencies** (already present in any NestJS project):
+
+```bash
+npm install @nestjs/common @nestjs/core reflect-metadata rxjs
+```
+
+---
+
+## Quick Start
+
+**1. Register the module in `AppModule`:**
+
+```typescript
+import { LLMBurnModule } from 'llm-burn';
+
+@Module({
+  imports: [
+    LLMBurnModule.forRoot({
+      globalBudget: 10.00,  // block all LLM calls after $10 spent
+      enableLogging: true,
+    }),
+  ],
+})
+export class AppModule {}
+```
+
+**2. Decorate the method that calls your LLM:**
+
+```typescript
+import { TrackLLMBurn } from 'llm-burn';
+
+@Injectable()
+export class AiService {
+  @TrackLLMBurn({ model: 'gpt-4o', budget: 2.00 })
+  async summarize(text: string) {
+    return this.openai.chat.completions.create({
+      model: 'gpt-4o',
+      messages: [{ role: 'user', content: text }],
+    });
+  }
+}
+```
+
+**3. Query costs anywhere in your application:**
+
+```typescript
+@Injectable()
+export class DashboardService {
+  constructor(private readonly llmBurn: LLMBurnService) {}
+
+  getReport() {
+    return this.llmBurn.getStats();
+    // { totalCost, totalCalls, byMethod, byModel, records }
+  }
+}
+```
+
+That's it. Token usage is extracted automatically from the response — no wrappers, no interceptors to wire up manually.
+
+---
+
+## Module Registration
+
+### Synchronous
+
+```typescript
+LLMBurnModule.forRoot({
+  globalBudget: 10.00,
+  enableLogging: true,
+})
+```
+
+### Async (with ConfigService)
+
+```typescript
+LLMBurnModule.forRootAsync({
+  imports: [ConfigModule],
+  inject: [ConfigService],
+  useFactory: (cfg: ConfigService) => ({
+    globalBudget: cfg.get<number>('LLM_BUDGET'),
+    enableLogging: cfg.get<boolean>('LLM_LOGGING'),
+  }),
+})
+```
+
+### With Global Interceptor
+
+Registers `LLMBurnInterceptor` as an `APP_INTERCEPTOR` so every route in your application is automatically intercepted. Combine with `@TrackLLMBurn()` on specific methods to control what gets tracked.
+
+```typescript
+LLMBurnModule.forRootWithGlobalInterceptor({
+  globalBudget: 5.00,
+  enableLogging: true,
+})
+```
+
+---
+
+## Decorator: `@TrackLLMBurn`
+
+Marks a method for LLM cost tracking. Automatically attaches the interceptor to that method — no need to wire up `UseInterceptors` manually.
+
+```typescript
+@TrackLLMBurn({ model: 'claude-3-5-sonnet-20241022', budget: 1.50 })
+async generateReport(prompt: string) {
+  return this.anthropic.messages.create({
+    model: 'claude-3-5-sonnet-20241022',
+    max_tokens: 1024,
+    messages: [{ role: 'user', content: prompt }],
+  });
+}
+```
+
+| Option | Type | Description |
+|---|---|---|
+| `model` | `string` | Model name used as fallback when the response doesn't include one. |
+| `provider` | `string` | Provider hint (`"openai"`, `"anthropic"`, or custom). Auto-detected from model name when omitted. |
+| `budget` | `number` | Per-method USD cap. `BudgetGuard` blocks calls once this is reached. |
+| `extractUsage` | `(result: unknown) => ExtractedUsage \| null` | Custom extractor for non-standard response shapes. |
+
+---
+
+## Budget Guard
+
+`BudgetGuard` runs **before** the route handler. It checks two thresholds in order:
+
+1. **Per-method budget** — reads `budget` from `@TrackLLMBurn({ budget: N })` and compares it against the cumulative cost of all previous calls to that method.
+2. **Global budget** — checks if `totalCost >= globalBudget` across all tracked calls.
+
+If either threshold is exceeded, it throws `ForbiddenException` (HTTP 403) and the LLM call is never made.
+
+> The guard checks cost accumulated from **previous calls**. The current call's cost is recorded after it completes (in the interceptor). This is by design — the guard acts as a spending limiter, not a per-call price check.
+
+### Applying the guard
+
+**Globally:**
+
+```typescript
+// main.ts
+async function bootstrap() {
+  const app = await NestFactory.create(AppModule);
+  app.useGlobalGuards(app.get(BudgetGuard));
+  await app.listen(3000);
+}
+```
+
+**Per controller:**
+
+```typescript
+@UseGuards(BudgetGuard)
+@Controller('ai')
+export class AiController {}
+```
+
+**Per route:**
+
+```typescript
+@UseGuards(BudgetGuard)
+@Post('summarize')
+@TrackLLMBurn({ model: 'gpt-4o', budget: 0.50 })
+async summarize(@Body() dto: SummarizeDto) { ... }
+```
+
+> When `BudgetGuard` is not registered, no request is ever blocked. Cost tracking via the interceptor still works normally.
+
+---
+
+## LLMBurnService
+
+Injectable service available anywhere after importing `LLMBurnModule`.
+
+| Method | Return | Description |
+|---|---|---|
+| `getStats()` | `LLMStats` | Full breakdown: totals, per-method, per-model, raw records |
+| `getTotalCost()` | `number` | Total USD spent across all calls |
+| `getMethodCost(method)` | `number` | Cumulative USD cost for a specific method |
+| `getBudgetStatus()` | `BudgetStatus` | Global budget usage (remaining, exceeded, % used) |
+| `getGlobalBudget()` | `number \| undefined` | Configured global budget cap |
+| `calculateCost(model, in, out, cached?)` | `number` | Calculate USD cost for a given token count |
+| `getPricing(model)` | `ModelPricing \| undefined` | Retrieve pricing for a model (supports prefix matching) |
+| `listKnownModels()` | `string[]` | All model names from built-in + custom prices |
+| `record(method, model, provider, in, out)` | `LLMCallRecord` | Manually record a call |
+| `reset()` | `void` | Clear all recorded usage |
+
+**Example — cost dashboard endpoint:**
+
+```typescript
+@Get('cost-report')
+getCostReport() {
+  return {
+    stats: this.llmBurn.getStats(),
+    budget: this.llmBurn.getBudgetStatus(),
+  };
+}
+```
+
+---
+
+## Supported Response Formats
+
+The interceptor auto-detects four response shapes out of the box:
+
+| Format | Shape |
+|---|---|
+| **OpenAI SDK** | `{ usage: { prompt_tokens, completion_tokens }, model }` |
+| **Anthropic SDK** | `{ usage: { input_tokens, output_tokens }, model }` |
+| **Flat** | `{ inputTokens, outputTokens, model? }` |
+| **LangChain** | `{ llmOutput: { tokenUsage: { promptTokens, completionTokens } } }` |
+
+### Custom extractor
+
+For non-standard SDKs or response wrappers, provide an `extractUsage` function:
+
+```typescript
+@TrackLLMBurn({
+  model: 'my-custom-model',
+  extractUsage: (result: unknown) => {
+    const r = result as MyCustomResponse;
+    if (!r?.meta?.tokens) return null;
+    return {
+      inputTokens: r.meta.tokens.input,
+      outputTokens: r.meta.tokens.output,
+      model: r.meta.model,       // optional — overrides decorator model
+      provider: 'my-provider',   // optional — overrides auto-detection
+    };
+  },
+})
+async callCustomLLM(prompt: string) { ... }
+```
+
+Return `null` to skip recording for a specific call — the interceptor will log a warning.
+
+---
+
+## Supported Models & Pricing
+
+Prices are in USD per 1 million tokens (updated March 2026).
+
+### OpenAI
+
+| Model | Input / M | Output / M | Cached Input / M |
+|---|---|---|---|
+| `gpt-4o` | $2.50 | $10.00 | $1.25 |
+| `gpt-4o-mini` | $0.15 | $0.60 | $0.075 |
+| `gpt-4-turbo` | $10.00 | $30.00 | — |
+| `gpt-4` | $30.00 | $60.00 | — |
+| `gpt-3.5-turbo` | $0.50 | $1.50 | — |
+| `o1` | $15.00 | $60.00 | $7.50 |
+| `o1-mini` | $3.00 | $12.00 | $1.50 |
+| `o3` | $10.00 | $40.00 | $2.50 |
+| `o3-mini` | $1.10 | $4.40 | $0.55 |
+| `gpt-4.5-preview` | $75.00 | $150.00 | $37.50 |
+
+### Anthropic
+
+| Model | Input / M | Output / M |
+|---|---|---|
+| `claude-opus-4-6` | $15.00 | $75.00 |
+| `claude-sonnet-4-6` | $3.00 | $15.00 |
+| `claude-haiku-4-5` | $0.80 | $4.00 |
+| `claude-3-5-sonnet-20241022` | $3.00 | $15.00 |
+| `claude-3-5-haiku-20241022` | $0.80 | $4.00 |
+| `claude-3-opus-20240229` | $15.00 | $75.00 |
+| `claude-3-haiku-20240307` | $0.25 | $1.25 |
+| `claude-2.1` | $8.00 | $24.00 |
+
+> **Prefix matching:** dated model variants like `gpt-4o-2024-11-20` are matched automatically — if no exact match exists, the interceptor falls back to the nearest prefix entry (`gpt-4o`).
+
+### Custom Prices
+
+**Inline** — add or override any model price at module registration:
+
+```typescript
+LLMBurnModule.forRoot({
+  customPrices: {
+    'my-fine-tuned-gpt4': {
+      inputPricePerMillion: 5.00,
+      outputPricePerMillion: 20.00,
+    },
+    'local-llama': {
+      inputPricePerMillion: 0,
+      outputPricePerMillion: 0,
+    },
+  },
+})
+```
+
+**External file** — point to your own JSON file to manage prices independently of the package version:
+
+```typescript
+LLMBurnModule.forRoot({
+  pricesPath: './prices.json',
+})
+```
+
+The file can be flat or nested (same shape as the built-in `prices.json`):
+
+```json
+// flat
+{
+  "gpt-4o": { "inputPricePerMillion": 2.50, "outputPricePerMillion": 10.00 },
+  "claude-sonnet-4-6": { "inputPricePerMillion": 3.00, "outputPricePerMillion": 15.00 }
+}
+
+// nested (grouped by provider)
+{
+  "openai": {
+    "gpt-4o": { "inputPricePerMillion": 2.50, "outputPricePerMillion": 10.00 }
+  },
+  "anthropic": {
+    "claude-sonnet-4-6": { "inputPricePerMillion": 3.00, "outputPricePerMillion": 15.00 }
+  }
+}
+```
+
+**Priority order:** `customPrices` > `pricesPath` > built-in prices.
+
+---
+
+## API Reference
+
+### LLMBurnModuleOptions
+
+| Option | Type | Default | Description |
+|---|---|---|---|
+| `globalBudget` | `number` | — | USD cap for total spend. `BudgetGuard` blocks when exceeded. |
+| `enableLogging` | `boolean` | `false` | Log each tracked call via NestJS Logger. |
+| `customPrices` | `Record<string, ModelPricing>` | — | Inline price overrides. Takes precedence over everything. |
+| `pricesPath` | `string` | — | Path to an external JSON prices file. Takes precedence over built-in prices. |
+
+### LLMStats
+
+```typescript
+interface LLMStats {
+  totalCost: number;
+  totalInputTokens: number;
+  totalOutputTokens: number;
+  totalCalls: number;
+  byMethod: Record<string, MethodStats>;  // breakdown per decorated method
+  byModel: Record<string, ModelStats>;    // breakdown per model name
+  records: LLMCallRecord[];               // all raw records
+}
+```
+
+### BudgetStatus
+
+```typescript
+interface BudgetStatus {
+  globalBudget?: number;   // configured cap (undefined if not set)
+  totalCost: number;       // total USD spent
+  remaining?: number;      // USD left before cap (0 when exceeded)
+  isExceeded: boolean;
+  percentUsed?: number;    // 0–100+
+}
+```
+
+---
+
+## License
+
+MIT

package/dist/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const LLM_BURN_OPTIONS = "LLM_BURN_OPTIONS";
+export declare const LLM_BURN_METADATA = "llm_burn:track";

package/dist/constants.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LLM_BURN_METADATA = exports.LLM_BURN_OPTIONS = void 0;
+exports.LLM_BURN_OPTIONS = 'LLM_BURN_OPTIONS';
+exports.LLM_BURN_METADATA = 'llm_burn:track';
+//# sourceMappingURL=constants.js.map

package/dist/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":";;;AAAa,QAAA,gBAAgB,GAAG,kBAAkB,CAAC;AACtC,QAAA,iBAAiB,GAAG,gBAAgB,CAAC"}

package/dist/decorators/track-llm-burn.decorator.d.ts

@@ -0,0 +1,13 @@
+export interface TrackLLMBurnOptions {
+    model?: string;
+    provider?: string;
+    budget?: number;
+    extractUsage?: (result: unknown) => ExtractedUsage | null;
+}
+export interface ExtractedUsage {
+    inputTokens: number;
+    outputTokens: number;
+    model?: string;
+    provider?: string;
+}
+export declare function TrackLLMBurn(options?: TrackLLMBurnOptions): MethodDecorator;

package/dist/decorators/track-llm-burn.decorator.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TrackLLMBurn = TrackLLMBurn;
+const common_1 = require("@nestjs/common");
+const constants_1 = require("../constants");
+const llm_burn_interceptor_1 = require("../llm-burn.interceptor");
+function TrackLLMBurn(options = {}) {
+    return (0, common_1.applyDecorators)((0, common_1.SetMetadata)(constants_1.LLM_BURN_METADATA, options), (0, common_1.UseInterceptors)(llm_burn_interceptor_1.LLMBurnInterceptor));
+}
+//# sourceMappingURL=track-llm-burn.decorator.js.map

package/dist/decorators/track-llm-burn.decorator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"track-llm-burn.decorator.js","sourceRoot":"","sources":["../../src/decorators/track-llm-burn.decorator.ts"],"names":[],"mappings":";;AAoDA,oCAKC;AAzDD,2CAA+E;AAC/E,4CAAiD;AACjD,kEAA6D;AAkD7D,SAAgB,YAAY,CAAC,UAA+B,EAAE;IAC5D,OAAO,IAAA,wBAAe,EACpB,IAAA,oBAAW,EAAC,6BAAiB,EAAE,OAAO,CAAC,EACvC,IAAA,wBAAe,EAAC,yCAAkB,CAAC,CACpC,CAAC;AACJ,CAAC"}

package/dist/guards/budget.guard.d.ts

@@ -0,0 +1,10 @@
+import { CanActivate, ExecutionContext } from '@nestjs/common';
+import { Reflector } from '@nestjs/core';
+import { LLMBurnService } from '../llm-burn.service';
+export declare class BudgetGuard implements CanActivate {
+    private readonly llmBurnService;
+    private readonly reflector;
+    private readonly logger;
+    constructor(llmBurnService: LLMBurnService, reflector: Reflector);
+    canActivate(context: ExecutionContext): boolean;
+}

package/dist/guards/budget.guard.js

@@ -0,0 +1,55 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var BudgetGuard_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BudgetGuard = void 0;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const constants_1 = require("../constants");
+const llm_burn_service_1 = require("../llm-burn.service");
+let BudgetGuard = BudgetGuard_1 = class BudgetGuard {
+    constructor(llmBurnService, reflector) {
+        this.llmBurnService = llmBurnService;
+        this.reflector = reflector;
+        this.logger = new common_1.Logger(BudgetGuard_1.name);
+    }
+    canActivate(context) {
+        const options = this.reflector.getAllAndOverride(constants_1.LLM_BURN_METADATA, [
+            context.getHandler(),
+            context.getClass(),
+        ]);
+        if (options?.budget != null) {
+            const methodName = context.getHandler().name;
+            const methodCost = this.llmBurnService.getMethodCost(methodName);
+            if (methodCost >= options.budget) {
+                const msg = `Method "${methodName}" has exceeded its budget cap of $${options.budget.toFixed(4)} ` +
+                    `(current: $${methodCost.toFixed(4)}).`;
+                this.logger.warn(msg);
+                throw new common_1.ForbiddenException(msg);
+            }
+        }
+        const status = this.llmBurnService.getBudgetStatus();
+        if (status.isExceeded) {
+            const msg = `Global LLM budget of $${status.globalBudget.toFixed(4)} exceeded ` +
+                `(spent: $${status.totalCost.toFixed(4)}).`;
+            this.logger.warn(msg);
+            throw new common_1.ForbiddenException(msg);
+        }
+        return true;
+    }
+};
+exports.BudgetGuard = BudgetGuard;
+exports.BudgetGuard = BudgetGuard = BudgetGuard_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [llm_burn_service_1.LLMBurnService,
+        core_1.Reflector])
+], BudgetGuard);
+//# sourceMappingURL=budget.guard.js.map

package/dist/guards/budget.guard.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"budget.guard.js","sourceRoot":"","sources":["../../src/guards/budget.guard.ts"],"names":[],"mappings":";;;;;;;;;;;;;AAAA,2CAMwB;AACxB,uCAAyC;AACzC,4CAAiD;AAEjD,0DAAqD;AAqB9C,IAAM,WAAW,mBAAjB,MAAM,WAAW;IAGtB,YACmB,cAA8B,EAC9B,SAAoB;QADpB,mBAAc,GAAd,cAAc,CAAgB;QAC9B,cAAS,GAAT,SAAS,CAAW;QAJtB,WAAM,GAAG,IAAI,eAAM,CAAC,aAAW,CAAC,IAAI,CAAC,CAAC;IAKpD,CAAC;IAEJ,WAAW,CAAC,OAAyB;QACnC,MAAM,OAAO,GAAG,IAAI,CAAC,SAAS,CAAC,iBAAiB,CAAsB,6BAAiB,EAAE;YACvF,OAAO,CAAC,UAAU,EAAE;YACpB,OAAO,CAAC,QAAQ,EAAE;SACnB,CAAC,CAAC;QAGH,IAAI,OAAO,EAAE,MAAM,IAAI,IAAI,EAAE,CAAC;YAC5B,MAAM,UAAU,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC,IAAI,CAAC;YAC7C,MAAM,UAAU,GAAG,IAAI,CAAC,cAAc,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC;YAEjE,IAAI,UAAU,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;gBACjC,MAAM,GAAG,GACP,WAAW,UAAU,qCAAqC,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG;oBACtF,cAAc,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC;gBAC1C,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;gBACtB,MAAM,IAAI,2BAAkB,CAAC,GAAG,CAAC,CAAC;YACpC,CAAC;QACH,CAAC;QAGD,MAAM,MAAM,GAAG,IAAI,CAAC,cAAc,CAAC,eAAe,EAAE,CAAC;QACrD,IAAI,MAAM,CAAC,UAAU,EAAE,CAAC;YACtB,MAAM,GAAG,GACP,yBAAyB,MAAM,CAAC,YAAa,CAAC,OAAO,CAAC,CAAC,CAAC,YAAY;gBACpE,YAAY,MAAM,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC;YAC9C,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;YACtB,MAAM,IAAI,2BAAkB,CAAC,GAAG,CAAC,CAAC;QACpC,CAAC;QAED,OAAO,IAAI,CAAC;IACd,CAAC;CACF,CAAA;AAxCY,kCAAW;sBAAX,WAAW;IADvB,IAAA,mBAAU,GAAE;qCAKwB,iCAAc;QACnB,gBAAS;GAL5B,WAAW,CAwCvB"}

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export { LLMBurnModule } from './llm-burn.module';
+export { LLMBurnService } from './llm-burn.service';
+export { LLMBurnInterceptor } from './llm-burn.interceptor';
+export { BudgetGuard } from './guards/budget.guard';
+export { TrackLLMBurn } from './decorators/track-llm-burn.decorator';
+export type { TrackLLMBurnOptions, ExtractedUsage } from './decorators/track-llm-burn.decorator';
+export type { LLMBurnModuleOptions, LLMBurnModuleAsyncOptions, ModelPricing, } from './interfaces/llm-burn-module-options.interface';
+export type { LLMCallRecord, LLMStats, MethodStats, ModelStats, BudgetStatus, } from './interfaces/llm-usage.interface';
+export { LLM_BURN_OPTIONS, LLM_BURN_METADATA } from './constants';

package/dist/index.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LLM_BURN_METADATA = exports.LLM_BURN_OPTIONS = exports.TrackLLMBurn = exports.BudgetGuard = exports.LLMBurnInterceptor = exports.LLMBurnService = exports.LLMBurnModule = void 0;
+var llm_burn_module_1 = require("./llm-burn.module");
+Object.defineProperty(exports, "LLMBurnModule", { enumerable: true, get: function () { return llm_burn_module_1.LLMBurnModule; } });
+var llm_burn_service_1 = require("./llm-burn.service");
+Object.defineProperty(exports, "LLMBurnService", { enumerable: true, get: function () { return llm_burn_service_1.LLMBurnService; } });
+var llm_burn_interceptor_1 = require("./llm-burn.interceptor");
+Object.defineProperty(exports, "LLMBurnInterceptor", { enumerable: true, get: function () { return llm_burn_interceptor_1.LLMBurnInterceptor; } });
+var budget_guard_1 = require("./guards/budget.guard");
+Object.defineProperty(exports, "BudgetGuard", { enumerable: true, get: function () { return budget_guard_1.BudgetGuard; } });
+var track_llm_burn_decorator_1 = require("./decorators/track-llm-burn.decorator");
+Object.defineProperty(exports, "TrackLLMBurn", { enumerable: true, get: function () { return track_llm_burn_decorator_1.TrackLLMBurn; } });
+var constants_1 = require("./constants");
+Object.defineProperty(exports, "LLM_BURN_OPTIONS", { enumerable: true, get: function () { return constants_1.LLM_BURN_OPTIONS; } });
+Object.defineProperty(exports, "LLM_BURN_METADATA", { enumerable: true, get: function () { return constants_1.LLM_BURN_METADATA; } });
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;AACA,qDAAkD;AAAzC,gHAAA,aAAa,OAAA;AAGtB,uDAAoD;AAA3C,kHAAA,cAAc,OAAA;AAGvB,+DAA4D;AAAnD,0HAAA,kBAAkB,OAAA;AAG3B,sDAAoD;AAA3C,2GAAA,WAAW,OAAA;AAGpB,kFAAqE;AAA5D,wHAAA,YAAY,OAAA;AAmBrB,yCAAkE;AAAzD,6GAAA,gBAAgB,OAAA;AAAE,8GAAA,iBAAiB,OAAA"}

package/dist/interfaces/llm-burn-module-options.interface.d.ts

@@ -0,0 +1,17 @@
+export interface ModelPricing {
+    inputPricePerMillion: number;
+    outputPricePerMillion: number;
+    cachedInputPricePerMillion?: number;
+}
+export interface LLMBurnModuleOptions {
+    globalBudget?: number;
+    throwOnBudgetExceeded?: boolean;
+    customPrices?: Record<string, ModelPricing>;
+    pricesPath?: string;
+    enableLogging?: boolean;
+}
+export interface LLMBurnModuleAsyncOptions {
+    imports?: any[];
+    useFactory: (...args: any[]) => LLMBurnModuleOptions | Promise<LLMBurnModuleOptions>;
+    inject?: any[];
+}

package/dist/interfaces/llm-burn-module-options.interface.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=llm-burn-module-options.interface.js.map

package/dist/interfaces/llm-burn-module-options.interface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"llm-burn-module-options.interface.js","sourceRoot":"","sources":["../../src/interfaces/llm-burn-module-options.interface.ts"],"names":[],"mappings":""}

package/dist/interfaces/llm-usage.interface.d.ts

@@ -0,0 +1,38 @@
+export interface LLMCallRecord {
+    method: string;
+    model: string;
+    provider: string;
+    inputTokens: number;
+    outputTokens: number;
+    cost: number;
+    timestamp: Date;
+}
+export interface MethodStats {
+    totalCost: number;
+    totalCalls: number;
+    totalInputTokens: number;
+    totalOutputTokens: number;
+    lastCalledAt?: Date;
+}
+export interface ModelStats {
+    totalCost: number;
+    totalCalls: number;
+    totalInputTokens: number;
+    totalOutputTokens: number;
+}
+export interface LLMStats {
+    totalCost: number;
+    totalInputTokens: number;
+    totalOutputTokens: number;
+    totalCalls: number;
+    byMethod: Record<string, MethodStats>;
+    byModel: Record<string, ModelStats>;
+    records: LLMCallRecord[];
+}
+export interface BudgetStatus {
+    globalBudget?: number;
+    totalCost: number;
+    remaining?: number;
+    isExceeded: boolean;
+    percentUsed?: number;
+}

package/dist/interfaces/llm-usage.interface.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=llm-usage.interface.js.map

package/dist/interfaces/llm-usage.interface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"llm-usage.interface.js","sourceRoot":"","sources":["../../src/interfaces/llm-usage.interface.ts"],"names":[],"mappings":""}

package/dist/llm-burn.interceptor.d.ts

@@ -0,0 +1,13 @@
+import { CallHandler, ExecutionContext, NestInterceptor } from '@nestjs/common';
+import { Reflector } from '@nestjs/core';
+import { Observable } from 'rxjs';
+import { LLMBurnService } from './llm-burn.service';
+export declare class LLMBurnInterceptor implements NestInterceptor {
+    private readonly llmBurnService;
+    private readonly reflector;
+    private readonly logger;
+    constructor(llmBurnService: LLMBurnService, reflector: Reflector);
+    intercept(context: ExecutionContext, next: CallHandler): Observable<unknown>;
+    private extractUsage;
+    private detectProvider;
+}