Skip to content

Self-hosted, Self-Improving, Federated Everything App — dev management, agent orchestration, persistent mind, digital twin, second brain, and creative pipeline from a single dashboard over Tailscale to port the user into the OS

5.5 KB
Raw Blame
import { describe, expect, it } from 'vitest';
import {
  galleryImageUsageEvent,
  grokTurnRepairId,
  imagineEventsFromGrokSession,
  planGrokUsageRepair,
  summarizeGrokRepairAdditions,
  videoHistoryUsageEvents,
} from './grokUsageRepair.js';

const LONG_TURN = {
  sessionId: 'sess-1',
  key: 'prompt-long',
  ms: 1_700_000_000_000,
  model: 'grok-4.7',
  promptTokens: 250_000,
  tokensIn: 200_000,
  tokensOut: 1_000,
  cacheReadTokens: 50_000,
  cacheWriteTokens: 0,
};

describe('planGrokUsageRepair', () => {
  it('adds the long-context premium once, and only for turns the scan already passed', () => {
    const first = planGrokUsageRepair({
      turns: [LONG_TURN, { ...LONG_TURN, key: 'later', ms: 1_800_000_000_000 }],
      watermarkMs: 1_750_000_000_000,
      providerId: 'grok-cli',
    });
    expect(first.additions).toHaveLength(1);
    expect(first.additions[0].repairId).toBe(grokTurnRepairId('sess-1', 'prompt-long'));
    expect(first.additions[0].record.tokensIn).toBeUndefined();
    expect(first.additions[0].record.longTokensIn).toBe(200_000);
    const again = planGrokUsageRepair({
      turns: [LONG_TURN],
      repairIds: first.additions.map((item) => item.repairId),
      watermarkMs: 1_750_000_000_000,
    });
    expect(again.additions).toEqual([]);
  });

  it('skips long-context premiums when the scan has never written a watermark, and still adds media', () => {
    const plan = planGrokUsageRepair({
      turns: [LONG_TURN],
      media: [{ id: 'gallery:job-1', day: '2026-10-01', model: 'grok-imagine-image-2.0', images: 1, source: 'measured' }],
      watermarkMs: null,
    });
    expect(plan.additions.map((item) => item.repairId)).toEqual(['gallery:job-1']);
    expect(plan.notes[0]).toMatch(/no Grok usage scan has run yet/);
    expect(summarizeGrokRepairAdditions(plan.additions)).toEqual({ added: 1, turns: 0, images: 1, videos: 0 });
  });

  it('skips a turn with no timestamp', () => {
    const plan = planGrokUsageRepair({
      turns: [{ ...LONG_TURN, ms: null }],
      watermarkMs: 1_800_000_000_000,
    });
    expect(plan.additions).toEqual([]);
  });
});

describe('Grok media recovery', () => {
  it('bills one ACP invocation across partial updates without merging distinct calls', () => {
    const updatesText = [
      { toolCallId: 'image-1', name: 'image_edit', rawInput: { image: 'source.png' } },
      { toolCallId: 'image-1', name: 'image_edit', status: 'in_progress' },
      { toolCallId: 'image-1', status: 'completed' },
      { toolCallId: 'video-1', name: 'image_to_video', rawInput: { duration: 10 } },
      { toolCallId: 'video-1', status: 'completed' },
    ].map(update => JSON.stringify({ params: { update: { sessionUpdate: 'tool_call_update', ...update } } })).join('\n');
    const media = imagineEventsFromGrokSession({ updatesText, sessionId: 'acp', day: '2026-10-01' });
    expect(media).toEqual([
      expect.objectContaining({ id: 'session-image:acp:0', images: 1, inputImages: 1 }),
      // Retain the old occurrence ordinal so a previous repair is not rebilled.
      expect.objectContaining({ id: 'session-video:acp:2', videoSeconds: 10, inputImages: 1 }),
    ]);
    expect(planGrokUsageRepair({ media, repairIds: media.map(item => item.id) }).additions).toEqual([]);
    const anonymous = JSON.stringify({ tool_calls: [{ name: 'image_gen' }, { name: 'image_gen' }] });
    expect(imagineEventsFromGrokSession({ chatText: anonymous, sessionId: 'chat', day: '2026-10-01' })).toHaveLength(2);
  });

  it.each([null, '', '  ', 0, -1, 'invalid'])('uses estimated requested duration without positive delivery evidence (%s)', deliveredSec => {
    expect(videoHistoryUsageEvents({
      id: 'clip', modelId: 'grok', mode: 'image', duration: 10, deliveredSec, createdAt: '2026-10-03T00:00:00.000Z',
    })[0]).toMatchObject({ videoSeconds: 10, source: 'estimate' });
  });

  it('uses measured positive delivered duration', () => {
    expect(videoHistoryUsageEvents({
      id: 'clip', modelId: 'grok', mode: 'image', duration: 10, deliveredSec: '5.5', createdAt: '2026-10-03T00:00:00.000Z',
    })[0]).toMatchObject({ videoSeconds: 5.5, source: 'measured' });
  });

  it('reads a gallery sidecar and a text-to-video history row', () => {
    expect(galleryImageUsageEvent({
      id: 'job-9', mode: 'grok', createdAt: '2026-10-02T03:04:05.000Z',
      initImageFilename: 'source.png', referenceImageFilenames: ['a.png'],
    })).toMatchObject({ id: 'gallery:job-9', day: '2026-10-02', images: 1, inputImages: 2 });
    expect(galleryImageUsageEvent({ id: 'local', mode: 'local', createdAt: '2026-10-02T00:00:00.000Z' })).toBeNull();
    const video = videoHistoryUsageEvents({
      id: 'clip-1', modelId: 'grok', mode: 'text', duration: 6, createdAt: '2026-10-03T00:00:00.000Z',
    });
    expect(video.map((event) => event.id)).toEqual(['video:clip-1', 'video-base:clip-1']);
    expect(video[0].videoSeconds).toBe(6);
  });

  it('ignores Imagine tool calls inside a PortOS scratch directory and defaults a missing duration', () => {
    const chat = JSON.stringify({
      type: 'assistant',
      tool_calls: [{ name: 'image_to_video', arguments: '{"prompt":"a fox"}' }],
    });
    expect(imagineEventsFromGrokSession({
      chatText: chat, sessionId: 's', cwd: '/tmp/portos-grok-abc', day: '2026-10-01',
    })).toEqual([]);
    const events = imagineEventsFromGrokSession({
      chatText: chat, sessionId: 's', cwd: '/home/example/notes', day: '2026-10-01',
    });
    expect(events).toEqual([expect.objectContaining({
      id: 'session-video:s:0', videoSeconds: 6, inputImages: 1, images: 0, source: 'estimate',
    })]);
  });
});