ai-sdk-cost-calculator 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 agos
+
+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,317 @@
+# ai-sdk-cost-calculator
+
+Cost calculator for [Vercel AI SDK](https://sdk.vercel.ai/) token usage. Calculate API costs for OpenAI, Anthropic, Google, xAI (Grok), and DeepSeek with support for long context pricing, prompt caching, and reasoning tokens.
+
+## Features
+
+- **Multi-provider support**: OpenAI, Anthropic, Google Gemini, xAI Grok, DeepSeek
+- **AI SDK integration**: Works directly with `LanguageModelUsage` from AI SDK
+- **Long context pricing**: Automatic tier-based pricing (e.g., Claude Sonnet 4.5 >200K tokens)
+- **Prompt caching**: Separate pricing for cache reads and writes
+- **Reasoning tokens**: Support for o1/o3/R1 reasoning model costs
+- **Cost tracking**: Track cumulative costs across multiple requests
+- **TypeScript**: Full type definitions included
+
+## Installation
+
+```bash
+npm install ai-sdk-cost-calculator
+```
+
+**Peer dependency**: Requires `ai` (Vercel AI SDK) version 6.0.0 or higher.
+
+```bash
+npm install ai
+```
+
+## Quick Start
+
+```typescript
+import { generateText } from "ai";
+import { openai } from "@ai-sdk/openai";
+import { calculateCost, formatCost } from "ai-sdk-cost-calculator";
+
+const result = await generateText({
+  model: openai("gpt-4o"),
+  prompt: "Hello, world!",
+});
+
+const cost = calculateCost({
+  provider: "openai",
+  modelId: "gpt-4o",
+  usage: result.usage,
+});
+
+console.log(`Total cost: ${formatCost(cost.totalCost)}`);
+// Output: Total cost: $0.000150
+```
+
+## API Reference
+
+### `calculateCost(options)`
+
+Calculate the cost for a single API request.
+
+```typescript
+import { calculateCost } from "ai-sdk-cost-calculator";
+
+const cost = calculateCost({
+  provider: "anthropic",
+  modelId: "claude-sonnet-4-5",
+  usage: {
+    inputTokens: 1000,
+    outputTokens: 500,
+    inputTokenDetails: {
+      cacheReadTokens: 200,
+      cacheWriteTokens: 100,
+    },
+    outputTokenDetails: {
+      reasoningTokens: 0,
+    },
+  },
+});
+
+console.log(cost);
+// {
+//   inputCost: 0.0024,
+//   outputCost: 0.0075,
+//   cacheReadCost: 0.00006,
+//   cacheWriteCost: 0.000375,
+//   reasoningCost: 0,
+//   totalCost: 0.010335,
+//   currency: "USD",
+//   isLongContext: false
+// }
+```
+
+#### Options
+
+| Property | Type | Required | Description |
+|----------|------|----------|-------------|
+| `provider` | `string` | Yes | Provider name: `"openai"`, `"anthropic"`, `"google"`, `"xai"`, `"deepseek"` |
+| `modelId` | `string` | Yes | Model identifier (e.g., `"gpt-4o"`, `"claude-sonnet-4-5"`) |
+| `usage` | `LanguageModelUsage` | Yes | Token usage from AI SDK |
+| `customPricing` | `ModelPricing` | No | Override default pricing |
+
+#### Return Value: `CostBreakdown`
+
+| Property | Type | Description |
+|----------|------|-------------|
+| `inputCost` | `number` | Cost for input tokens (excluding cache) |
+| `outputCost` | `number` | Cost for output tokens (excluding reasoning) |
+| `cacheReadCost` | `number` | Cost for cached input tokens |
+| `cacheWriteCost` | `number` | Cost for writing to cache |
+| `reasoningCost` | `number` | Cost for reasoning tokens |
+| `totalCost` | `number` | Sum of all costs |
+| `currency` | `"USD"` | Always USD |
+| `isLongContext` | `boolean` | Whether long context pricing was applied |
+
+### `formatCost(cost, decimals?)`
+
+Format a cost value as a currency string.
+
+```typescript
+import { formatCost } from "ai-sdk-cost-calculator";
+
+formatCost(0.0015);      // "$0.001500"
+formatCost(0.0015, 4);   // "$0.0015"
+```
+
+### `formatCostBreakdown(breakdown, decimals?)`
+
+Format a full cost breakdown as a multi-line string.
+
+```typescript
+import { formatCostBreakdown } from "ai-sdk-cost-calculator";
+
+const output = formatCostBreakdown(cost);
+// Input:        $0.002400
+// Cache Read:   $0.000060
+// Cache Write:  $0.000375
+// Output:       $0.007500
+// Total:        $0.010335
+```
+
+### `createCostTracker(options)`
+
+Track cumulative costs across multiple requests.
+
+```typescript
+import { createCostTracker } from "ai-sdk-cost-calculator";
+
+const tracker = createCostTracker({
+  provider: "openai",
+  modelId: "gpt-4o",
+});
+
+// Add usage from multiple requests
+tracker.addUsage(result1.usage);
+tracker.addUsage(result2.usage);
+tracker.addUsage(result3.usage);
+
+console.log(`Requests: ${tracker.getRequestCount()}`);
+console.log(`Total tokens: ${tracker.getTotalUsage().totalTokens}`);
+console.log(`Total cost: ${formatCost(tracker.getTotalCost().totalCost)}`);
+
+// Reset when needed
+tracker.reset();
+```
+
+### `calculateStreamCost(streamResult, options)`
+
+Calculate cost from a streaming response.
+
+```typescript
+import { streamText } from "ai";
+import { calculateStreamCost } from "ai-sdk-cost-calculator";
+
+const stream = await streamText({
+  model: openai("gpt-4o"),
+  prompt: "Write a haiku",
+});
+
+const cost = await calculateStreamCost(stream, {
+  provider: "openai",
+  modelId: "gpt-4o",
+  onCost: (cost, usage) => {
+    console.log(`Stream completed: ${formatCost(cost.totalCost)}`);
+  },
+});
+```
+
+### Pricing Data Access
+
+Access raw pricing data for any provider or model.
+
+```typescript
+import {
+  openaiPricing,
+  anthropicPricing,
+  googlePricing,
+  xaiPricing,
+  deepseekPricing,
+  getModelPricing,
+  getModelPricingByModelId,
+  getAllSupportedModels,
+} from "ai-sdk-cost-calculator";
+
+// Get pricing for a specific model
+const pricing = getModelPricing("anthropic", "claude-sonnet-4-5");
+console.log(pricing);
+// {
+//   inputPer1MTokens: 3,
+//   outputPer1MTokens: 15,
+//   cacheReadPer1MTokens: 0.3,
+//   cacheWritePer1MTokens: 3.75,
+//   longContextThreshold: 200000,
+//   longContextInputPer1MTokens: 6,
+//   longContextOutputPer1MTokens: 22.5,
+//   ...
+// }
+
+// Get pricing by model ID only (searches all providers)
+const pricing2 = getModelPricingByModelId("gpt-4o");
+
+// List all supported models
+const models = getAllSupportedModels();
+// [{ provider: "openai", modelId: "gpt-4o" }, ...]
+```
+
+## Supported Models
+
+### OpenAI (23 models)
+- GPT-4o, GPT-4o-mini
+- GPT-4.1, GPT-4.1-mini, GPT-4.1-nano
+- GPT-4 Turbo, GPT-4, GPT-4-32k
+- GPT-3.5 Turbo
+- o1, o1-mini, o1-pro, o1-preview
+- o3, o3-mini, o3-pro
+- o4-mini
+
+### Anthropic (23 models)
+- Claude Opus 4.5, Sonnet 4.5, Haiku 4.5
+- Claude Opus 4.1, Sonnet 4, Opus 4
+- Claude 3.5 Sonnet, 3.5 Haiku
+- Claude 3 Opus, 3 Sonnet, 3 Haiku
+- All dated variants (e.g., `claude-3-5-sonnet-20241022`)
+
+### Google Gemini (17 models)
+- Gemini 3 Pro, 3 Flash
+- Gemini 2.5 Pro, 2.5 Flash, 2.5 Flash-Lite
+- Gemini 2.0 Flash, 2.0 Flash-Lite
+- Gemini 1.5 Pro, 1.5 Flash, 1.5 Flash-8B
+
+### xAI Grok (12 models)
+- Grok 4, Grok 4-0709
+- Grok 4 Fast (reasoning/non-reasoning)
+- Grok 4.1 Fast (reasoning/non-reasoning)
+- Grok Code Fast
+- Grok 3, Grok 3-mini
+- Grok 2, Grok 2 Vision
+
+### DeepSeek (10 models)
+- DeepSeek Chat (V3, V3.2)
+- DeepSeek Reasoner (R1)
+- DeepSeek R1 Distill variants
+- DeepSeek Coder
+
+## Long Context Pricing
+
+Some models have tiered pricing based on input token count:
+
+| Model | Threshold | Standard | Long Context |
+|-------|-----------|----------|--------------|
+| Claude Sonnet 4.5 | 200K | $3/$15 | $6/$22.50 |
+| Gemini 2.5 Pro | 200K | $1.25/$10 | $2.50/$15 |
+| Gemini 1.5 Pro | 128K | $1.25/$5 | $2.50/$10 |
+| Grok 4 Fast | 128K | $0.20/$0.50 | $0.40/$1.00 |
+
+The calculator automatically applies the correct pricing tier based on input token count.
+
+## Custom Pricing
+
+Override default pricing for any model:
+
+```typescript
+const cost = calculateCost({
+  provider: "openai",
+  modelId: "gpt-4o",
+  usage: result.usage,
+  customPricing: {
+    inputPer1MTokens: 2.0,  // Custom rate
+    outputPer1MTokens: 8.0,
+    cacheReadPer1MTokens: 1.0,
+  },
+});
+```
+
+## TypeScript Types
+
+```typescript
+import type {
+  CostBreakdown,
+  CalculateCostOptions,
+  ModelPricing,
+  ProviderPricing,
+  Provider,
+  CostTracker,
+  CreateCostTrackerOptions,
+  StreamCostOptions,
+} from "ai-sdk-cost-calculator";
+```
+
+## Pricing Sources
+
+Pricing data is sourced from official provider documentation:
+
+- [OpenAI API Pricing](https://openai.com/api/pricing/)
+- [Anthropic Claude Pricing](https://www.anthropic.com/pricing)
+- [Google Gemini API Pricing](https://ai.google.dev/gemini-api/docs/pricing)
+- [xAI Grok API](https://docs.x.ai/docs/models)
+- [DeepSeek API Pricing](https://api-docs.deepseek.com/quick_start/pricing)
+
+**Note**: Prices may change. Please verify current pricing with official sources for production use.
+
+## License
+
+MIT

package/dist/calculator.d.ts

@@ -0,0 +1,22 @@
+import { LanguageModelUsage } from "ai";
+import { type ModelPricing } from "./prices";
+export interface CostBreakdown {
+    inputCost: number;
+    outputCost: number;
+    cacheReadCost: number;
+    cacheWriteCost: number;
+    reasoningCost: number;
+    totalCost: number;
+    currency: "USD";
+    isLongContext: boolean;
+}
+export interface CalculateCostOptions {
+    provider: string;
+    modelId: string;
+    usage: LanguageModelUsage;
+    customPricing?: ModelPricing;
+}
+export declare function calculateCost(options: CalculateCostOptions): CostBreakdown;
+export declare function formatCost(cost: number, decimals?: number): string;
+export declare function formatCostBreakdown(result: CostBreakdown, decimals?: number): string;
+//# sourceMappingURL=calculator.d.ts.map

package/dist/calculator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"calculator.d.ts","sourceRoot":"","sources":["../src/calculator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,IAAI,CAAC;AACxC,OAAO,EAAmB,KAAK,YAAY,EAAE,MAAM,UAAU,CAAC;AAE9D,MAAM,WAAW,aAAa;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,MAAM,CAAC;IACtB,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,EAAE,MAAM,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,KAAK,CAAC;IAChB,aAAa,EAAE,OAAO,CAAC;CACxB;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,kBAAkB,CAAC;IAC1B,aAAa,CAAC,EAAE,YAAY,CAAC;CAC9B;AAqDD,wBAAgB,aAAa,CAAC,OAAO,EAAE,oBAAoB,GAAG,aAAa,CAwD1E;AAMD,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,GAAE,MAAU,GAAG,MAAM,CAErE;AAED,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,aAAa,EACrB,QAAQ,GAAE,MAAU,GACnB,MAAM,CAwBR"}

package/dist/calculator.js

@@ -0,0 +1,96 @@
+import { getModelPricing } from "./prices";
+function getEffectivePricing(pricing, inputTokens) {
+    const threshold = pricing.longContextThreshold ?? 200000;
+    const isLongContext = inputTokens > threshold &&
+        pricing.longContextInputPer1MTokens !== undefined;
+    if (isLongContext) {
+        return {
+            inputPer1MTokens: pricing.longContextInputPer1MTokens,
+            outputPer1MTokens: pricing.longContextOutputPer1MTokens ?? pricing.outputPer1MTokens,
+            cacheReadPer1MTokens: pricing.longContextCacheReadPer1MTokens ??
+                pricing.cacheReadPer1MTokens ??
+                pricing.longContextInputPer1MTokens,
+            cacheWritePer1MTokens: pricing.longContextCacheWritePer1MTokens ??
+                pricing.cacheWritePer1MTokens ??
+                0,
+            reasoningPer1MTokens: pricing.reasoningPer1MTokens ??
+                pricing.longContextOutputPer1MTokens ??
+                pricing.outputPer1MTokens,
+            isLongContext: true,
+        };
+    }
+    return {
+        inputPer1MTokens: pricing.inputPer1MTokens,
+        outputPer1MTokens: pricing.outputPer1MTokens,
+        cacheReadPer1MTokens: pricing.cacheReadPer1MTokens ?? pricing.inputPer1MTokens,
+        cacheWritePer1MTokens: pricing.cacheWritePer1MTokens ?? 0,
+        reasoningPer1MTokens: pricing.reasoningPer1MTokens ?? pricing.outputPer1MTokens,
+        isLongContext: false,
+    };
+}
+export function calculateCost(options) {
+    const { provider, modelId, usage, customPricing } = options;
+    const pricing = customPricing ?? getModelPricing(provider, modelId);
+    if (!pricing) {
+        throw new Error(`Unknown model: ${provider}/${modelId}. Use customPricing option or add the model to prices.ts`);
+    }
+    // Extract token counts from details
+    const noCacheTokens = usage.inputTokenDetails?.noCacheTokens ?? 0;
+    const cacheReadTokens = usage.inputTokenDetails?.cacheReadTokens ?? 0;
+    const cacheWriteTokens = usage.inputTokenDetails?.cacheWriteTokens ?? 0;
+    const textTokens = usage.outputTokenDetails?.textTokens ?? 0;
+    const reasoningTokens = usage.outputTokenDetails?.reasoningTokens ?? 0;
+    // Total input tokens for long context threshold check
+    const totalInputTokens = usage.inputTokens ?? (noCacheTokens + cacheReadTokens);
+    // Get effective pricing based on input token count
+    const effectivePricing = getEffectivePricing(pricing, totalInputTokens);
+    const inputCost = (noCacheTokens / 1_000_000) * effectivePricing.inputPer1MTokens;
+    const outputCost = (textTokens / 1_000_000) * effectivePricing.outputPer1MTokens;
+    const cacheReadCost = (cacheReadTokens / 1_000_000) * effectivePricing.cacheReadPer1MTokens;
+    const cacheWriteCost = (cacheWriteTokens / 1_000_000) * effectivePricing.cacheWritePer1MTokens;
+    const reasoningCost = (reasoningTokens / 1_000_000) * effectivePricing.reasoningPer1MTokens;
+    const totalCost = inputCost +
+        outputCost +
+        cacheReadCost +
+        cacheWriteCost +
+        reasoningCost;
+    return {
+        inputCost: roundToMicroDollars(inputCost),
+        outputCost: roundToMicroDollars(outputCost),
+        cacheReadCost: roundToMicroDollars(cacheReadCost),
+        cacheWriteCost: roundToMicroDollars(cacheWriteCost),
+        reasoningCost: roundToMicroDollars(reasoningCost),
+        totalCost: roundToMicroDollars(totalCost),
+        currency: "USD",
+        isLongContext: effectivePricing.isLongContext,
+    };
+}
+function roundToMicroDollars(value) {
+    return Math.round(value * 1_000_000) / 1_000_000;
+}
+export function formatCost(cost, decimals = 6) {
+    return `$${cost.toFixed(decimals)}`;
+}
+export function formatCostBreakdown(result, decimals = 6) {
+    const lines = [];
+    if (result.isLongContext) {
+        lines.push(`(Long context pricing applied)`);
+    }
+    if (result.inputCost > 0) {
+        lines.push(`Input:        ${formatCost(result.inputCost, decimals)}`);
+    }
+    if (result.cacheReadCost > 0) {
+        lines.push(`Cache Read:   ${formatCost(result.cacheReadCost, decimals)}`);
+    }
+    if (result.cacheWriteCost > 0) {
+        lines.push(`Cache Write:  ${formatCost(result.cacheWriteCost, decimals)}`);
+    }
+    if (result.outputCost > 0) {
+        lines.push(`Output:       ${formatCost(result.outputCost, decimals)}`);
+    }
+    if (result.reasoningCost > 0) {
+        lines.push(`Reasoning:    ${formatCost(result.reasoningCost, decimals)}`);
+    }
+    lines.push(`Total:        ${formatCost(result.totalCost, decimals)}`);
+    return lines.join("\n");
+}

package/dist/index.d.mts

@@ -0,0 +1,84 @@
+import { LanguageModelUsage } from 'ai';
+
+interface ModelPricing {
+    inputPer1MTokens: number;
+    outputPer1MTokens: number;
+    cacheReadPer1MTokens?: number;
+    cacheWritePer1MTokens?: number;
+    reasoningPer1MTokens?: number;
+    longContextThreshold?: number;
+    longContextInputPer1MTokens?: number;
+    longContextOutputPer1MTokens?: number;
+    longContextCacheReadPer1MTokens?: number;
+    longContextCacheWritePer1MTokens?: number;
+}
+interface ProviderPricing {
+    [modelId: string]: ModelPricing;
+}
+
+declare const openaiPricing: ProviderPricing;
+
+declare const anthropicPricing: ProviderPricing;
+
+declare const googlePricing: ProviderPricing;
+
+declare const xaiPricing: ProviderPricing;
+
+declare const deepseekPricing: ProviderPricing;
+
+declare const allPricing: Record<string, ProviderPricing>;
+declare const flatPricing: ProviderPricing;
+declare function getModelPricing(provider: string, modelId: string): ModelPricing | undefined;
+declare function getModelPricingByModelId(modelId: string): ModelPricing | undefined;
+declare function getAllSupportedModels(): {
+    provider: string;
+    modelId: string;
+}[];
+type Provider = keyof typeof allPricing;
+
+interface CostBreakdown {
+    inputCost: number;
+    outputCost: number;
+    cacheReadCost: number;
+    cacheWriteCost: number;
+    reasoningCost: number;
+    totalCost: number;
+    currency: "USD";
+    isLongContext: boolean;
+}
+interface CalculateCostOptions {
+    provider: string;
+    modelId: string;
+    usage: LanguageModelUsage;
+    customPricing?: ModelPricing;
+}
+declare function calculateCost(options: CalculateCostOptions): CostBreakdown;
+declare function formatCost(cost: number, decimals?: number): string;
+declare function formatCostBreakdown(result: CostBreakdown, decimals?: number): string;
+
+interface CostTracker {
+    addUsage(usage: LanguageModelUsage): void;
+    getTotalUsage(): LanguageModelUsage;
+    getTotalCost(): CostBreakdown;
+    getRequestCount(): number;
+    reset(): void;
+}
+interface CreateCostTrackerOptions {
+    provider: string;
+    modelId: string;
+    customPricing?: ModelPricing;
+}
+declare function createCostTracker(options: CreateCostTrackerOptions): CostTracker;
+interface StreamCostOptions {
+    provider: string;
+    modelId: string;
+    customPricing?: ModelPricing;
+    onCost?: (cost: CostBreakdown, usage: LanguageModelUsage) => void;
+}
+declare function calculateStreamCost<T extends {
+    usage: LanguageModelUsage;
+}>(streamResult: T | Promise<T>, options: StreamCostOptions): Promise<CostBreakdown & {
+    usage: LanguageModelUsage;
+}>;
+
+export { type CalculateCostOptions, type CostBreakdown, type CostTracker, type CreateCostTrackerOptions, type ModelPricing, type Provider, type ProviderPricing, type StreamCostOptions, allPricing, anthropicPricing, calculateCost, calculateStreamCost, createCostTracker, deepseekPricing, flatPricing, formatCost, formatCostBreakdown, getAllSupportedModels, getModelPricing, getModelPricingByModelId, googlePricing, openaiPricing, xaiPricing };

package/dist/index.d.ts

@@ -0,0 +1,84 @@
+import { LanguageModelUsage } from 'ai';
+
+interface ModelPricing {
+    inputPer1MTokens: number;
+    outputPer1MTokens: number;
+    cacheReadPer1MTokens?: number;
+    cacheWritePer1MTokens?: number;
+    reasoningPer1MTokens?: number;
+    longContextThreshold?: number;
+    longContextInputPer1MTokens?: number;
+    longContextOutputPer1MTokens?: number;
+    longContextCacheReadPer1MTokens?: number;
+    longContextCacheWritePer1MTokens?: number;
+}
+interface ProviderPricing {
+    [modelId: string]: ModelPricing;
+}
+
+declare const openaiPricing: ProviderPricing;
+
+declare const anthropicPricing: ProviderPricing;
+
+declare const googlePricing: ProviderPricing;
+
+declare const xaiPricing: ProviderPricing;
+
+declare const deepseekPricing: ProviderPricing;
+
+declare const allPricing: Record<string, ProviderPricing>;
+declare const flatPricing: ProviderPricing;
+declare function getModelPricing(provider: string, modelId: string): ModelPricing | undefined;
+declare function getModelPricingByModelId(modelId: string): ModelPricing | undefined;
+declare function getAllSupportedModels(): {
+    provider: string;
+    modelId: string;
+}[];
+type Provider = keyof typeof allPricing;
+
+interface CostBreakdown {
+    inputCost: number;
+    outputCost: number;
+    cacheReadCost: number;
+    cacheWriteCost: number;
+    reasoningCost: number;
+    totalCost: number;
+    currency: "USD";
+    isLongContext: boolean;
+}
+interface CalculateCostOptions {
+    provider: string;
+    modelId: string;
+    usage: LanguageModelUsage;
+    customPricing?: ModelPricing;
+}
+declare function calculateCost(options: CalculateCostOptions): CostBreakdown;
+declare function formatCost(cost: number, decimals?: number): string;
+declare function formatCostBreakdown(result: CostBreakdown, decimals?: number): string;
+
+interface CostTracker {
+    addUsage(usage: LanguageModelUsage): void;
+    getTotalUsage(): LanguageModelUsage;
+    getTotalCost(): CostBreakdown;
+    getRequestCount(): number;
+    reset(): void;
+}
+interface CreateCostTrackerOptions {
+    provider: string;
+    modelId: string;
+    customPricing?: ModelPricing;
+}
+declare function createCostTracker(options: CreateCostTrackerOptions): CostTracker;
+interface StreamCostOptions {
+    provider: string;
+    modelId: string;
+    customPricing?: ModelPricing;
+    onCost?: (cost: CostBreakdown, usage: LanguageModelUsage) => void;
+}
+declare function calculateStreamCost<T extends {
+    usage: LanguageModelUsage;
+}>(streamResult: T | Promise<T>, options: StreamCostOptions): Promise<CostBreakdown & {
+    usage: LanguageModelUsage;
+}>;
+
+export { type CalculateCostOptions, type CostBreakdown, type CostTracker, type CreateCostTrackerOptions, type ModelPricing, type Provider, type ProviderPricing, type StreamCostOptions, allPricing, anthropicPricing, calculateCost, calculateStreamCost, createCostTracker, deepseekPricing, flatPricing, formatCost, formatCostBreakdown, getAllSupportedModels, getModelPricing, getModelPricingByModelId, googlePricing, openaiPricing, xaiPricing };

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EACL,aAAa,EACb,UAAU,EACV,mBAAmB,EACnB,KAAK,aAAa,EAClB,KAAK,oBAAoB,GAC1B,MAAM,cAAc,CAAC;AAGtB,OAAO,EACL,iBAAiB,EACjB,mBAAmB,EACnB,KAAK,WAAW,EAChB,KAAK,wBAAwB,EAC7B,KAAK,iBAAiB,GACvB,MAAM,aAAa,CAAC;AAGrB,OAAO,EACL,eAAe,EACf,wBAAwB,EACxB,qBAAqB,EACrB,aAAa,EACb,gBAAgB,EAChB,aAAa,EACb,UAAU,EACV,eAAe,EACf,UAAU,EACV,WAAW,EACX,KAAK,YAAY,EACjB,KAAK,eAAe,EACpB,KAAK,QAAQ,GACd,MAAM,UAAU,CAAC"}