@tokentop/ttop 0.2.2

package/src/pricing/estimator.ts

@@ -0,0 +1,80 @@
+import type { ModelPricing, CostBreakdown } from '@/plugins/types/provider.ts';
+
+export interface TokenUsage {
+  input: number;
+  output: number;
+  cacheRead?: number;
+  cacheWrite?: number;
+}
+
+export function estimateCost(
+  usage: TokenUsage,
+  pricing: ModelPricing
+): CostBreakdown {
+  const inputCost = (usage.input / 1_000_000) * pricing.input;
+  const outputCost = (usage.output / 1_000_000) * pricing.output;
+
+  let cacheReadCost = 0;
+  if (usage.cacheRead && pricing.cacheRead) {
+    cacheReadCost = (usage.cacheRead / 1_000_000) * pricing.cacheRead;
+  }
+
+  let cacheWriteCost = 0;
+  if (usage.cacheWrite && pricing.cacheWrite) {
+    cacheWriteCost = (usage.cacheWrite / 1_000_000) * pricing.cacheWrite;
+  }
+
+  const total = inputCost + outputCost + cacheReadCost + cacheWriteCost;
+
+  const breakdown: CostBreakdown = {
+    total: roundCost(total),
+    input: roundCost(inputCost),
+    output: roundCost(outputCost),
+    currency: 'USD',
+  };
+
+  if (cacheReadCost > 0) breakdown.cacheRead = roundCost(cacheReadCost);
+  if (cacheWriteCost > 0) breakdown.cacheWrite = roundCost(cacheWriteCost);
+
+  return breakdown;
+}
+
+export function estimateSessionCost(
+  sessions: TokenUsage[],
+  pricing: ModelPricing
+): CostBreakdown {
+  const totals = sessions.reduce<TokenUsage>(
+    (acc, session) => ({
+      input: acc.input + session.input,
+      output: acc.output + session.output,
+      cacheRead: (acc.cacheRead ?? 0) + (session.cacheRead ?? 0),
+      cacheWrite: (acc.cacheWrite ?? 0) + (session.cacheWrite ?? 0),
+    }),
+    { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 }
+  );
+
+  return estimateCost(totals, pricing);
+}
+
+export function formatCost(cost: number, currency = 'USD'): string {
+  if (currency === 'USD') {
+    if (cost < 0.01) {
+      return `$${cost.toFixed(4)}`;
+    }
+    if (cost < 1) {
+      return `$${cost.toFixed(3)}`;
+    }
+    return `$${cost.toFixed(2)}`;
+  }
+  return `${cost.toFixed(4)} ${currency}`;
+}
+
+export function formatTokenCount(tokens: number): string {
+  if (tokens < 1000) return tokens.toString();
+  if (tokens < 1_000_000) return `${(tokens / 1000).toFixed(1)}K`;
+  return `${(tokens / 1_000_000).toFixed(2)}M`;
+}
+
+function roundCost(value: number): number {
+  return Math.round(value * 1_000_000) / 1_000_000;
+}

package/src/pricing/fallback.test.ts

@@ -0,0 +1,71 @@
+import { describe, expect, test } from 'bun:test';
+import {
+  FALLBACK_PRICING,
+  getFallbackPricing,
+  getFallbackProviderPricing,
+} from './fallback.ts';
+
+describe('getFallbackPricing()', () => {
+  test('returns pricing for an exact model match', () => {
+    expect(getFallbackPricing('openai', 'gpt-4.1')).toEqual({
+      input: 2,
+      output: 8,
+      cacheRead: 0.5,
+      source: 'fallback',
+    });
+  });
+
+  test('returns pricing when model id includes a known key', () => {
+    expect(getFallbackPricing('anthropic', 'claude-3-7-sonnet-20250219-thinking')).toEqual({
+      input: 3,
+      output: 15,
+      cacheRead: 0.3,
+      cacheWrite: 3.75,
+      source: 'fallback',
+    });
+  });
+
+  test('returns pricing when a known key includes the model id', () => {
+    expect(getFallbackPricing('google', 'gemini-2.5')).toEqual({
+      input: 1.25,
+      output: 10,
+      source: 'fallback',
+    });
+  });
+
+  test('returns null for unknown provider', () => {
+    expect(getFallbackPricing('unknown-provider', 'gpt-4.1')).toBeNull();
+  });
+
+  test('returns null for unknown model in a known provider', () => {
+    expect(getFallbackPricing('openai', 'totally-unknown-model')).toBeNull();
+  });
+});
+
+describe('getFallbackProviderPricing()', () => {
+  test('returns the full provider pricing map', () => {
+    const anthropicPricing = FALLBACK_PRICING['anthropic'];
+    if (!anthropicPricing) {
+      throw new Error('Expected anthropic fallback pricing to exist');
+    }
+    expect(getFallbackProviderPricing('anthropic')).toEqual(anthropicPricing);
+  });
+
+  test('returns null for unknown provider', () => {
+    expect(getFallbackProviderPricing('does-not-exist')).toBeNull();
+  });
+});
+
+describe('FALLBACK_PRICING', () => {
+  test('includes anthropic provider pricing data', () => {
+    expect(FALLBACK_PRICING['anthropic']).toBeDefined();
+  });
+
+  test('includes openai provider pricing data', () => {
+    expect(FALLBACK_PRICING['openai']).toBeDefined();
+  });
+
+  test('includes google provider pricing data', () => {
+    expect(FALLBACK_PRICING['google']).toBeDefined();
+  });
+});

package/src/pricing/fallback.ts

@@ -0,0 +1,62 @@
+import type { ModelPricing } from '@/plugins/types/provider.ts';
+
+//TODO: get more up to date fallback pricing
+export const FALLBACK_PRICING: Record<string, Record<string, ModelPricing>> = {
+  anthropic: {
+    'claude-sonnet-4-20250514': { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75, source: 'fallback' },
+    'claude-3-7-sonnet-20250219': { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75, source: 'fallback' },
+    'claude-3-5-sonnet-20241022': { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75, source: 'fallback' },
+    'claude-3-5-haiku-20241022': { input: 0.8, output: 4, cacheRead: 0.08, cacheWrite: 1, source: 'fallback' },
+    'claude-3-opus-20240229': { input: 15, output: 75, cacheRead: 1.5, cacheWrite: 18.75, source: 'fallback' },
+  },
+
+  openai: {
+    'gpt-4.1': { input: 2, output: 8, cacheRead: 0.5, source: 'fallback' },
+    'gpt-4.1-mini': { input: 0.4, output: 1.6, cacheRead: 0.1, source: 'fallback' },
+    'gpt-4o': { input: 2.5, output: 10, cacheRead: 1.25, source: 'fallback' },
+    'gpt-4o-mini': { input: 0.15, output: 0.6, cacheRead: 0.075, source: 'fallback' },
+    'o1': { input: 15, output: 60, source: 'fallback' },
+    'o1-mini': { input: 1.1, output: 4.4, source: 'fallback' },
+    'o3': { input: 10, output: 40, source: 'fallback' },
+    'o3-mini': { input: 1.1, output: 4.4, source: 'fallback' },
+    'o4-mini': { input: 1.1, output: 4.4, source: 'fallback' },
+  },
+
+  google: {
+    'gemini-2.0-flash': { input: 0.1, output: 0.4, source: 'fallback' },
+    'gemini-2.0-flash-lite': { input: 0.075, output: 0.3, source: 'fallback' },
+    'gemini-2.5-pro': { input: 1.25, output: 10, source: 'fallback' },
+    'gemini-2.5-flash': { input: 0.15, output: 0.6, source: 'fallback' },
+  },
+
+  openrouter: {
+    'anthropic/claude-sonnet-4': { input: 3, output: 15, source: 'fallback' },
+    'openai/gpt-4.1': { input: 2, output: 8, source: 'fallback' },
+    'google/gemini-2.5-pro': { input: 1.25, output: 10, source: 'fallback' },
+  },
+};
+
+export function getFallbackPricing(
+  providerId: string,
+  modelId: string
+): ModelPricing | null {
+  const providerPricing = FALLBACK_PRICING[providerId];
+  if (!providerPricing) return null;
+
+  const exactMatch = providerPricing[modelId];
+  if (exactMatch) return exactMatch;
+
+  for (const [key, pricing] of Object.entries(providerPricing)) {
+    if (modelId.includes(key) || key.includes(modelId)) {
+      return pricing;
+    }
+  }
+
+  return null;
+}
+
+export function getFallbackProviderPricing(
+  providerId: string
+): Record<string, ModelPricing> | null {
+  return FALLBACK_PRICING[providerId] ?? null;
+}

package/src/pricing/index.ts

@@ -0,0 +1,66 @@
+import type { ModelPricing, ProviderPlugin, ProviderPricing } from '@/plugins/types/provider.ts';
+import { getModelPricing, getProviderModels, normalizeProviderName, setProviderAliases, clearCache as clearModelsDevCache } from './models-dev.ts';
+import { getFallbackPricing, getFallbackProviderPricing } from './fallback.ts';
+
+export function initPricingFromPlugins(
+  plugins: readonly ProviderPlugin[],
+  additionalAliases?: Record<string, string>,
+): void {
+  const aliases = new Map<string, string>();
+
+  for (const plugin of plugins) {
+    const pricing = plugin.pricing;
+    if (
+      pricing &&
+      'modelsDevProviderId' in pricing &&
+      typeof (pricing as ProviderPricing).modelsDevProviderId === 'string'
+    ) {
+      aliases.set(plugin.id, (pricing as ProviderPricing).modelsDevProviderId!);
+    }
+  }
+
+  if (additionalAliases) {
+    for (const [key, value] of Object.entries(additionalAliases)) {
+      aliases.set(key, value);
+    }
+  }
+
+  setProviderAliases(aliases);
+}
+
+export async function getPricing(
+  providerId: string,
+  modelId: string
+): Promise<ModelPricing | null> {
+  const normalizedProvider = normalizeProviderName(providerId);
+  
+  const modelsDevPricing = await getModelPricing(normalizedProvider, modelId);
+  if (modelsDevPricing) return modelsDevPricing;
+
+  const fallbackPricing = getFallbackPricing(normalizedProvider, modelId);
+  if (fallbackPricing) return fallbackPricing;
+
+  return null;
+}
+
+export async function getProviderPricing(
+  providerId: string
+): Promise<Record<string, ModelPricing>> {
+  const normalizedProvider = normalizeProviderName(providerId);
+  
+  const modelsDevPricing = await getProviderModels(normalizedProvider);
+  if (modelsDevPricing && Object.keys(modelsDevPricing).length > 0) {
+    return modelsDevPricing;
+  }
+
+  const fallbackPricing = getFallbackProviderPricing(normalizedProvider);
+  return fallbackPricing ?? {};
+}
+
+export function clearPricingCache(): void {
+  clearModelsDevCache();
+}
+
+export { estimateCost, estimateSessionCost, formatCost, formatTokenCount } from './estimator.ts';
+export type { TokenUsage } from './estimator.ts';
+export { FALLBACK_PRICING } from './fallback.ts';

package/src/pricing/models-dev.ts

@@ -0,0 +1,130 @@
+import type { ModelPricing } from '@/plugins/types/provider.ts';
+
+const MODELS_DEV_API = 'https://models.dev/api.json';
+const CACHE_TTL_MS = 3600000;
+
+interface ModelsDevCost {
+  input: number;
+  output: number;
+  cache_read?: number;
+  cache_write?: number;
+}
+
+interface ModelsDevModel {
+  id: string;
+  name: string;
+  family: string;
+  cost: ModelsDevCost;
+}
+
+interface ModelsDevProvider {
+  id: string;
+  name: string;
+  models: Record<string, ModelsDevModel>;
+}
+
+type ModelsDevResponse = Record<string, ModelsDevProvider>;
+
+interface CachedData {
+  data: ModelsDevResponse;
+  fetchedAt: number;
+}
+
+let cache: CachedData | null = null;
+
+export async function fetchModelsDevData(): Promise<ModelsDevResponse | null> {
+  if (cache && Date.now() - cache.fetchedAt < CACHE_TTL_MS) {
+    return cache.data;
+  }
+
+  try {
+    const response = await fetch(MODELS_DEV_API);
+    if (!response.ok) {
+      return cache?.data ?? null;
+    }
+
+    const data = (await response.json()) as ModelsDevResponse;
+    cache = { data, fetchedAt: Date.now() };
+    return data;
+  } catch {
+    return cache?.data ?? null;
+  }
+}
+
+let providerAliases: ReadonlyMap<string, string> = new Map();
+
+export function setProviderAliases(aliases: ReadonlyMap<string, string>): void {
+  providerAliases = aliases;
+}
+
+export function normalizeProviderName(providerId: string): string {
+  return providerAliases.get(providerId) ?? providerId;
+}
+
+export async function getModelPricing(
+  providerId: string,
+  modelId: string
+): Promise<ModelPricing | null> {
+  const data = await fetchModelsDevData();
+  if (!data) return null;
+
+  const normalizedProvider = normalizeProviderName(providerId);
+  const provider = data[normalizedProvider];
+  if (!provider?.models) return null;
+
+  const model = provider.models[modelId];
+  if (!model?.cost) return null;
+
+  const pricing: ModelPricing = {
+    input: model.cost.input,
+    output: model.cost.output,
+    source: 'models.dev',
+  };
+
+  if (model.cost.cache_read !== undefined) {
+    pricing.cacheRead = model.cost.cache_read;
+  }
+  if (model.cost.cache_write !== undefined) {
+    pricing.cacheWrite = model.cost.cache_write;
+  }
+
+  return pricing;
+}
+
+export async function getProviderModels(
+  providerId: string
+): Promise<Record<string, ModelPricing> | null> {
+  const data = await fetchModelsDevData();
+  if (!data) return null;
+
+  const normalizedProvider = normalizeProviderName(providerId);
+  const provider = data[normalizedProvider];
+  if (!provider?.models) return null;
+
+  const result: Record<string, ModelPricing> = {};
+
+  for (const [modelId, model] of Object.entries(provider.models)) {
+    if (!model.cost) continue;
+
+    const pricing: ModelPricing = {
+      input: model.cost.input,
+      output: model.cost.output,
+      source: 'models.dev',
+    };
+
+    if (model.cost.cache_read !== undefined) {
+      pricing.cacheRead = model.cost.cache_read;
+    }
+    if (model.cost.cache_write !== undefined) {
+      pricing.cacheWrite = model.cost.cache_write;
+    }
+
+    result[modelId] = pricing;
+  }
+
+  return result;
+}
+
+export function clearCache(): void {
+  cache = null;
+}