ai-cost-calc 1.3.5

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 ai-cost-calc contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,300 @@
+# ai-cost-calc (JavaScript/TypeScript)
+
+AI cost calculator and usage tracker for LLM apps.
+
+- Powered by MarginDash live pricing, fetched at runtime (not bundled static pricing files)
+- AI API prices change often; this SDK fetches live pricing from the API instead of relying on bundled static tables
+- Privacy-first: your app still talks directly to AI providers, so prompts/responses stay in your stack
+- Tracking is optional and sends usage plus event metadata (customer ID, event type, revenue if provided)
+
+Use it in two ways:
+- Free cost calculator (`cost`) for 400+ models (no API key required):
+  - exact mode with token counts (`inputTokens`, `outputTokens`)
+  - estimate mode with prompt/response text (`inputText`, `outputText`)
+  - live pricing with 24h cache per `AiCostCalc` instance
+- Usage tracking (`addUsage` + `track`) with an API key
+
+## Pricing Data
+
+Cost calculation uses live pricing from the API.
+No hardcoded pricing tables.
+
+- Pricing data is cached per `AiCostCalc` instance for 24 hours
+- Cache refresh happens automatically when the cache is stale
+- If a refresh fails after a successful fetch, the SDK reuses last-known pricing and retries after backoff
+
+## Caching Behavior
+
+- Cache scope: per `AiCostCalc` instance
+- Cache TTL: 24 hours
+- Refresh failures: last-known pricing is reused, then retried after backoff
+- Force refresh now: create a new `AiCostCalc` instance
+
+## Requirements
+
+- Node.js 18+
+
+## Installation
+
+```bash
+npm install ai-cost-calc
+```
+
+For the tracking quickstart (OpenAI example):
+
+```bash
+npm install openai
+```
+
+For text-based estimation, `js-tiktoken` is used. It is an optional dependency,
+so some environments may skip it. If needed:
+
+```bash
+npm install js-tiktoken
+```
+
+## Quickstart (Cost Calculator)
+
+```typescript
+import { AiCostCalc } from "ai-cost-calc";
+
+async function run() {
+  const md = new AiCostCalc();
+  const result = await md.cost("gpt-4o", 1000, 500);
+  if (!result) return;
+  console.log(result.totalCost);
+}
+
+run();
+```
+
+## Quickstart (Usage Tracking)
+
+Use an API key from your MarginDash dashboard.
+
+```typescript
+import { AiCostCalc } from "ai-cost-calc";
+import OpenAI from "openai";
+
+async function run() {
+  const md = new AiCostCalc({ apiKey: process.env.AI_COST_CALC_API_KEY });
+  const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
+
+  const response = await openai.chat.completions.create({
+    model: "gpt-4o",
+    messages: [{ role: "user", content: "Hello" }],
+  });
+
+  md.addUsage({
+    vendor: "openai",
+    model: response.model,
+    inputTokens: response.usage?.prompt_tokens ?? 0,
+    outputTokens: response.usage?.completion_tokens ?? 0,
+  });
+
+  md.track({
+    customerId: "cust_123",
+    eventType: "chat",
+    revenueAmountInCents: 250,
+  });
+
+  await md.shutdown();
+}
+
+run();
+```
+
+## When to Use Which Mode
+
+| If you need... | Use... |
+| --- | --- |
+| Quick cost checks with no account setup | `cost()` only |
+| Exact costs from provider token usage | `cost(model, inputTokens, outputTokens)` |
+| Early estimation from prompt/response text | `cost(model, inputText, outputText?)` |
+| MarginDash customer/revenue tracking | `addUsage()` + `track()` with `apiKey` |
+
+## Return Values and Failure Modes
+
+| Method | Failure behavior |
+| --- | --- |
+| `cost()` | Returns `null` |
+| `addUsage()` / `track()` without `apiKey` | No-op, reports via `onError` once |
+| `flush()` / `shutdown()` | Do not throw for request failures; report via `onError` |
+
+## Common Integration Patterns
+
+OpenAI (`chat.completions`):
+
+```typescript
+md.addUsage({
+  vendor: "openai",
+  model: response.model,
+  inputTokens: response.usage?.prompt_tokens ?? 0,
+  outputTokens: response.usage?.completion_tokens ?? 0,
+});
+```
+
+Anthropic (`messages`):
+
+```typescript
+md.addUsage({
+  vendor: "anthropic",
+  model: response.model,
+  inputTokens: response.usage?.input_tokens ?? 0,
+  outputTokens: response.usage?.output_tokens ?? 0,
+});
+```
+
+Google Gemini:
+
+```typescript
+md.addUsage({
+  vendor: "google",
+  model: response.modelVersion ?? "gemini-2.0-flash",
+  inputTokens: response.usageMetadata?.promptTokenCount ?? 0,
+  outputTokens: response.usageMetadata?.candidatesTokenCount ?? 0,
+});
+```
+
+## Environment Variables
+
+- `AI_COST_CALC_API_KEY`: required only for tracking (from your MarginDash dashboard)
+- `OPENAI_API_KEY`: only needed if you use the OpenAI SDK in your app
+
+## API Reference
+
+### `cost(model, inputTokens, outputTokens)`
+
+Exact cost mode.
+
+- `model`: model slug (example: `gpt-4o`, `claude-sonnet-4`)
+- `inputTokens`: non-negative integer
+- `outputTokens`: non-negative integer
+
+### `cost(model, inputText, outputText?)`
+
+Estimated cost mode using `js-tiktoken`.
+
+- `inputText`: prompt text
+- `outputText`: optional response text (defaults to 0 output tokens)
+
+Returns `Promise<CostResult | null>`.
+
+`null` means one of:
+- unknown model
+- pricing fetch unavailable
+- invalid arguments
+- tokenizer unavailable/failure in estimate mode
+
+`CostResult` fields:
+- `model`
+- `inputCost`
+- `outputCost`
+- `totalCost`
+- `inputTokens`
+- `outputTokens`
+- `estimated`
+
+### `addUsage({ vendor, model, inputTokens, outputTokens })`
+
+Buffers usage from one AI call. Requires `apiKey` in constructor.
+
+### `track({ customerId, revenueAmountInCents?, eventType?, uniqueRequestToken?, occurredAt? })`
+
+Creates an event from all currently buffered usage entries and enqueues it for delivery.
+Requires `apiKey`.
+
+### `flush()`
+
+Immediately sends queued events. Returns `Promise<void>`.
+
+### `shutdown()`
+
+Stops the background flush timer and flushes remaining events. Returns `Promise<void>`.
+Call this before process exit.
+
+## Configuration
+
+```typescript
+import { AiCostCalc } from "ai-cost-calc";
+
+const md = new AiCostCalc({
+  apiKey: process.env.AI_COST_CALC_API_KEY, // optional for cost(); required for tracking
+  baseUrl: "https://margindash.com/api/v1",
+  flushIntervalMs: 5000,
+  maxRetries: 3,
+  defaultEventType: "ai_request",
+  debug: false,
+  onError: (err) => console.error(err.message),
+});
+```
+
+Options:
+- `apiKey` (optional)
+- `baseUrl` (default `https://margindash.com/api/v1`)
+- `flushIntervalMs` (default `5000`, must be a finite number `> 0` when `apiKey` is set)
+- `maxRetries` (default `3`, must be a non-negative integer)
+- `defaultEventType` (default `ai_request`)
+- `debug` (default `false`)
+- `onError` (optional callback)
+
+## Error Handling
+
+The SDK is non-throwing for normal tracking/cost failures and reports errors via:
+- `onError` callback
+- console logs when `debug: true`
+
+Example:
+
+```typescript
+const md = new AiCostCalc({
+  apiKey: process.env.AI_COST_CALC_API_KEY,
+  onError: (err) => console.error(err.message),
+});
+```
+
+## Delivery Semantics
+
+Tracking behavior:
+- in-memory queue size limit: 1000 events (oldest dropped when full)
+- pending usage limit before `track`: 1000 items (oldest dropped when full)
+- batch size: 50 events/request
+- retries on network errors, HTTP `429`, and `5xx` with exponential backoff
+
+Idempotency:
+- `uniqueRequestToken` is the idempotency key for an event
+- if omitted, SDK auto-generates a UUID
+- for retry-safe exactly-once behavior across your own retries, provide your own stable token
+
+## Privacy
+
+Free cost mode only fetches pricing data.
+If tracking is enabled, the SDK sends event metadata (for example: customer ID, event type, revenue), plus model/vendor and token counts.
+Request/response content is not sent.
+
+## Troubleshooting
+
+- `cost()` returns `null`:
+  - verify model slug
+  - check network access to the pricing API
+  - add `onError` and/or `debug: true`
+- numbers look outdated:
+  - pricing cache TTL is 24 hours per `AiCostCalc` instance
+  - create a new `AiCostCalc` instance for an immediate refresh if needed
+- text estimation fails:
+  - install `js-tiktoken` (`npm install js-tiktoken`)
+- tracking methods appear to do nothing:
+  - confirm `apiKey` is set in constructor
+- events missing on shutdown:
+  - `await md.shutdown()` before process exits
+
+## Versioning and Releases
+
+This SDK follows semantic versioning.
+
+- npm package: `ai-cost-calc`
+- check release history on npm/GitHub before major upgrades
+
+## License
+
+MIT

package/dist/index.d.mts

@@ -0,0 +1,116 @@
+/** Payload passed to `AiCostCalc.track()`. */
+interface EventPayload {
+    customerId: string;
+    revenueAmountInCents?: number;
+    uniqueRequestToken?: string;
+    eventType?: string;
+    occurredAt?: string;
+}
+/** Usage data from a single AI API call. */
+interface UsageData {
+    vendor: string;
+    model: string;
+    inputTokens: number;
+    outputTokens: number;
+}
+/** Pricing data for a single model. */
+interface ModelPricing {
+    slug: string;
+    inputPricePer1M: number;
+    outputPricePer1M: number;
+}
+/** Result of a cost calculation. */
+interface CostResult {
+    model: string;
+    inputCost: number;
+    outputCost: number;
+    totalCost: number;
+    inputTokens?: number;
+    outputTokens?: number;
+    estimated?: boolean;
+}
+/** SDK configuration options. */
+interface AiCostCalcConfig {
+    apiKey?: string;
+    baseUrl?: string;
+    flushIntervalMs?: number;
+    maxRetries?: number;
+    defaultEventType?: string;
+    onError?: (error: AiCostCalcError) => void;
+    debug?: boolean;
+}
+/** Error information surfaced via the `onError` callback. */
+interface AiCostCalcError {
+    message: string;
+    cause?: unknown;
+}
+
+/**
+ * ai-cost-calc client.
+ *
+ * Queues events in memory and flushes them to the API in
+ * batches on a timer. Call {@link shutdown} when your process is about
+ * to exit so that remaining events are delivered.
+ */
+declare class AiCostCalc {
+    private readonly apiKey;
+    private readonly baseUrl;
+    private readonly maxRetries;
+    private readonly defaultEventType;
+    private readonly onError?;
+    private readonly debug;
+    private flushTimer;
+    private shutdownPromise;
+    private queue;
+    private pendingUsages;
+    private readonly boundBeforeExit;
+    private apiKeyWarned;
+    private pricingCache;
+    private pricingFetchedAt;
+    private pricingPromise;
+    private pricingFailedAt;
+    private static readonly PRICING_CACHE_TTL_MS;
+    private static readonly PRICING_FAILURE_BACKOFF_MS;
+    constructor(config?: AiCostCalcConfig);
+    /**
+     * Calculate the cost of an AI API call using live pricing data.
+     * No API key required — pricing is fetched from the public models endpoint.
+     * Returns null if the model is unknown or pricing data is unavailable.
+     *
+     * Pass (model, inputTokens, outputTokens) for exact costs, or
+     * (model, inputText, outputText?) for estimated costs using js-tiktoken.
+     */
+    cost(model: string, inputTokens: number, outputTokens: number): Promise<CostResult | null>;
+    cost(model: string, inputText: string, outputText?: string): Promise<CostResult | null>;
+    private loadTokenizer;
+    addUsage(usage: UsageData): void;
+    /**
+     * Enqueue an event for delivery. This method is synchronous and will
+     * never throw -- errors are silently swallowed so that tracking can
+     * never crash the host application.
+     *
+     * All usage entries previously added via {@link addUsage} are drained
+     * and attached to the event.
+     */
+    track(event: EventPayload): void;
+    /**
+     * Flush all queued events to the API immediately.
+     */
+    flush(): Promise<void>;
+    /**
+     * Flush remaining events and stop the background timer.
+     * Call this before your process exits.
+     */
+    shutdown(): Promise<void>;
+    private requireApiKey;
+    private ensurePricing;
+    private enqueue;
+    private drain;
+    private toWireEvent;
+    private fetchWithRetry;
+    private sendBatch;
+    private reportError;
+    private log;
+}
+
+export { AiCostCalc, type AiCostCalcConfig, type AiCostCalcError, type CostResult, type EventPayload, type ModelPricing, type UsageData };

package/dist/index.d.ts

@@ -0,0 +1,116 @@
+/** Payload passed to `AiCostCalc.track()`. */
+interface EventPayload {
+    customerId: string;
+    revenueAmountInCents?: number;
+    uniqueRequestToken?: string;
+    eventType?: string;
+    occurredAt?: string;
+}
+/** Usage data from a single AI API call. */
+interface UsageData {
+    vendor: string;
+    model: string;
+    inputTokens: number;
+    outputTokens: number;
+}
+/** Pricing data for a single model. */
+interface ModelPricing {
+    slug: string;
+    inputPricePer1M: number;
+    outputPricePer1M: number;
+}
+/** Result of a cost calculation. */
+interface CostResult {
+    model: string;
+    inputCost: number;
+    outputCost: number;
+    totalCost: number;
+    inputTokens?: number;
+    outputTokens?: number;
+    estimated?: boolean;
+}
+/** SDK configuration options. */
+interface AiCostCalcConfig {
+    apiKey?: string;
+    baseUrl?: string;
+    flushIntervalMs?: number;
+    maxRetries?: number;
+    defaultEventType?: string;
+    onError?: (error: AiCostCalcError) => void;
+    debug?: boolean;
+}
+/** Error information surfaced via the `onError` callback. */
+interface AiCostCalcError {
+    message: string;
+    cause?: unknown;
+}
+
+/**
+ * ai-cost-calc client.
+ *
+ * Queues events in memory and flushes them to the API in
+ * batches on a timer. Call {@link shutdown} when your process is about
+ * to exit so that remaining events are delivered.
+ */
+declare class AiCostCalc {
+    private readonly apiKey;
+    private readonly baseUrl;
+    private readonly maxRetries;
+    private readonly defaultEventType;
+    private readonly onError?;
+    private readonly debug;
+    private flushTimer;
+    private shutdownPromise;
+    private queue;
+    private pendingUsages;
+    private readonly boundBeforeExit;
+    private apiKeyWarned;
+    private pricingCache;
+    private pricingFetchedAt;
+    private pricingPromise;
+    private pricingFailedAt;
+    private static readonly PRICING_CACHE_TTL_MS;
+    private static readonly PRICING_FAILURE_BACKOFF_MS;
+    constructor(config?: AiCostCalcConfig);
+    /**
+     * Calculate the cost of an AI API call using live pricing data.
+     * No API key required — pricing is fetched from the public models endpoint.
+     * Returns null if the model is unknown or pricing data is unavailable.
+     *
+     * Pass (model, inputTokens, outputTokens) for exact costs, or
+     * (model, inputText, outputText?) for estimated costs using js-tiktoken.
+     */
+    cost(model: string, inputTokens: number, outputTokens: number): Promise<CostResult | null>;
+    cost(model: string, inputText: string, outputText?: string): Promise<CostResult | null>;
+    private loadTokenizer;
+    addUsage(usage: UsageData): void;
+    /**
+     * Enqueue an event for delivery. This method is synchronous and will
+     * never throw -- errors are silently swallowed so that tracking can
+     * never crash the host application.
+     *
+     * All usage entries previously added via {@link addUsage} are drained
+     * and attached to the event.
+     */
+    track(event: EventPayload): void;
+    /**
+     * Flush all queued events to the API immediately.
+     */
+    flush(): Promise<void>;
+    /**
+     * Flush remaining events and stop the background timer.
+     * Call this before your process exits.
+     */
+    shutdown(): Promise<void>;
+    private requireApiKey;
+    private ensurePricing;
+    private enqueue;
+    private drain;
+    private toWireEvent;
+    private fetchWithRetry;
+    private sendBatch;
+    private reportError;
+    private log;
+}
+
+export { AiCostCalc, type AiCostCalcConfig, type AiCostCalcError, type CostResult, type EventPayload, type ModelPricing, type UsageData };

package/dist/index.js

@@ -0,0 +1,339 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class;// src/client.ts
+var DEFAULT_BASE_URL = "https://margindash.com/api/v1";
+var DEFAULT_FLUSH_INTERVAL_MS = 5e3;
+var DEFAULT_MAX_RETRIES = 3;
+var DEFAULT_EVENT_TYPE = "ai_request";
+var MAX_QUEUE_SIZE = 1e3;
+var BATCH_SIZE = 50;
+var MAX_PENDING_USAGES = 1e3;
+var SDK_VERSION = "1.3.5";
+var HTTP_TIMEOUT_MS = 1e4;
+var MAX_BACKOFF_MS = 3e4;
+var AiCostCalc = (_class = class _AiCostCalc {
+  
+  
+  
+  
+  
+  
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  __init() {this.flushTimer = null}
+  __init2() {this.shutdownPromise = null}
+  __init3() {this.queue = []}
+  __init4() {this.pendingUsages = []}
+  
+  __init5() {this.apiKeyWarned = false}
+  // Pricing cache
+  __init6() {this.pricingCache = null}
+  __init7() {this.pricingFetchedAt = 0}
+  __init8() {this.pricingPromise = null}
+  __init9() {this.pricingFailedAt = 0}
+  static __initStatic() {this.PRICING_CACHE_TTL_MS = 864e5}
+  // 24 hours
+  static __initStatic2() {this.PRICING_FAILURE_BACKOFF_MS = 6e4}
+  // 60 seconds
+  constructor(config = {}) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);_class.prototype.__init4.call(this);_class.prototype.__init5.call(this);_class.prototype.__init6.call(this);_class.prototype.__init7.call(this);_class.prototype.__init8.call(this);_class.prototype.__init9.call(this);
+    this.apiKey = _nullishCoalesce(_optionalChain([config, 'access', _ => _.apiKey, 'optionalAccess', _2 => _2.trim, 'call', _3 => _3()]), () => ( ""));
+    this.baseUrl = (_nullishCoalesce(config.baseUrl, () => ( DEFAULT_BASE_URL))).replace(/\/+$/, "");
+    this.maxRetries = _nullishCoalesce(config.maxRetries, () => ( DEFAULT_MAX_RETRIES));
+    if (!Number.isInteger(this.maxRetries) || this.maxRetries < 0) {
+      throw new Error("maxRetries must be a non-negative integer");
+    }
+    this.defaultEventType = _nullishCoalesce(config.defaultEventType, () => ( DEFAULT_EVENT_TYPE));
+    this.onError = config.onError;
+    this.debug = _nullishCoalesce(config.debug, () => ( false));
+    if (this.apiKey) {
+      const intervalMs = _nullishCoalesce(config.flushIntervalMs, () => ( DEFAULT_FLUSH_INTERVAL_MS));
+      if (!Number.isFinite(intervalMs) || intervalMs <= 0) {
+        throw new Error("flushIntervalMs must be a finite number > 0");
+      }
+      this.flushTimer = setInterval(() => {
+        void this.flush();
+      }, intervalMs);
+      if (this.flushTimer && typeof this.flushTimer.unref === "function") {
+        this.flushTimer.unref();
+      }
+    }
+    this.boundBeforeExit = () => {
+      void this.shutdown();
+    };
+    if (this.apiKey && typeof process !== "undefined" && typeof process.on === "function") {
+      process.on("beforeExit", this.boundBeforeExit);
+    }
+  }
+  async cost(model, inputOrText, outputOrText) {
+    try {
+      let inputTokens;
+      let outputTokens;
+      let estimated = false;
+      if (typeof inputOrText === "string") {
+        if (outputOrText !== void 0 && typeof outputOrText !== "string") {
+          this.reportError({ message: "outputText must be a string when using text-based estimation" });
+          return null;
+        }
+        const tokenizer = await this.loadTokenizer();
+        if (!tokenizer) return null;
+        inputTokens = tokenizer(inputOrText, model);
+        outputTokens = typeof outputOrText === "string" ? tokenizer(outputOrText, model) : 0;
+        estimated = true;
+      } else if (typeof inputOrText === "number") {
+        if (typeof outputOrText !== "number") {
+          this.reportError({ message: "outputTokens is required when using token counts" });
+          return null;
+        }
+        if (!Number.isInteger(inputOrText) || !Number.isInteger(outputOrText) || inputOrText < 0 || outputOrText < 0) {
+          this.reportError({ message: "Token counts must be non-negative integers" });
+          return null;
+        }
+        inputTokens = inputOrText;
+        outputTokens = outputOrText;
+      } else {
+        this.reportError({ message: "Invalid arguments: pass (model, inputTokens, outputTokens) or (model, inputText, outputText?)" });
+        return null;
+      }
+      await this.ensurePricing();
+      const pricing = _optionalChain([this, 'access', _4 => _4.pricingCache, 'optionalAccess', _5 => _5.get, 'call', _6 => _6(model)]);
+      if (!pricing) return null;
+      const inputCost = inputTokens * pricing.inputPricePer1M / 1e6;
+      const outputCost = outputTokens * pricing.outputPricePer1M / 1e6;
+      return { model, inputCost, outputCost, totalCost: inputCost + outputCost, inputTokens, outputTokens, estimated };
+    } catch (e) {
+      this.reportError({ message: e instanceof Error ? e.message : "Unexpected error in cost()" });
+      return null;
+    }
+  }
+  async loadTokenizer() {
+    try {
+      const { countTokens } = await Promise.resolve().then(() => _interopRequireWildcard(require("./tokenizer.js")));
+      return countTokens;
+    } catch (e2) {
+      this.reportError({ message: "js-tiktoken is required for text-based cost estimation. Install it with: npm install js-tiktoken" });
+      return null;
+    }
+  }
+  addUsage(usage) {
+    if (!this.requireApiKey("addUsage")) return;
+    if (this.pendingUsages.length >= MAX_PENDING_USAGES) {
+      this.log(`pendingUsages limit reached (${MAX_PENDING_USAGES}), dropping oldest entry`);
+      this.pendingUsages.shift();
+    }
+    this.pendingUsages.push(usage);
+  }
+  /**
+   * Enqueue an event for delivery. This method is synchronous and will
+   * never throw -- errors are silently swallowed so that tracking can
+   * never crash the host application.
+   *
+   * All usage entries previously added via {@link addUsage} are drained
+   * and attached to the event.
+   */
+  track(event) {
+    if (!this.requireApiKey("track")) return;
+    if (this.shutdownPromise !== null) return;
+    try {
+      const usages = this.pendingUsages;
+      this.pendingUsages = [];
+      const wire = this.toWireEvent(event, usages);
+      this.enqueue(wire);
+      this.log(`event enqueued (queue: ${this.queue.length})`);
+    } catch (err) {
+      this.reportError({ message: "Failed to enqueue event", cause: err });
+    }
+  }
+  /**
+   * Flush all queued events to the API immediately.
+   */
+  async flush() {
+    if (!this.apiKey) return;
+    const batches = this.drain();
+    if (batches.length === 0) return;
+    const eventCount = batches.reduce((sum, b) => sum + b.length, 0);
+    this.log(`flushing ${eventCount} ${eventCount === 1 ? "event" : "events"} in ${batches.length} ${batches.length === 1 ? "batch" : "batches"}`);
+    await Promise.allSettled(batches.map((batch) => this.sendBatch(batch)));
+  }
+  /**
+   * Flush remaining events and stop the background timer.
+   * Call this before your process exits.
+   */
+  async shutdown() {
+    if (!this.apiKey) return;
+    if (this.shutdownPromise !== null) return this.shutdownPromise;
+    this.shutdownPromise = (async () => {
+      if (typeof process !== "undefined" && typeof process.removeListener === "function") {
+        process.removeListener("beforeExit", this.boundBeforeExit);
+      }
+      if (this.flushTimer !== null) {
+        clearInterval(this.flushTimer);
+        this.flushTimer = null;
+      }
+      await this.flush();
+    })();
+    return this.shutdownPromise;
+  }
+  // ---------------------------------------------------------------------------
+  // API key guard
+  // ---------------------------------------------------------------------------
+  requireApiKey(method) {
+    if (this.apiKey) return true;
+    if (!this.apiKeyWarned) {
+      this.reportError({ message: `apiKey required for ${method} \u2014 calls will be skipped` });
+      this.apiKeyWarned = true;
+    }
+    return false;
+  }
+  // ---------------------------------------------------------------------------
+  // Pricing
+  // ---------------------------------------------------------------------------
+  async ensurePricing() {
+    const now = Date.now();
+    if (this.pricingCache && now - this.pricingFetchedAt < _AiCostCalc.PRICING_CACHE_TTL_MS) {
+      return;
+    }
+    if (this.pricingFailedAt && now - this.pricingFailedAt < _AiCostCalc.PRICING_FAILURE_BACKOFF_MS) {
+      return;
+    }
+    if (this.pricingPromise) return this.pricingPromise;
+    this.pricingPromise = (async () => {
+      try {
+        const res = await fetch(`${this.baseUrl}/models`, {
+          headers: { "User-Agent": `ai-cost-calc-node/${SDK_VERSION}` },
+          signal: AbortSignal.timeout(HTTP_TIMEOUT_MS)
+        });
+        if (!res.ok) throw new Error(`status ${res.status}`);
+        const data = await res.json();
+        const map = /* @__PURE__ */ new Map();
+        if (Array.isArray(data.vendors)) {
+          for (const vendor of data.vendors) {
+            if (typeof vendor !== "object" || vendor === null) continue;
+            if (!Array.isArray(vendor.models)) continue;
+            for (const m of vendor.models) {
+              if (typeof m !== "object" || m === null) continue;
+              const input = m.input_price_per_1m;
+              const output = m.output_price_per_1m;
+              if (!m.slug || !Number.isFinite(input) || !Number.isFinite(output)) continue;
+              map.set(m.slug, {
+                slug: m.slug,
+                inputPricePer1M: input,
+                outputPricePer1M: output
+              });
+            }
+          }
+        }
+        this.pricingCache = map;
+        this.pricingFetchedAt = Date.now();
+        this.pricingFailedAt = 0;
+        this.log(`pricing loaded (${map.size} models)`);
+      } catch (err) {
+        this.pricingFailedAt = Date.now();
+        this.reportError({ message: "Failed to fetch pricing data", cause: err });
+      } finally {
+        this.pricingPromise = null;
+      }
+    })();
+    return this.pricingPromise;
+  }
+  // ---------------------------------------------------------------------------
+  // Queue
+  // ---------------------------------------------------------------------------
+  enqueue(event) {
+    if (this.queue.length >= MAX_QUEUE_SIZE) {
+      this.queue.shift();
+      this.log(`queue full (${MAX_QUEUE_SIZE}), dropping oldest event`);
+    }
+    this.queue.push(event);
+  }
+  drain() {
+    if (this.queue.length === 0) return [];
+    const all = this.queue;
+    this.queue = [];
+    const batches = [];
+    for (let i = 0; i < all.length; i += BATCH_SIZE) {
+      batches.push(all.slice(i, i + BATCH_SIZE));
+    }
+    return batches;
+  }
+  // ---------------------------------------------------------------------------
+  // Serialization
+  // ---------------------------------------------------------------------------
+  toWireEvent(event, usages) {
+    const wire = {
+      customer_id: event.customerId,
+      revenue_amount_in_cents: _nullishCoalesce(event.revenueAmountInCents, () => ( null)),
+      vendor_responses: usages.map((u) => ({
+        vendor_name: u.vendor,
+        ai_model_name: u.model,
+        input_tokens: u.inputTokens,
+        output_tokens: u.outputTokens
+      })),
+      unique_request_token: _nullishCoalesce(event.uniqueRequestToken, () => ( crypto.randomUUID())),
+      event_type: _nullishCoalesce(event.eventType, () => ( this.defaultEventType)),
+      occurred_at: _nullishCoalesce(event.occurredAt, () => ( (/* @__PURE__ */ new Date()).toISOString()))
+    };
+    return wire;
+  }
+  // ---------------------------------------------------------------------------
+  // HTTP
+  // ---------------------------------------------------------------------------
+  async fetchWithRetry(url, init) {
+    let lastError;
+    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+      try {
+        const res = await fetch(url, init);
+        if (res.status >= 500 || res.status === 429) {
+          lastError = res;
+        } else {
+          return res;
+        }
+      } catch (err) {
+        lastError = err;
+      }
+      if (attempt < this.maxRetries) {
+        const status = lastError instanceof Response ? `status ${lastError.status}` : "network error";
+        this.log(`${status}, retrying (${attempt + 1}/${this.maxRetries})`);
+        const base = Math.min(1e3 * 2 ** attempt, MAX_BACKOFF_MS);
+        await new Promise((r) => setTimeout(r, base + Math.random() * base * 0.5));
+      }
+    }
+    throw lastError;
+  }
+  async sendBatch(events) {
+    try {
+      const response = await this.fetchWithRetry(`${this.baseUrl}/events`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.apiKey}`,
+          "User-Agent": `ai-cost-calc-node/${SDK_VERSION}`
+        },
+        body: JSON.stringify({ events }),
+        signal: AbortSignal.timeout(HTTP_TIMEOUT_MS)
+      });
+      this.log(`batch sent (status ${response.status}, ${events.length} ${events.length === 1 ? "event" : "events"})`);
+      if (!response.ok) {
+        let body = "";
+        try {
+          body = await response.text();
+        } catch (e3) {
+        }
+        this.reportError({ message: `Request failed with status ${response.status}: ${body}` });
+      }
+    } catch (err) {
+      const message = err instanceof Response ? `Request failed after retries (status ${err.status})` : "Request failed after retries";
+      this.reportError({ message, cause: err });
+    }
+  }
+  reportError(error) {
+    if (this.debug) console.error(`[ai-cost-calc] ${error.message}`);
+    if (!this.onError) return;
+    try {
+      this.onError(error);
+    } catch (e4) {
+    }
+  }
+  log(msg) {
+    if (this.debug) console.debug(`[ai-cost-calc] ${msg}`);
+  }
+}, _class.__initStatic(), _class.__initStatic2(), _class);
+
+
+exports.AiCostCalc = AiCostCalc;

package/dist/index.mjs

@@ -0,0 +1,339 @@
+// src/client.ts
+var DEFAULT_BASE_URL = "https://margindash.com/api/v1";
+var DEFAULT_FLUSH_INTERVAL_MS = 5e3;
+var DEFAULT_MAX_RETRIES = 3;
+var DEFAULT_EVENT_TYPE = "ai_request";
+var MAX_QUEUE_SIZE = 1e3;
+var BATCH_SIZE = 50;
+var MAX_PENDING_USAGES = 1e3;
+var SDK_VERSION = "1.3.5";
+var HTTP_TIMEOUT_MS = 1e4;
+var MAX_BACKOFF_MS = 3e4;
+var AiCostCalc = class _AiCostCalc {
+  apiKey;
+  baseUrl;
+  maxRetries;
+  defaultEventType;
+  onError;
+  debug;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  flushTimer = null;
+  shutdownPromise = null;
+  queue = [];
+  pendingUsages = [];
+  boundBeforeExit;
+  apiKeyWarned = false;
+  // Pricing cache
+  pricingCache = null;
+  pricingFetchedAt = 0;
+  pricingPromise = null;
+  pricingFailedAt = 0;
+  static PRICING_CACHE_TTL_MS = 864e5;
+  // 24 hours
+  static PRICING_FAILURE_BACKOFF_MS = 6e4;
+  // 60 seconds
+  constructor(config = {}) {
+    this.apiKey = config.apiKey?.trim() ?? "";
+    this.baseUrl = (config.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+    this.maxRetries = config.maxRetries ?? DEFAULT_MAX_RETRIES;
+    if (!Number.isInteger(this.maxRetries) || this.maxRetries < 0) {
+      throw new Error("maxRetries must be a non-negative integer");
+    }
+    this.defaultEventType = config.defaultEventType ?? DEFAULT_EVENT_TYPE;
+    this.onError = config.onError;
+    this.debug = config.debug ?? false;
+    if (this.apiKey) {
+      const intervalMs = config.flushIntervalMs ?? DEFAULT_FLUSH_INTERVAL_MS;
+      if (!Number.isFinite(intervalMs) || intervalMs <= 0) {
+        throw new Error("flushIntervalMs must be a finite number > 0");
+      }
+      this.flushTimer = setInterval(() => {
+        void this.flush();
+      }, intervalMs);
+      if (this.flushTimer && typeof this.flushTimer.unref === "function") {
+        this.flushTimer.unref();
+      }
+    }
+    this.boundBeforeExit = () => {
+      void this.shutdown();
+    };
+    if (this.apiKey && typeof process !== "undefined" && typeof process.on === "function") {
+      process.on("beforeExit", this.boundBeforeExit);
+    }
+  }
+  async cost(model, inputOrText, outputOrText) {
+    try {
+      let inputTokens;
+      let outputTokens;
+      let estimated = false;
+      if (typeof inputOrText === "string") {
+        if (outputOrText !== void 0 && typeof outputOrText !== "string") {
+          this.reportError({ message: "outputText must be a string when using text-based estimation" });
+          return null;
+        }
+        const tokenizer = await this.loadTokenizer();
+        if (!tokenizer) return null;
+        inputTokens = tokenizer(inputOrText, model);
+        outputTokens = typeof outputOrText === "string" ? tokenizer(outputOrText, model) : 0;
+        estimated = true;
+      } else if (typeof inputOrText === "number") {
+        if (typeof outputOrText !== "number") {
+          this.reportError({ message: "outputTokens is required when using token counts" });
+          return null;
+        }
+        if (!Number.isInteger(inputOrText) || !Number.isInteger(outputOrText) || inputOrText < 0 || outputOrText < 0) {
+          this.reportError({ message: "Token counts must be non-negative integers" });
+          return null;
+        }
+        inputTokens = inputOrText;
+        outputTokens = outputOrText;
+      } else {
+        this.reportError({ message: "Invalid arguments: pass (model, inputTokens, outputTokens) or (model, inputText, outputText?)" });
+        return null;
+      }
+      await this.ensurePricing();
+      const pricing = this.pricingCache?.get(model);
+      if (!pricing) return null;
+      const inputCost = inputTokens * pricing.inputPricePer1M / 1e6;
+      const outputCost = outputTokens * pricing.outputPricePer1M / 1e6;
+      return { model, inputCost, outputCost, totalCost: inputCost + outputCost, inputTokens, outputTokens, estimated };
+    } catch (e) {
+      this.reportError({ message: e instanceof Error ? e.message : "Unexpected error in cost()" });
+      return null;
+    }
+  }
+  async loadTokenizer() {
+    try {
+      const { countTokens } = await import("./tokenizer.mjs");
+      return countTokens;
+    } catch {
+      this.reportError({ message: "js-tiktoken is required for text-based cost estimation. Install it with: npm install js-tiktoken" });
+      return null;
+    }
+  }
+  addUsage(usage) {
+    if (!this.requireApiKey("addUsage")) return;
+    if (this.pendingUsages.length >= MAX_PENDING_USAGES) {
+      this.log(`pendingUsages limit reached (${MAX_PENDING_USAGES}), dropping oldest entry`);
+      this.pendingUsages.shift();
+    }
+    this.pendingUsages.push(usage);
+  }
+  /**
+   * Enqueue an event for delivery. This method is synchronous and will
+   * never throw -- errors are silently swallowed so that tracking can
+   * never crash the host application.
+   *
+   * All usage entries previously added via {@link addUsage} are drained
+   * and attached to the event.
+   */
+  track(event) {
+    if (!this.requireApiKey("track")) return;
+    if (this.shutdownPromise !== null) return;
+    try {
+      const usages = this.pendingUsages;
+      this.pendingUsages = [];
+      const wire = this.toWireEvent(event, usages);
+      this.enqueue(wire);
+      this.log(`event enqueued (queue: ${this.queue.length})`);
+    } catch (err) {
+      this.reportError({ message: "Failed to enqueue event", cause: err });
+    }
+  }
+  /**
+   * Flush all queued events to the API immediately.
+   */
+  async flush() {
+    if (!this.apiKey) return;
+    const batches = this.drain();
+    if (batches.length === 0) return;
+    const eventCount = batches.reduce((sum, b) => sum + b.length, 0);
+    this.log(`flushing ${eventCount} ${eventCount === 1 ? "event" : "events"} in ${batches.length} ${batches.length === 1 ? "batch" : "batches"}`);
+    await Promise.allSettled(batches.map((batch) => this.sendBatch(batch)));
+  }
+  /**
+   * Flush remaining events and stop the background timer.
+   * Call this before your process exits.
+   */
+  async shutdown() {
+    if (!this.apiKey) return;
+    if (this.shutdownPromise !== null) return this.shutdownPromise;
+    this.shutdownPromise = (async () => {
+      if (typeof process !== "undefined" && typeof process.removeListener === "function") {
+        process.removeListener("beforeExit", this.boundBeforeExit);
+      }
+      if (this.flushTimer !== null) {
+        clearInterval(this.flushTimer);
+        this.flushTimer = null;
+      }
+      await this.flush();
+    })();
+    return this.shutdownPromise;
+  }
+  // ---------------------------------------------------------------------------
+  // API key guard
+  // ---------------------------------------------------------------------------
+  requireApiKey(method) {
+    if (this.apiKey) return true;
+    if (!this.apiKeyWarned) {
+      this.reportError({ message: `apiKey required for ${method} \u2014 calls will be skipped` });
+      this.apiKeyWarned = true;
+    }
+    return false;
+  }
+  // ---------------------------------------------------------------------------
+  // Pricing
+  // ---------------------------------------------------------------------------
+  async ensurePricing() {
+    const now = Date.now();
+    if (this.pricingCache && now - this.pricingFetchedAt < _AiCostCalc.PRICING_CACHE_TTL_MS) {
+      return;
+    }
+    if (this.pricingFailedAt && now - this.pricingFailedAt < _AiCostCalc.PRICING_FAILURE_BACKOFF_MS) {
+      return;
+    }
+    if (this.pricingPromise) return this.pricingPromise;
+    this.pricingPromise = (async () => {
+      try {
+        const res = await fetch(`${this.baseUrl}/models`, {
+          headers: { "User-Agent": `ai-cost-calc-node/${SDK_VERSION}` },
+          signal: AbortSignal.timeout(HTTP_TIMEOUT_MS)
+        });
+        if (!res.ok) throw new Error(`status ${res.status}`);
+        const data = await res.json();
+        const map = /* @__PURE__ */ new Map();
+        if (Array.isArray(data.vendors)) {
+          for (const vendor of data.vendors) {
+            if (typeof vendor !== "object" || vendor === null) continue;
+            if (!Array.isArray(vendor.models)) continue;
+            for (const m of vendor.models) {
+              if (typeof m !== "object" || m === null) continue;
+              const input = m.input_price_per_1m;
+              const output = m.output_price_per_1m;
+              if (!m.slug || !Number.isFinite(input) || !Number.isFinite(output)) continue;
+              map.set(m.slug, {
+                slug: m.slug,
+                inputPricePer1M: input,
+                outputPricePer1M: output
+              });
+            }
+          }
+        }
+        this.pricingCache = map;
+        this.pricingFetchedAt = Date.now();
+        this.pricingFailedAt = 0;
+        this.log(`pricing loaded (${map.size} models)`);
+      } catch (err) {
+        this.pricingFailedAt = Date.now();
+        this.reportError({ message: "Failed to fetch pricing data", cause: err });
+      } finally {
+        this.pricingPromise = null;
+      }
+    })();
+    return this.pricingPromise;
+  }
+  // ---------------------------------------------------------------------------
+  // Queue
+  // ---------------------------------------------------------------------------
+  enqueue(event) {
+    if (this.queue.length >= MAX_QUEUE_SIZE) {
+      this.queue.shift();
+      this.log(`queue full (${MAX_QUEUE_SIZE}), dropping oldest event`);
+    }
+    this.queue.push(event);
+  }
+  drain() {
+    if (this.queue.length === 0) return [];
+    const all = this.queue;
+    this.queue = [];
+    const batches = [];
+    for (let i = 0; i < all.length; i += BATCH_SIZE) {
+      batches.push(all.slice(i, i + BATCH_SIZE));
+    }
+    return batches;
+  }
+  // ---------------------------------------------------------------------------
+  // Serialization
+  // ---------------------------------------------------------------------------
+  toWireEvent(event, usages) {
+    const wire = {
+      customer_id: event.customerId,
+      revenue_amount_in_cents: event.revenueAmountInCents ?? null,
+      vendor_responses: usages.map((u) => ({
+        vendor_name: u.vendor,
+        ai_model_name: u.model,
+        input_tokens: u.inputTokens,
+        output_tokens: u.outputTokens
+      })),
+      unique_request_token: event.uniqueRequestToken ?? crypto.randomUUID(),
+      event_type: event.eventType ?? this.defaultEventType,
+      occurred_at: event.occurredAt ?? (/* @__PURE__ */ new Date()).toISOString()
+    };
+    return wire;
+  }
+  // ---------------------------------------------------------------------------
+  // HTTP
+  // ---------------------------------------------------------------------------
+  async fetchWithRetry(url, init) {
+    let lastError;
+    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+      try {
+        const res = await fetch(url, init);
+        if (res.status >= 500 || res.status === 429) {
+          lastError = res;
+        } else {
+          return res;
+        }
+      } catch (err) {
+        lastError = err;
+      }
+      if (attempt < this.maxRetries) {
+        const status = lastError instanceof Response ? `status ${lastError.status}` : "network error";
+        this.log(`${status}, retrying (${attempt + 1}/${this.maxRetries})`);
+        const base = Math.min(1e3 * 2 ** attempt, MAX_BACKOFF_MS);
+        await new Promise((r) => setTimeout(r, base + Math.random() * base * 0.5));
+      }
+    }
+    throw lastError;
+  }
+  async sendBatch(events) {
+    try {
+      const response = await this.fetchWithRetry(`${this.baseUrl}/events`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.apiKey}`,
+          "User-Agent": `ai-cost-calc-node/${SDK_VERSION}`
+        },
+        body: JSON.stringify({ events }),
+        signal: AbortSignal.timeout(HTTP_TIMEOUT_MS)
+      });
+      this.log(`batch sent (status ${response.status}, ${events.length} ${events.length === 1 ? "event" : "events"})`);
+      if (!response.ok) {
+        let body = "";
+        try {
+          body = await response.text();
+        } catch {
+        }
+        this.reportError({ message: `Request failed with status ${response.status}: ${body}` });
+      }
+    } catch (err) {
+      const message = err instanceof Response ? `Request failed after retries (status ${err.status})` : "Request failed after retries";
+      this.reportError({ message, cause: err });
+    }
+  }
+  reportError(error) {
+    if (this.debug) console.error(`[ai-cost-calc] ${error.message}`);
+    if (!this.onError) return;
+    try {
+      this.onError(error);
+    } catch {
+    }
+  }
+  log(msg) {
+    if (this.debug) console.debug(`[ai-cost-calc] ${msg}`);
+  }
+};
+export {
+  AiCostCalc
+};

package/dist/tokenizer.d.mts

@@ -0,0 +1,3 @@
+declare function countTokens(text: string, model: string): number;
+
+export { countTokens };

package/dist/tokenizer.d.ts

@@ -0,0 +1,3 @@
+declare function countTokens(text: string, model: string): number;
+
+export { countTokens };

package/dist/tokenizer.js

@@ -0,0 +1,25 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/tokenizer.ts
+var _jstiktoken = require('js-tiktoken');
+var cache = /* @__PURE__ */ new Map();
+var MAX_CACHE_SIZE = 128;
+var MAX_TEXT_LENGTH = 1e6;
+function countTokens(text, model) {
+  if (text.length > MAX_TEXT_LENGTH) throw new Error("Text exceeds 1MB limit");
+  let enc = cache.get(model);
+  if (!enc) {
+    if (cache.size >= MAX_CACHE_SIZE) {
+      const firstKey = cache.keys().next().value;
+      cache.delete(firstKey);
+    }
+    try {
+      enc = _jstiktoken.encodingForModel.call(void 0, model);
+    } catch (e) {
+      enc = _jstiktoken.getEncoding.call(void 0, "cl100k_base");
+    }
+    cache.set(model, enc);
+  }
+  return enc.encode(text).length;
+}
+
+
+exports.countTokens = countTokens;

package/dist/tokenizer.mjs

@@ -0,0 +1,25 @@
+// src/tokenizer.ts
+import { encodingForModel, getEncoding } from "js-tiktoken";
+var cache = /* @__PURE__ */ new Map();
+var MAX_CACHE_SIZE = 128;
+var MAX_TEXT_LENGTH = 1e6;
+function countTokens(text, model) {
+  if (text.length > MAX_TEXT_LENGTH) throw new Error("Text exceeds 1MB limit");
+  let enc = cache.get(model);
+  if (!enc) {
+    if (cache.size >= MAX_CACHE_SIZE) {
+      const firstKey = cache.keys().next().value;
+      cache.delete(firstKey);
+    }
+    try {
+      enc = encodingForModel(model);
+    } catch {
+      enc = getEncoding("cl100k_base");
+    }
+    cache.set(model, enc);
+  }
+  return enc.encode(text).length;
+}
+export {
+  countTokens
+};

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "ai-cost-calc",
+  "version": "1.3.5",
+  "description": "AI cost calculator and usage tracker. Calculate LLM API costs for 400+ models (OpenAI, Anthropic, Google). No API key required for cost lookups.",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsup",
+    "test": "tsx --test tests/client.test.ts",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist"
+  },
+  "keywords": [
+    "ai-cost",
+    "llm-cost",
+    "llm-pricing",
+    "token-cost",
+    "openai-cost",
+    "openai-pricing",
+    "anthropic-pricing",
+    "ai-usage",
+    "cost-tracker",
+    "cost-calculator",
+    "model-pricing",
+    "token-pricing",
+    "ai-billing",
+    "llm-usage",
+    "api-cost"
+  ],
+  "license": "MIT",
+  "optionalDependencies": {
+    "js-tiktoken": "^1.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.1.0",
+    "tsup": "^8.0.0",
+    "tsx": "^4.21.0",
+    "typescript": "^5.4.0"
+  }
+}