Skip to content

Soul-driven AI agent with permission-hardened tools, token budgets, and multi-channel access. Runs 24/7 from CLI, Telegram or More.

7.2 KB
Raw Blame
import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
import { join } from 'node:path';
import { tmpdir } from 'node:os';
import { beforeEach, afterEach, describe, expect, it, vi } from 'vitest';
import { TokenBudget } from './tokens.js';
import type { MercuryConfig } from './config.js';

let mercuryHome = '';

/** Only the slice TokenBudget reads: a whole config would be noise in every assertion. */
const configWith = (dailyBudget: number) => ({ tokens: { dailyBudget } } as unknown as MercuryConfig);

vi.mock('./config.js', () => ({
  getMercuryHome: () => mercuryHome,
  saveConfig: vi.fn(),
}));

vi.mock('./logger.js', () => ({
  logger: {
    info: vi.fn(),
    warn: vi.fn(),
  },
}));

describe('TokenBudget hardening', () => {
  beforeEach(() => {
    mercuryHome = mkdtempSync(join(tmpdir(), 'mercury-token-test-'));
  });

  afterEach(() => {
    if (mercuryHome) {
      rmSync(mercuryHome, { recursive: true, force: true });
    }
  });

  it('does not poison daily usage when token values are invalid', () => {
    const budget = new TokenBudget({ tokens: { dailyBudget: 200_000 } } as any);

    budget.recordUsage({
      provider: 'openai',
      model: 'gpt-4o-mini',
      inputTokens: Number.NaN,
      outputTokens: Number.NaN,
      totalTokens: Number.NaN,
      channelType: 'cli',
    });

    expect(budget.getDailyUsed()).toBe(0);
    expect(budget.getStatusText()).not.toContain('NaN');

    budget.recordUsage({
      provider: 'openai',
      model: 'gpt-4o-mini',
      inputTokens: 120,
      outputTokens: 30,
      totalTokens: 150,
      channelType: 'cli',
    });

    expect(budget.getDailyUsed()).toBe(150);
    expect(budget.getRemaining()).toBe(199_850);
  });

  it('repairs corrupted persisted usage data on restore', () => {
    const usagePath = join(mercuryHome, 'token-usage.json');
    const today = new Date().toISOString().split('T')[0];

    writeFileSync(usagePath, JSON.stringify({
      dailyUsed: null,
      dailyBudget: 200000,
      lastResetDate: today,
      requestLog: [
        {
          provider: 'openai',
          model: 'gpt-4o-mini',
          inputTokens: null,
          outputTokens: null,
          totalTokens: null,
          channelType: 'cli',
          timestamp: Date.now(),
        },
        {
          provider: 'openai',
          model: 'gpt-4o-mini',
          inputTokens: 80,
          outputTokens: 20,
          totalTokens: 100,
          channelType: 'cli',
          timestamp: Date.now(),
        },
      ],
    }), 'utf-8');

    const budget = new TokenBudget({ tokens: { dailyBudget: 200_000 } } as any);

    expect(budget.getDailyUsed()).toBe(100);
    expect(budget.getStatusText()).toContain('100 / 200,000 used');
    expect(budget.getStatusText()).not.toContain('NaN');

    const persisted = JSON.parse(readFileSync(usagePath, 'utf-8')) as { dailyUsed: number };
    expect(persisted.dailyUsed).toBe(100);
  });

  it('reads a zero budget as no ceiling, not as no answers', () => {
    const budget = new TokenBudget(configWith(0));
    budget.recordUsage({
      provider: 'deepseek',
      model: 'deepseek-flash',
      inputTokens: 900,
      outputTokens: 100,
      totalTokens: 1_000,
      channelType: 'cli',
    });

    expect(budget.isOverBudget()).toBe(false);
    expect(budget.canAfford(5_000_000)).toBe(true);
    expect(budget.getStatusText()).toContain('no daily ceiling');
    expect(budget.getStatusText()).not.toContain('0 remaining');
  });

  it('still refuses once a real ceiling is crossed', () => {
    const budget = new TokenBudget(configWith(1_000));
    budget.recordUsage({
      provider: 'deepseek',
      model: 'deepseek-flash',
      inputTokens: 900,
      outputTokens: 100,
      totalTokens: 1_000,
      channelType: 'cli',
    });

    expect(budget.canAfford(1)).toBe(false);
    expect(budget.isOverBudget()).toBe(true);
    expect(budget.getRemaining()).toBe(0);
  });
});
describe('TokenBudget cache weighting (tokens.cachedWeight)', () => {
  beforeEach(() => {
    mercuryHome = mkdtempSync(join(tmpdir(), 'mercury-token-test-'));
  });

  afterEach(() => {
    if (mercuryHome) rmSync(mercuryHome, { recursive: true, force: true });
  });

  const turn = {
    provider: 'litellm',
    model: 'gpt-5',
    inputTokens: 100_000,
    outputTokens: 2_000,
    totalTokens: 102_000,
    cachedInputTokens: 90_000,
    noCacheInputTokens: 10_000,
    channelType: 'cli',
  };
  const withWeight = (cachedWeight: unknown) => ({ tokens: { dailyBudget: 1_000_000, cachedWeight } } as unknown as MercuryConfig);

  it('counts every token when the weight is unset (default 1)', () => {
    const budget = new TokenBudget(configWith(1_000_000));
    budget.recordUsage(turn);
    expect(budget.getDailyUsed()).toBe(102_000);
  });

  it('counts cache hits at the configured weight', () => {
    const budget = new TokenBudget(withWeight(0.1));
    budget.recordUsage(turn);
    // 10,000 uncached + 2,000 out + 90,000 × 0.1
    expect(budget.getDailyUsed()).toBe(21_000);
  });

  it('excludes cache hits at weight 0', () => {
    const budget = new TokenBudget(withWeight(0));
    budget.recordUsage(turn);
    expect(budget.getDailyUsed()).toBe(12_000);
  });

  it('clamps out-of-range weights and treats non-numbers as 1', () => {
    const over = new TokenBudget(withWeight(5));
    over.recordUsage(turn);
    expect(over.getDailyUsed()).toBe(102_000);

    rmSync(join(mercuryHome, 'token-usage.json'), { force: true });
    const under = new TokenBudget(withWeight(-2));
    under.recordUsage(turn);
    expect(under.getDailyUsed()).toBe(12_000);

    rmSync(join(mercuryHome, 'token-usage.json'), { force: true });
    const junk = new TokenBudget(withWeight('cheap'));
    junk.recordUsage(turn);
    expect(junk.getDailyUsed()).toBe(102_000);
  });

  it('counts requests without a cache split at their plain total', () => {
    const budget = new TokenBudget(withWeight(0.1));
    budget.recordUsage({ provider: 'openai', model: 'm', inputTokens: 400, outputTokens: 100, totalTokens: 500, channelType: 'internal' });
    expect(budget.getDailyUsed()).toBe(500);
  });

  it('shows the cache split and the weight in /budget', () => {
    const budget = new TokenBudget(withWeight(0.1));
    expect(budget.getCacheSplitText()).toBe('');
    budget.recordUsage(turn);
    expect(budget.getCacheSplitText()).toBe('Today: 100,000 in (90,000 cached · 90%, counted at 0.1) · 10,000 uncached · 2,000 out');
  });

  it('leaves the weight out of the /budget line at the default', () => {
    const budget = new TokenBudget(configWith(1_000_000));
    budget.recordUsage(turn);
    expect(budget.getCacheSplitText()).toBe('Today: 100,000 in (90,000 cached · 90%) · 10,000 uncached · 2,000 out');
  });

  it('keeps the split and the weighted total across a restart', () => {
    const first = new TokenBudget(withWeight(0.1));
    first.recordUsage(turn);
    const second = new TokenBudget(withWeight(0.1));
    expect(second.getDailyUsed()).toBe(21_000);
    expect(second.getDailySplit()).toEqual({ inputTokens: 100_000, cachedInputTokens: 90_000, noCacheInputTokens: 10_000, outputTokens: 2_000 });
  });

  it('clears the split on reset', () => {
    const budget = new TokenBudget(withWeight(0.1));
    budget.recordUsage(turn);
    budget.resetUsage();
    expect(budget.getCacheSplitText()).toBe('');
  });
});