token-cost-analyzer

What this skill does

# Token Cost Analyzer

Audit, analyze, and optimize your LLM API spending.

## When to Use

- Monthly AI bill higher than expected
- Need to understand where tokens are spent
- Optimizing prompts for cost efficiency
- Setting up cost monitoring
- Budgeting for AI features

## Token Pricing Reference (2026)

### Anthropic Claude

| Model | Input (per 1M tokens) | Output (per 1M tokens) |
|-------|----------------------|------------------------|
| Claude 3 Opus | $15.00 | $75.00 |
| Claude 3.5 Sonnet | $3.00 | $15.00 |
| Claude 3 Haiku | $0.25 | $1.25 |

### OpenAI

| Model | Input (per 1M tokens) | Output (per 1M tokens) |
|-------|----------------------|------------------------|
| GPT-4 Turbo | $10.00 | $30.00 |
| GPT-4o | $5.00 | $15.00 |
| GPT-4o mini | $0.15 | $0.60 |
| o1 | $15.00 | $60.00 |

### Google

| Model | Input (per 1M tokens) | Output (per 1M tokens) |
|-------|----------------------|------------------------|
| Gemini 1.5 Pro | $3.50 | $10.50 |
| Gemini 1.5 Flash | $0.075 | $0.30 |

## Cost Calculation

```typescript
interface TokenUsage {
  inputTokens: number;
  outputTokens: number;
  cachedTokens?: number;
}

interface ModelPricing {
  inputPer1M: number;
  outputPer1M: number;
  cachedPer1M?: number;
}

function calculateCost(usage: TokenUsage, pricing: ModelPricing): number {
  const inputCost = (usage.inputTokens / 1_000_000) * pricing.inputPer1M;
  const outputCost = (usage.outputTokens / 1_000_000) * pricing.outputPer1M;
  const cachedCost = usage.cachedTokens
    ? (usage.cachedTokens / 1_000_000) * (pricing.cachedPer1M || pricing.inputPer1M * 0.1)
    : 0;

  return inputCost + outputCost + cachedCost;
}

// Example
const usage = { inputTokens: 50000, outputTokens: 10000 };
const claude35Sonnet = { inputPer1M: 3.00, outputPer1M: 15.00 };
const cost = calculateCost(usage, claude35Sonnet);
// $0.15 + $0.15 = $0.30
```

## Cost Tracking System

```typescript
interface UsageRecord {
  timestamp: Date;
  model: string;
  operation: string;
  userId?: string;
  inputTokens: number;
  outputTokens: number;
  cost: number;
  metadata: Record<string, unknown>;
}

class CostTracker {
  private records: UsageRecord[] = [];

  record(usage: Omit<UsageRecord, 'timestamp' | 'cost'>): void {
    const pricing = this.getPricing(usage.model);
    const cost = calculateCost(
      { inputTokens: usage.inputTokens, outputTokens: usage.outputTokens },
      pricing
    );

    this.records.push({
      ...usage,
      timestamp: new Date(),
      cost
    });
  }

  // Aggregation methods
  getTotalCost(since: Date): number {
    return this.records
      .filter(r => r.timestamp >= since)
      .reduce((sum, r) => sum + r.cost, 0);
  }

  getCostByOperation(): Map<string, number> {
    const byOp = new Map<string, number>();
    for (const r of this.records) {
      byOp.set(r.operation, (byOp.get(r.operation) || 0) + r.cost);
    }
    return byOp;
  }

  getCostByModel(): Map<string, number> {
    const byModel = new Map<string, number>();
    for (const r of this.records) {
      byModel.set(r.model, (byModel.get(r.model) || 0) + r.cost);
    }
    return byModel;
  }

  getTopExpensiveOperations(limit: number = 10): UsageRecord[] {
    return [...this.records]
      .sort((a, b) => b.cost - a.cost)
      .slice(0, limit);
  }
}
```

## Cost Analysis Report

```typescript
interface CostReport {
  period: { start: Date; end: Date };
  summary: {
    totalCost: number;
    totalInputTokens: number;
    totalOutputTokens: number;
    uniqueOperations: number;
    avgCostPerRequest: number;
  };
  breakdown: {
    byModel: { model: string; cost: number; percentage: number }[];
    byOperation: { operation: string; cost: number; requests: number }[];
    byDay: { date: string; cost: number }[];
  };
  insights: {
    mostExpensiveOperation: string;
    fastestGrowingCost: string;
    optimizationOpportunities: string[];
  };
}

function generateCostReport(
  records: UsageRecord[],
  period: { start: Date; end: Date }
): CostReport {
  const filtered = records.filter(
    r => r.timestamp >= period.start && r.timestamp <= period.end
  );

  const totalCost = filtered.reduce((sum, r) => sum + r.cost, 0);

  // Group by model
  const byModel = new Map<string, number>();
  for (const r of filtered) {
    byModel.set(r.model, (byModel.get(r.model) || 0) + r.cost);
  }

  // Group by operation
  const byOperation = new Map<string, { cost: number; count: number }>();
  for (const r of filtered) {
    const existing = byOperation.get(r.operation) || { cost: 0, count: 0 };
    byOperation.set(r.operation, {
      cost: existing.cost + r.cost,
      count: existing.count + 1
    });
  }

  // Find optimization opportunities
  const opportunities: string[] = [];

  // Check for expensive model usage on simple tasks
  const haiku = byModel.get('claude-haiku-4-5') || 0;
  const opus = byModel.get('claude-opus-4-6') || 0;
  if (opus > haiku * 10) {
    opportunities.push('Consider using Haiku for simpler tasks - Opus usage is 10x higher');
  }

  // Check for high output token ratio
  const totalInput = filtered.reduce((s, r) => s + r.inputTokens, 0);
  const totalOutput = filtered.reduce((s, r) => s + r.outputTokens, 0);
  if (totalOutput > totalInput * 2) {
    opportunities.push('High output ratio - consider asking for more concise responses');
  }

  return {
    period,
    summary: {
      totalCost,
      totalInputTokens: totalInput,
      totalOutputTokens: totalOutput,
      uniqueOperations: byOperation.size,
      avgCostPerRequest: totalCost / filtered.length
    },
    breakdown: {
      byModel: Array.from(byModel.entries()).map(([model, cost]) => ({
        model,
        cost,
        percentage: (cost / totalCost) * 100
      })),
      byOperation: Array.from(byOperation.entries()).map(([op, data]) => ({
        operation: op,
        cost: data.cost,
        requests: data.count
      })),
      byDay: groupByDay(filtered)
    },
    insights: {
      mostExpensiveOperation: [...byOperation.entries()]
        .sort((a, b) => b[1].cost - a[1].cost)[0]?.[0] || 'none',
      fastestGrowingCost: calculateGrowth(filtered),
      optimizationOpportunities: opportunities
    }
  };
}
```

## Optimization Strategies

### 1. Model Selection

```typescript
type TaskComplexity = 'simple' | 'medium' | 'complex';

function selectCostEffectiveModel(
  task: string,
  complexity: TaskComplexity
): string {
  const modelMap = {
    simple: 'gpt-4o-mini',    // $0.15/$0.60 per 1M
    medium: 'claude-haiku-4-5', // $0.25/$1.25 per 1M
    complex: 'claude-sonnet-4-6' // $3/$15 per 1M
  };

  return modelMap[complexity];
}

// Auto-detect complexity
function assessComplexity(task: string): TaskComplexity {
  const complexIndicators = ['analyze', 'compare', 'synthesize', 'evaluate', 'complex'];
  const simpleIndicators = ['format', 'extract', 'classify', 'summarize short'];

  const lower = task.toLowerCase();

  if (complexIndicators.some(i => lower.includes(i))) return 'complex';
  if (simpleIndicators.some(i => lower.includes(i))) return 'simple';
  return 'medium';
}
```

### 2. Prompt Optimization

```typescript
// Before: Verbose prompt (many input tokens)
const verbosePrompt = `
You are an expert assistant. Your task is to help users with their questions.
Please be thorough and comprehensive in your responses. Make sure to consider
all aspects of the question and provide detailed explanations. If you're unsure
about something, please say so. Always be polite and professional.

User question: ${question}
`;

// After: Concise prompt (fewer input tokens)
const concisePrompt = `Answer concisely: ${question}`;

// Savings: ~80% reduction in input tokens
```

### 3. Response Length Control

```typescript
// Instruct the model to be concise
const prompt = `
${task}

Respond in under 100 words. Use bullet points.
`;

// Or use max_tokens parameter
const response = await client.messages.create({
  model: 'claude-haiku-4-5',
  max_tokens: 500, // Limit output