@pydantic/genai-prices 0.0.6

package/dist/matcher.d.ts

@@ -0,0 +1,3 @@
+import { Provider, ModelInfo } from './types.js';
+export declare function matchProvider(providers: Provider[], modelRef: string, providerId?: string, providerApiUrl?: string): Provider | undefined;
+export declare function matchModel(models: ModelInfo[], modelRef: string): ModelInfo | undefined;

package/dist/matcher.js

@@ -0,0 +1,37 @@
+function matchLogic(logic, text) {
+    if ('or' in logic) {
+        return logic.or.some((clause) => matchLogic(clause, text));
+    }
+    if ('and' in logic) {
+        return logic.and.every((clause) => matchLogic(clause, text));
+    }
+    if ('equals' in logic) {
+        return text === logic.equals;
+    }
+    if ('starts_with' in logic) {
+        return text.startsWith(logic.starts_with);
+    }
+    if ('ends_with' in logic) {
+        return text.endsWith(logic.ends_with);
+    }
+    if ('contains' in logic) {
+        return text.includes(logic.contains);
+    }
+    if ('regex' in logic) {
+        return new RegExp(logic.regex).test(text);
+    }
+    return false;
+}
+export function matchProvider(providers, modelRef, providerId, providerApiUrl) {
+    if (providerId) {
+        return providers.find((p) => p.id === providerId);
+    }
+    if (providerApiUrl) {
+        return providers.find((p) => new RegExp(p.api_pattern).test(providerApiUrl));
+    }
+    // Try model_match logic
+    return providers.find((p) => p.model_match && matchLogic(p.model_match, modelRef));
+}
+export function matchModel(models, modelRef) {
+    return models.find((m) => matchLogic(m.match, modelRef));
+}

package/dist/priceCalc.d.ts

@@ -0,0 +1,3 @@
+import { Usage, ModelPrice, ModelInfo } from './types.js';
+export declare function calcPrice(usage: Usage, modelPrice: ModelPrice): number;
+export declare function getActiveModelPrice(model: ModelInfo, timestamp: Date): ModelPrice;

package/dist/priceCalc.js

@@ -0,0 +1,68 @@
+function calcTieredPrice(tiered, tokens) {
+    if (tokens <= 0)
+        return 0;
+    let price = 0;
+    // Sort tiers by start ascending
+    const tiers = [...tiered.tiers].sort((a, b) => a.start - b.start);
+    // Base price for tokens up to the first tier start
+    const firstTierStart = tiers[0]?.start ?? tokens;
+    const baseTokens = Math.min(tokens, firstTierStart);
+    price += (baseTokens * tiered.base) / 1_000_000;
+    // Price for each tier
+    for (let i = 0; i < tiers.length; i++) {
+        const tier = tiers[i];
+        const nextTierStart = tiers[i + 1]?.start ?? Infinity;
+        // Tokens in this tier: from tier.start up to nextTierStart or tokens
+        const tierTokenCount = Math.max(0, Math.min(tokens, nextTierStart) - tier.start);
+        if (tierTokenCount > 0) {
+            price += (tierTokenCount * tier.price) / 1_000_000;
+        }
+    }
+    return price;
+}
+function calcMtokPrice(price, tokens, _field) {
+    if (price === undefined || tokens === undefined)
+        return 0;
+    if (typeof price === 'number') {
+        return (price * tokens) / 1_000_000;
+    }
+    return calcTieredPrice(price, tokens);
+}
+export function calcPrice(usage, modelPrice) {
+    let price = 0;
+    price += calcMtokPrice(modelPrice.input_mtok, usage.input_tokens, 'input_mtok');
+    price += calcMtokPrice(modelPrice.cache_write_mtok, usage.cache_write_tokens, 'cache_write_mtok');
+    price += calcMtokPrice(modelPrice.cache_read_mtok, usage.cache_read_tokens, 'cache_read_mtok');
+    price += calcMtokPrice(modelPrice.output_mtok, usage.output_tokens, 'output_mtok');
+    price += calcMtokPrice(modelPrice.input_audio_mtok, usage.input_audio_tokens, 'input_audio_mtok');
+    price += calcMtokPrice(modelPrice.cache_audio_read_mtok, usage.cache_audio_read_tokens, 'cache_audio_read_mtok');
+    price += calcMtokPrice(modelPrice.output_audio_mtok, usage.output_audio_tokens, 'output_audio_mtok');
+    if (modelPrice.requests_kcount !== undefined) {
+        price += modelPrice.requests_kcount * ((usage.requests ?? 1) / 1000);
+    }
+    return price;
+}
+export function getActiveModelPrice(model, timestamp) {
+    if (!Array.isArray(model.prices)) {
+        return model.prices;
+    }
+    // Conditional prices: last active wins
+    for (let i = model.prices.length - 1; i >= 0; i--) {
+        const cond = model.prices[i];
+        if (!cond.constraint)
+            return cond.prices;
+        if (cond.constraint.type === 'start_date') {
+            if (timestamp >= new Date(cond.constraint.start_date)) {
+                return cond.prices;
+            }
+        }
+        else if (cond.constraint.type === 'time_of_date') {
+            const t = timestamp.toTimeString().slice(0, 8);
+            if (t >= cond.constraint.start_time && t < cond.constraint.end_time) {
+                return cond.prices;
+            }
+        }
+    }
+    // Fallback to first
+    return model.prices[0].prices;
+}

package/dist/sync/calcPriceSync.d.ts

@@ -0,0 +1,8 @@
+import { Usage, PriceCalculationResult } from '../types.js';
+export type { Usage, PriceCalculation, PriceCalculationResult } from '../types.js';
+export interface CalcPriceOptions {
+    providerId?: string;
+    providerApiUrl?: string;
+    timestamp?: Date;
+}
+export declare function calcPriceSync(usage: Usage, modelRef: string, options?: CalcPriceOptions): PriceCalculationResult;

package/dist/sync/calcPriceSync.js

@@ -0,0 +1,22 @@
+import { getProvidersSync } from '../dataLoader.js';
+import { matchProvider, matchModel } from '../matcher.js';
+import { calcPrice as calcModelPrice, getActiveModelPrice } from '../priceCalc.js';
+export function calcPriceSync(usage, modelRef, options = {}) {
+    const providers = getProvidersSync();
+    const provider = matchProvider(providers, modelRef, options.providerId, options.providerApiUrl);
+    if (!provider)
+        return null;
+    const model = matchModel(provider.models, modelRef);
+    if (!model)
+        return null;
+    const timestamp = options.timestamp || new Date();
+    const model_price = getActiveModelPrice(model, timestamp);
+    const price = calcModelPrice(usage, model_price);
+    return {
+        price,
+        provider,
+        model,
+        model_price,
+        auto_update_timestamp: undefined,
+    };
+}

package/dist/types.d.ts

@@ -0,0 +1,88 @@
+export interface Usage {
+    input_tokens?: number;
+    cache_write_tokens?: number;
+    cache_read_tokens?: number;
+    output_tokens?: number;
+    input_audio_tokens?: number;
+    cache_audio_read_tokens?: number;
+    output_audio_tokens?: number;
+    requests?: number;
+}
+export interface Tier {
+    start: number;
+    price: number;
+}
+export interface TieredPrices {
+    base: number;
+    tiers: Tier[];
+}
+export interface ModelPrice {
+    input_mtok?: number | TieredPrices;
+    cache_write_mtok?: number | TieredPrices;
+    cache_read_mtok?: number | TieredPrices;
+    output_mtok?: number | TieredPrices;
+    input_audio_mtok?: number | TieredPrices;
+    cache_audio_read_mtok?: number | TieredPrices;
+    output_audio_mtok?: number | TieredPrices;
+    requests_kcount?: number;
+}
+export interface ConditionalPrice {
+    constraint?: StartDateConstraint | TimeOfDateConstraint;
+    prices: ModelPrice;
+}
+export interface StartDateConstraint {
+    start_date: string;
+    type: 'start_date';
+}
+export interface TimeOfDateConstraint {
+    start_time: string;
+    end_time: string;
+    type: 'time_of_date';
+}
+export type MatchLogic = {
+    starts_with: string;
+} | {
+    ends_with: string;
+} | {
+    contains: string;
+} | {
+    equals: string;
+} | {
+    regex: string;
+} | {
+    or: MatchLogic[];
+} | {
+    and: MatchLogic[];
+};
+export interface ModelInfo {
+    id: string;
+    match: MatchLogic;
+    name?: string;
+    description?: string;
+    context_window?: number;
+    price_comments?: string;
+    prices: ModelPrice | ConditionalPrice[];
+}
+export interface Provider {
+    id: string;
+    name: string;
+    api_pattern: string;
+    pricing_urls?: string[];
+    description?: string;
+    price_comments?: string;
+    model_match?: MatchLogic;
+    models: ModelInfo[];
+}
+export interface PriceCalculation {
+    price: number;
+    provider: Provider;
+    model: ModelInfo;
+    model_price: ModelPrice;
+    auto_update_timestamp?: string;
+}
+export type PriceCalculationResult = PriceCalculation | null;
+export type PriceDataStorage = {
+    get: () => Promise<string | null>;
+    set: (data: string) => Promise<void>;
+    get_last_modified?: () => Promise<number | null>;
+};

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "@pydantic/genai-prices",
+  "version": "0.0.6",
+  "description": "Calculate prices for calling LLM inference APIs (JS/TS version of genai-prices)",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    }
+  },
+  "files": [
+    "dist",
+    "LICENSE"
+  ],
+  "bin": {
+    "genai-prices": "dist/cli.js"
+  },
+  "scripts": {
+    "build": "vite build && npm run build:cli",
+    "build:cli": "tsc src/cli.ts --outDir dist --module nodenext --esModuleInterop --skipLibCheck",
+    "postbuild": "if ! head -n1 dist/cli.js | grep -q '^#!/usr/bin/env node$'; then echo '#!/usr/bin/env node' | cat - dist/cli.js > dist/cli.tmp && mv dist/cli.tmp dist/cli.js; fi && chmod +x dist/cli.js",
+    "dev": "vite build --watch",
+    "typecheck": "tsc",
+    "test": "vitest run",
+    "test:ui": "vitest --ui",
+    "prepare": "npm run build"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/pydantic/genai-prices"
+  },
+  "author": "Pydantic Team",
+  "license": "MIT",
+  "dependencies": {
+    "node-fetch": "^3.3.2",
+    "yargs": "^17.7.2"
+  },
+  "devDependencies": {
+    "@changesets/cli": "^2.29.5",
+    "@types/node": "^20.0.0",
+    "@types/yargs": "^17.0.24",
+    "@vitest/ui": "^3.2.4",
+    "typescript": "^5.0.0",
+    "vite": "^5.1.3",
+    "vite-plugin-dts": "^4.5.3",
+    "vitest": "^3.2.4"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "browser": {
+    "node-fetch": false
+  },
+  "type": "module",
+  "optionalDependencies": {
+    "@rollup/rollup-linux-x64-gnu": "^4.9.5"
+  }
+}