Base cost: $10
× Retry loops (2x average): $20
× Context bloat (3x on turn 50): $60  
× No prompt caching (full price each call): $60
× Verbose schemas (1.4x tool overhead): $84

Actual cost: $84 vs projected $10

// Bad: naive retry
async function callTool(tool: string, args: unknown) {
  for (let i = 0; i < 3; i++) {
    try {
      return await executeToolCall(tool, args);
    } catch (e) {
      // Retrying means paying full context price again
      continue;
    }
  }
}

// Better: exponential backoff + circuit breaker
const RETRY_BUDGET = { maxAttempts: 2, backoffMs: 1000 };

async function callToolWithBudget(tool: string, args: unknown, attempt = 0) {
  try {
    return await executeToolCall(tool, args);
  } catch (e) {
    if (attempt >= RETRY_BUDGET.maxAttempts) throw e; // fail fast
    if (isTransientError(e)) {
      await sleep(RETRY_BUDGET.backoffMs * Math.pow(2, attempt));
      return callToolWithBudget(tool, args, attempt + 1);
    }
    throw e; // don't retry logic errors
  }
}

// This is what most people do:
const response = await client.messages.create({
  model: 'claude-opus-4-7',
  messages: conversationHistory, // grows unbounded — silent cost bomb
  // ...
});

// What you should do:
function pruneHistory(
  history: Message[],
  maxTokenBudget = 8000
): Message[] {
  // Always keep last N turns verbatim
  const KEEP_RECENT = 6;
  const recent = history.slice(-KEEP_RECENT);

  // Summarize older context rather than dropping it
  if (history.length > KEEP_RECENT) {
    const older = history.slice(0, -KEEP_RECENT);
    // Option 1: Drop (lossy but cheap)
    // Option 2: Summarize with Haiku (cheap model, good compression)
    const summary = await summarizeWithHaiku(older);
    return [
      { role: 'user', content: `[Context summary: ${summary}]` },
      ...recent,
    ];
  }

  return recent;
}

// Check your cache hit rate — if this is near 0, you have a problem:
console.log(response.usage);
// {
//   input_tokens: 45,
//   cache_read_input_tokens: 0,    // ← should be non-zero on repeated calls
//   cache_creation_input_tokens: 9843
// }

// Fix: mark your stable system prompt for caching
const response = await client.messages.create({
  model: 'claude-opus-4-7',
  system: [
    {
      type: 'text',
      text: LARGE_SYSTEM_PROMPT, // the part that doesn't change
      cache_control: { type: 'ephemeral' },
    },
  ],
  messages: conversationHistory,
});

// This schema is 400 tokens:
const verboseTool = {
  name: 'search_database',
  description: 'Searches the production PostgreSQL database using parameterized queries. Supports full-text search across the documents table. Returns paginated results with relevance scoring. Use this when the user asks for information that might be stored in our database.',
  input_schema: {
    type: 'object',
    properties: {
      query: {
        type: 'string',
        description: 'The search query string to use for full-text search across the documents table'
      },
      limit: {
        type: 'number',
        description: 'Maximum number of results to return (default 10, max 100)'
      },
      offset: {
        type: 'number', 
        description: 'Pagination offset for retrieving subsequent pages of results'
      }
    },
    required: ['query']
  }
};

// This schema is 80 tokens and Claude handles it fine:
const compactTool = {
  name: 'search_database',
  description: 'Full-text search across documents. Returns paginated results.',
  input_schema: {
    type: 'object',
    properties: {
      query: { type: 'string' },
      limit: { type: 'number' },
      offset: { type: 'number' }
    },
    required: ['query']
  }
};

class TokenBudgetTracker {
  private calls = 0;
  private totalInput = 0;
  private totalCacheRead = 0;
  private totalCacheWrite = 0;
  private retries = 0;

  record(usage: Anthropic.Usage, retryCount: number) {
    this.calls++;
    this.totalInput += usage.input_tokens;
    this.totalCacheRead += usage.cache_read_input_tokens ?? 0;
    this.totalCacheWrite += usage.cache_creation_input_tokens ?? 0;
    this.retries += retryCount;
  }

  report() {
    const effectiveCacheRate = this.totalCacheRead /
      (this.totalInput + this.totalCacheRead + this.totalCacheWrite);

    console.log({
      calls: this.calls,
      avgInputTokens: (this.totalInput / this.calls).toFixed(0),
      cacheHitRate: `${(effectiveCacheRate * 100).toFixed(1)}%`,
      retryRate: `${((this.retries / this.calls) * 100).toFixed(1)}%`,
    });
  }
}