@robhowley/pi-openrouter 0.9.0 → 0.10.0

package/extensions/openrouter/__tests__/status-bar.test.ts

@@ -0,0 +1,262 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import * as fs from 'node:fs/promises';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { setLocalUsageDir, dedupeLocalUsageEvents } from '../local-usage.js';
+import {
+  calculateOpenRouterStatusStats,
+  formatOpenRouterStatusBar,
+  loadOpenRouterStatusBar,
+  loadOpenRouterStatusStats,
+  type OpenRouterStatusStats,
+} from '../status-bar.js';
+import type { LocalUsageEvent } from '../types.js';
+
+let testDir: string;
+
+function createLocalUsageEvent(
+  id: string,
+  completedAt: string,
+  cost: number,
+  overrides: Partial<LocalUsageEvent> = {},
+): LocalUsageEvent {
+  return {
+    id,
+    generationId: `${id}-generation`,
+    sessionId: 'session-test',
+    completedAt,
+    requests: 1,
+    model: 'openrouter/anthropic/claude-sonnet-4',
+    provider: 'anthropic',
+    promptTokens: 10,
+    completionTokens: 5,
+    cost,
+    ...overrides,
+  };
+}
+
+async function writeDailyFile(
+  dateUtc: string,
+  rows: Array<LocalUsageEvent | string>,
+): Promise<void> {
+  const content = rows
+    .map((row) => (typeof row === 'string' ? row : JSON.stringify(row)))
+    .join('\n');
+  await fs.writeFile(path.join(testDir, `${dateUtc}.jsonl`), `${content}\n`, 'utf8');
+}
+
+beforeEach(async () => {
+  testDir = path.join(
+    os.tmpdir(),
+    `pi-openrouter-status-bar-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  );
+  await fs.mkdir(testDir, { recursive: true });
+  setLocalUsageDir(testDir);
+});
+
+afterEach(async () => {
+  setLocalUsageDir(null);
+  vi.restoreAllMocks();
+  vi.doUnmock('../local-usage.js');
+  vi.doUnmock('../status-bar.js');
+
+  try {
+    await fs.rm(testDir, { recursive: true, force: true });
+  } catch {
+    // Ignore cleanup errors.
+  }
+});
+
+describe('calculateOpenRouterStatusStats', () => {
+  it('returns null for no local events', () => {
+    expect(calculateOpenRouterStatusStats([], '2026-05-22')).toBeNull();
+  });
+
+  it('returns null when the full 30-day window totals zero local spend', () => {
+    expect(
+      calculateOpenRouterStatusStats(
+        [
+          createLocalUsageEvent('today-zero', '2026-05-22T09:15:00.000Z', 0),
+          createLocalUsageEvent('older-zero', '2026-05-12T09:15:00.000Z', 0),
+        ],
+        '2026-05-22',
+      ),
+    ).toBeNull();
+  });
+
+  it('includes only UTC-today spend and divides by exactly 30 calendar days', () => {
+    const stats = calculateOpenRouterStatusStats(
+      [
+        createLocalUsageEvent('today', '2026-05-22T09:15:00.000Z', 3),
+        createLocalUsageEvent('yesterday', '2026-05-21T09:15:00.000Z', 9),
+      ],
+      '2026-05-22',
+    );
+
+    expect(stats).toEqual({
+      todayLocalSpend: 3,
+      averageLocalDailySpendLast30Days: 0.4,
+      burnRateMultiplier: 7.5,
+    });
+  });
+
+  it('uses only the today-29 through today window', () => {
+    const stats = calculateOpenRouterStatusStats(
+      [
+        createLocalUsageEvent('old', '2026-04-22T12:00:00.000Z', 100),
+        createLocalUsageEvent('boundary', '2026-04-23T12:00:00.000Z', 6),
+        createLocalUsageEvent('recent', '2026-05-21T12:00:00.000Z', 3),
+        createLocalUsageEvent('today', '2026-05-22T12:00:00.000Z', 1.5),
+      ],
+      '2026-05-22',
+    );
+
+    expect(stats).toEqual({
+      todayLocalSpend: 1.5,
+      averageLocalDailySpendLast30Days: 0.35,
+      burnRateMultiplier: 1.5 / 0.35,
+    });
+  });
+
+  it('deduplicates event ids exactly once across the full 30-day window', () => {
+    const events = [
+      createLocalUsageEvent('duplicate-id', '2026-05-20T12:00:00.000Z', 1),
+      createLocalUsageEvent('duplicate-id', '2026-05-22T12:00:00.000Z', 99),
+      createLocalUsageEvent('unique-id', '2026-05-22T13:00:00.000Z', 2),
+    ];
+
+    expect(dedupeLocalUsageEvents(events)).toHaveLength(2);
+    expect(calculateOpenRouterStatusStats(events, '2026-05-22')).toEqual({
+      todayLocalSpend: 2,
+      averageLocalDailySpendLast30Days: 0.1,
+      burnRateMultiplier: 20,
+    });
+  });
+});
+
+describe('formatOpenRouterStatusBar', () => {
+  it('formats the representative status text exactly', () => {
+    const stats: OpenRouterStatusStats = {
+      todayLocalSpend: 2.14,
+      averageLocalDailySpendLast30Days: 1.64,
+      burnRateMultiplier: 1.3,
+    };
+
+    expect(formatOpenRouterStatusBar(stats)).toBe('OR $2.14 today · 1.3x 30d avg');
+  });
+
+  it('formats $0.00 today · 0.0x 30d avg when prior 30-day spend exists but today spend is zero', () => {
+    const stats: OpenRouterStatusStats = {
+      todayLocalSpend: 0,
+      averageLocalDailySpendLast30Days: 0.5,
+      burnRateMultiplier: 0,
+    };
+
+    expect(formatOpenRouterStatusBar(stats)).toBe('OR $0.00 today · 0.0x 30d avg');
+  });
+
+  it('omits the multiplier when given a stats object with no denominator', () => {
+    expect(
+      formatOpenRouterStatusBar({
+        todayLocalSpend: 2.14,
+        averageLocalDailySpendLast30Days: 0,
+        burnRateMultiplier: null,
+      }),
+    ).toBe('OR $2.14 today');
+  });
+});
+
+describe('loadOpenRouterStatusStats and loadOpenRouterStatusBar', () => {
+  it('returns an empty result for empty local usage data', async () => {
+    const now = new Date('2026-05-22T12:00:00.000Z');
+
+    await expect(loadOpenRouterStatusStats(now)).resolves.toBeNull();
+    await expect(loadOpenRouterStatusBar(now)).resolves.toEqual({ kind: 'empty' });
+  });
+
+  it('returns an empty result when the 30-day window has only zero-cost local rows', async () => {
+    await writeDailyFile('2026-05-12', [
+      createLocalUsageEvent('older-zero', '2026-05-12T12:00:00.000Z', 0),
+    ]);
+    await writeDailyFile('2026-05-22', [
+      createLocalUsageEvent('today-zero', '2026-05-22T12:00:00.000Z', 0),
+    ]);
+
+    const now = new Date('2026-05-22T12:00:00.000Z');
+
+    await expect(loadOpenRouterStatusStats(now)).resolves.toBeNull();
+    await expect(loadOpenRouterStatusBar(now)).resolves.toEqual({ kind: 'empty' });
+  });
+
+  it('requests local usage only from today-29 through today', async () => {
+    vi.resetModules();
+    const actualLocalUsage =
+      await vi.importActual<typeof import('../local-usage.js')>('../local-usage.js');
+    const readLocalUsage = vi
+      .fn()
+      .mockResolvedValue([
+        createLocalUsageEvent('boundary', '2026-04-23T12:00:00.000Z', 1),
+        createLocalUsageEvent('today', '2026-05-22T12:00:00.000Z', 2),
+      ]);
+
+    vi.doMock('../local-usage.js', () => ({
+      ...actualLocalUsage,
+      readLocalUsage,
+    }));
+
+    const { loadOpenRouterStatusStats: loadMockedStats } = await import('../status-bar.js');
+
+    await expect(loadMockedStats(new Date('2026-05-22T12:00:00.000Z'))).resolves.toEqual({
+      todayLocalSpend: 2,
+      averageLocalDailySpendLast30Days: 0.1,
+      burnRateMultiplier: 20,
+    });
+    expect(readLocalUsage).toHaveBeenCalledTimes(1);
+    expect(readLocalUsage).toHaveBeenCalledWith({
+      fromDateUtc: '2026-04-23',
+      toDateUtc: '2026-05-22',
+    });
+  });
+
+  it('tolerates missing files and malformed rows while returning a ready status', async () => {
+    await writeDailyFile('2026-05-10', [
+      createLocalUsageEvent('older', '2026-05-10T12:00:00.000Z', 4),
+      '{not json}',
+    ]);
+    await writeDailyFile('2026-05-22', [
+      createLocalUsageEvent('today', '2026-05-22T12:00:00.000Z', 2),
+      '',
+    ]);
+
+    const now = new Date('2026-05-22T12:00:00.000Z');
+
+    await expect(loadOpenRouterStatusStats(now)).resolves.toEqual({
+      todayLocalSpend: 2,
+      averageLocalDailySpendLast30Days: 0.2,
+      burnRateMultiplier: 10,
+    });
+    await expect(loadOpenRouterStatusBar(now)).resolves.toEqual({
+      kind: 'ready',
+      text: 'OR $2.00 today · 10.0x 30d avg',
+    });
+  });
+
+  it('returns a failed result when the local usage read path throws unexpectedly', async () => {
+    vi.resetModules();
+
+    const readLocalUsage = vi.fn().mockRejectedValue(new Error('disk exploded'));
+    vi.doMock('../local-usage.js', async () => {
+      const actual = await vi.importActual<typeof import('../local-usage.js')>('../local-usage.js');
+      return {
+        ...actual,
+        readLocalUsage,
+      };
+    });
+
+    const { loadOpenRouterStatusBar: loadMockedBar } = await import('../status-bar.js');
+
+    await expect(loadMockedBar(new Date('2026-05-22T12:00:00.000Z'))).resolves.toEqual({
+      kind: 'failed',
+    });
+  });
+});

package/extensions/openrouter/account-client.ts

@@ -3,6 +3,7 @@ import type { KeyInfo, KeyStatus } from './account-types.js';
 
 // Re-export error types from client.ts
 import { AuthError, ApiError } from './client.js';
+import { normalizeSdkKeyMetadata } from './normalizers.js';
 
 let client: OpenRouter | null = null;
 
@@ -33,8 +34,6 @@ export async function getAccountCredits(): Promise<number | null> {
 // Key Management API
 // =============================================================================
 
-import type { GetCurrentKeyData, ListData } from '@openrouter/sdk/models/operations/index.js';
-
 // Workspace ID for the default workspace (empty string) - used when workspaceId is not specified
 const DEFAULT_WORKSPACE_ID = '';
 
@@ -61,7 +60,9 @@ export async function getAllKeys(): Promise<KeyInfo[] | null> {
       const response = await client.apiKeys.list({ workspaceId, includeDisabled: true });
       const rawKeys = response.data;
 
-      const keys = rawKeys.map((raw) => rawToKeyInfo(raw, workspace.name));
+      const keys = rawKeys.map((raw) =>
+        keyMetadataToKeyInfo(normalizeSdkKeyMetadata(raw), workspace.name),
+      );
       allKeys.push(...keys);
     }
 
@@ -81,7 +82,7 @@ export async function getCurrentKey(): Promise<KeyInfo | null> {
   if (!client) return null;
   try {
     const response = await client.apiKeys.getCurrentKeyMetadata();
-    return rawToKeyInfo(response.data, 'Current Workspace');
+    return keyMetadataToKeyInfo(normalizeSdkKeyMetadata(response.data), 'Current Workspace');
   } catch (err) {
     throw mapSdkError(err);
   }
@@ -91,60 +92,11 @@ export async function getCurrentKey(): Promise<KeyInfo | null> {
 // Helper Functions
 // =============================================================================
 
-function rawToKeyInfo(raw: GetCurrentKeyData | ListData, workspaceName: string): KeyInfo {
-  const used = raw.usage ?? raw.usageMonthly ?? 0;
-
-  // limit is number | null in both GetCurrentKeyData and ListData
-  const limitValue = raw.limit;
-
-  // remaining is number | null in both types
-  const remainingValue = raw.limitRemaining;
-
-  // Determine BYOK status
-  let byok: 'incl' | 'excl' | '?' = '?';
-  if (raw.includeByokInLimit === true) {
-    byok = 'incl';
-  } else if (raw.includeByokInLimit === false) {
-    byok = 'excl';
-  }
-
-  // Determine reset cadence
-  let resetCadence: 'monthly' | 'daily' | 'never' | 'partial' = 'partial';
-  if (raw.limitReset) {
-    const reset = raw.limitReset.toLowerCase();
-    if (reset === 'monthly') {
-      resetCadence = 'monthly';
-    } else if (reset === 'daily') {
-      resetCadence = 'daily';
-    } else if (reset === 'never') {
-      resetCadence = 'never';
-    }
-  }
-
-  // Determine hash (ListData has hash, GetCurrentKeyData doesn't)
-  const hash = 'hash' in raw ? (raw as ListData).hash : 'unknown';
-
-  // Determine name (ListData has name, GetCurrentKeyData doesn't - use label as fallback)
-  const name = 'name' in raw ? (raw as ListData).name : raw.label;
-
-  // Get disabled status (ListData has it, GetCurrentKeyData doesn't)
-  const disabled = 'disabled' in raw ? (raw as ListData).disabled : false;
-
-  // For exactOptionalPropertyTypes, we need to handle optional properties carefully
-  // The SDK returns number | null but KeyInfo expects number | undefined (or just number)
-  // We use type assertion to tell TypeScript that limit/remaining are either number or not set
-
-  // When limitValue is null, we set limit to undefined (or omit it)
-  // When limitValue is a number, we keep it as is
-  let limit: number | undefined;
-  if (limitValue !== null) {
-    limit = limitValue;
-  }
-
-  let remaining: number | undefined;
-  if (remainingValue !== null) {
-    remaining = remainingValue;
-  }
+function keyMetadataToKeyInfo(
+  metadata: ReturnType<typeof normalizeSdkKeyMetadata>,
+  workspaceName: string,
+): KeyInfo {
+  const { name, label, used, limit, remaining, resetCadence, byok, hash, disabled } = metadata;
 
   // Calculate status based on usage percentage
   let status: KeyStatus;
@@ -167,10 +119,9 @@ function rawToKeyInfo(raw: GetCurrentKeyData | ListData, workspaceName: string):
     }
   }
 
-  // Create the object
   const keyInfo: KeyInfo = {
     name,
-    label: raw.label,
+    label,
     status,
     used,
     spend: used, // spend is the same as usage (in USD)
@@ -181,7 +132,6 @@ function rawToKeyInfo(raw: GetCurrentKeyData | ListData, workspaceName: string):
     workspaceName,
   };
 
-  // Set optional properties explicitly
   if (limit !== undefined) {
     keyInfo.limit = limit;
   }