@robhowley/pi-openrouter 0.9.0 → 0.9.1

package/extensions/openrouter/__tests__/normalizers.test.ts

@@ -0,0 +1,288 @@
+import { describe, expect, it } from 'vitest';
+import type { Model as SDKModel } from '@openrouter/sdk/models/index.js';
+import type { GetCurrentKeyData, ListData } from '@openrouter/sdk/models/operations/index.js';
+import {
+  normalizeOpenRouterModel,
+  normalizeSdkKeyMetadata,
+  sdkModelToOpenRouterModel,
+} from '../normalizers.js';
+import { createValidModel } from './fixtures.js';
+
+function createSdkModel(overrides: Partial<SDKModel> = {}): SDKModel {
+  return {
+    architecture: {
+      inputModalities: ['text'],
+      modality: 'text',
+      outputModalities: ['text'],
+    },
+    canonicalSlug: 'test/model',
+    contextLength: 128000,
+    created: 0,
+    defaultParameters: null,
+    id: 'test/model',
+    links: {} as SDKModel['links'],
+    name: 'Test Model',
+    perRequestLimits: null,
+    pricing: {
+      prompt: '0.0000005',
+      completion: '0.0000015',
+    },
+    supportedParameters: [],
+    topProvider: {
+      isModerated: false,
+    },
+    ...overrides,
+  };
+}
+
+function createCurrentKeyData(overrides: Partial<GetCurrentKeyData> = {}): GetCurrentKeyData {
+  return {
+    byokUsage: 0,
+    byokUsageDaily: 0,
+    byokUsageMonthly: 0,
+    byokUsageWeekly: 0,
+    creatorUserId: null,
+    includeByokInLimit: true,
+    isFreeTier: false,
+    isManagementKey: false,
+    isProvisioningKey: false,
+    label: 'sk-or-v1-current',
+    limit: 100,
+    limitRemaining: 40,
+    limitReset: 'monthly',
+    rateLimit: {
+      interval: 'day',
+      note: 'deprecated',
+      requests: -1,
+    },
+    usage: 60,
+    usageDaily: 0,
+    usageMonthly: 0,
+    usageWeekly: 0,
+    ...overrides,
+  };
+}
+
+function createListKeyData(overrides: Partial<ListData> = {}): ListData {
+  return {
+    byokUsage: 0,
+    byokUsageDaily: 0,
+    byokUsageMonthly: 0,
+    byokUsageWeekly: 0,
+    createdAt: '2026-05-22T00:00:00.000Z',
+    creatorUserId: null,
+    disabled: false,
+    hash: 'hash-123',
+    includeByokInLimit: true,
+    label: 'sk-or-v1-list',
+    limit: 100,
+    limitRemaining: 40,
+    limitReset: 'monthly',
+    name: 'Workspace Key',
+    updatedAt: null,
+    usage: 60,
+    usageDaily: 0,
+    usageMonthly: 0,
+    usageWeekly: 0,
+    workspaceId: 'ws-1',
+    ...overrides,
+  };
+}
+
+describe('sdkModelToOpenRouterModel', () => {
+  it('normalizes SDK camelCase fields into canonical snake_case model shape', () => {
+    const normalized = sdkModelToOpenRouterModel(
+      createSdkModel({
+        architecture: {
+          inputModalities: ['text', 'image'],
+          modality: 'text',
+          outputModalities: ['text'],
+        },
+        contextLength: null,
+        perRequestLimits: { completionTokens: 0, promptTokens: 123 },
+        pricing: {
+          prompt: '0.0000005',
+          completion: '0.0000015',
+          inputCacheRead: undefined,
+          inputCacheWrite: undefined,
+        },
+        supportedParameters: ['reasoning'],
+        topProvider: {
+          contextLength: null,
+          isModerated: false,
+          maxCompletionTokens: null,
+        },
+      }),
+    );
+
+    expect(normalized).toEqual({
+      id: 'test/model',
+      name: 'Test Model',
+      architecture: {
+        input_modalities: ['text', 'image'],
+        output_modalities: ['text'],
+      },
+      context_length: 0,
+      pricing: {
+        prompt: '0.0000005',
+        completion: '0.0000015',
+        input_cache_read: '0',
+        input_cache_write: '0',
+      },
+      supported_parameters: ['reasoning'],
+      top_provider: {
+        context_length: 0,
+        max_completion_tokens: 0,
+      },
+      per_request_limits: {
+        completion_tokens: 0,
+      },
+    });
+  });
+
+  it('omits optional provider/request blocks when the SDK omits them', () => {
+    const normalized = sdkModelToOpenRouterModel(
+      createSdkModel({
+        topProvider: null as unknown as SDKModel['topProvider'],
+        perRequestLimits: null,
+      }),
+    );
+
+    expect(normalized).not.toHaveProperty('top_provider');
+    expect(normalized).not.toHaveProperty('per_request_limits');
+  });
+
+  it('leaves canonical models unchanged when normalization is a no-op', () => {
+    const model = createValidModel({
+      top_provider: { context_length: 64000, max_completion_tokens: 8192 },
+      per_request_limits: { completion_tokens: 4096 },
+    });
+
+    expect(normalizeOpenRouterModel(model)).toBe(model);
+  });
+
+  it('guards against null architecture without crashing', () => {
+    const normalized = sdkModelToOpenRouterModel(
+      createSdkModel({
+        architecture: null as unknown as SDKModel['architecture'],
+      }),
+    );
+
+    expect(normalized).toMatchObject({
+      id: 'test/model',
+      name: 'Test Model',
+      context_length: 128000,
+      pricing: {
+        prompt: '0.0000005',
+        completion: '0.0000015',
+      },
+    });
+    expect(normalized).not.toHaveProperty('architecture');
+  });
+
+  it('guards against null pricing without pretending the model is free', () => {
+    const normalized = sdkModelToOpenRouterModel(
+      createSdkModel({
+        pricing: null as unknown as SDKModel['pricing'],
+      }),
+    );
+
+    expect(normalized).toMatchObject({
+      id: 'test/model',
+      name: 'Test Model',
+      context_length: 128000,
+    });
+    expect(normalized).not.toHaveProperty('pricing');
+  });
+
+  it('guards against undefined architecture without crashing', () => {
+    const normalized = sdkModelToOpenRouterModel(
+      createSdkModel({
+        architecture: undefined as unknown as SDKModel['architecture'],
+      }),
+    );
+
+    expect(normalized).not.toHaveProperty('architecture');
+    expect(normalized.pricing).toBeDefined();
+  });
+
+  it('guards against undefined pricing without crashing', () => {
+    const normalized = sdkModelToOpenRouterModel(
+      createSdkModel({
+        pricing: undefined as unknown as SDKModel['pricing'],
+      }),
+    );
+
+    expect(normalized).not.toHaveProperty('pricing');
+  });
+});
+
+describe('normalizeSdkKeyMetadata', () => {
+  it('preserves zero limits and zero remaining distinctly from absent values', () => {
+    const normalized = normalizeSdkKeyMetadata(
+      createCurrentKeyData({
+        includeByokInLimit: false,
+        limit: 0,
+        limitRemaining: 0,
+        limitReset: 'DAILY',
+        usage: 0,
+      }),
+    );
+
+    expect(normalized).toMatchObject({
+      name: 'sk-or-v1-current',
+      label: 'sk-or-v1-current',
+      used: 0,
+      limit: 0,
+      remaining: 0,
+      byok: 'excl',
+      resetCadence: 'daily',
+      hash: 'unknown',
+      disabled: false,
+    });
+    expect('limit' in normalized).toBe(true);
+    expect('remaining' in normalized).toBe(true);
+  });
+
+  it('omits null limits and keeps unknown byok/reset cases partial', () => {
+    const normalized = normalizeSdkKeyMetadata(
+      createCurrentKeyData({
+        includeByokInLimit: undefined as never,
+        limit: null,
+        limitRemaining: null,
+        limitReset: undefined as never,
+      }),
+    );
+
+    expect(normalized).toMatchObject({
+      name: 'sk-or-v1-current',
+      byok: '?',
+      resetCadence: 'partial',
+      hash: 'unknown',
+      disabled: false,
+    });
+    expect(normalized).not.toHaveProperty('limit');
+    expect(normalized).not.toHaveProperty('remaining');
+  });
+
+  it('keeps list-only metadata such as name, hash, disabled, and never resets', () => {
+    const normalized = normalizeSdkKeyMetadata(
+      createListKeyData({
+        disabled: true,
+        includeByokInLimit: true,
+        limitReset: 'never',
+      }),
+    );
+
+    expect(normalized).toMatchObject({
+      name: 'Workspace Key',
+      label: 'sk-or-v1-list',
+      byok: 'incl',
+      resetCadence: 'never',
+      hash: 'hash-123',
+      disabled: true,
+      limit: 100,
+      remaining: 40,
+    });
+  });
+});

package/extensions/openrouter/__tests__/overlay.test.ts

@@ -0,0 +1,225 @@
+import { describe, it, expect, afterEach } from 'vitest';
+import { UsageOverlayComponent } from '../overlay.js';
+import { createUsageSummary, createUsageAggregate } from './fixtures.js';
+import type { Theme } from '@mariozechner/pi-coding-agent';
+
+/**
+ * Minimal identity theme for testing.
+ * Returns text unchanged to simplify assertions.
+ */
+function createIdentityTheme(): Theme {
+  return {
+    bold: (text: string) => text,
+    fg: (_style: string, text: string) => text,
+  } as Theme;
+}
+
+/**
+ * Test suite for overlay Today-row rendering safety net.
+ *
+ * These tests prove the fix for the Today-row / local-window mismatch bug.
+ * The contract: the row labeled `Today` must render `summary.today`,
+ * not `summary.local.cost` or `summary.local.requests`.
+ */
+describe('UsageOverlayComponent - Today row rendering', () => {
+  const components: UsageOverlayComponent[] = [];
+
+  afterEach(() => {
+    // Dispose all components to prevent interval timer leaks
+    for (const component of components) {
+      component.dispose();
+    }
+    components.length = 0;
+  });
+
+  function createComponent(summary: ReturnType<typeof createUsageSummary>): UsageOverlayComponent {
+    const component = new UsageOverlayComponent(
+      summary,
+      null, // no error
+      null, // no cached age
+      createIdentityTheme(),
+      () => {}, // onClose
+      () => {}, // requestRender
+    );
+    components.push(component);
+    return component;
+  }
+
+  /**
+   * Find the Today row line in rendered output.
+   * Returns the line or null if not found.
+   */
+  function findTodayLine(lines: string[]): string | null {
+    return lines.find((line) => line.includes('Today')) ?? null;
+  }
+
+  describe('Activity API absent / 30-day local fallback', () => {
+    it.each([
+      {
+        label: 'local aggregate includes older + today usage',
+        today: 0.5,
+        localCost: 3.5,
+        localRequests: 15,
+        expectedTodayDisplay: 'Today ~$0.50',
+        excludedAmount: '3.50',
+      },
+      {
+        label: 'local aggregate is zero',
+        today: 0,
+        localCost: 0,
+        localRequests: 0,
+        expectedTodayDisplay: 'Today ~$0.00',
+        excludedAmount: null,
+      },
+    ])(
+      'renders Today using summary.today when $label',
+      ({ today, localCost, localRequests, expectedTodayDisplay, excludedAmount }) => {
+        const summary = createUsageSummary({
+          today,
+          hasActivityData: false,
+          local: createUsageAggregate({
+            cost: localCost,
+            requests: localRequests,
+          }),
+          combined: createUsageAggregate({
+            cost: localCost,
+            requests: localRequests,
+          }),
+        });
+
+        const component = createComponent(summary);
+        const lines = component.render(120);
+        const todayLine = findTodayLine(lines);
+
+        expect(todayLine).toBeTruthy();
+        expect(todayLine).toContain(expectedTodayDisplay);
+        if (excludedAmount) {
+          expect(todayLine).not.toContain(excludedAmount);
+        }
+        expect(todayLine).not.toContain('reqs');
+      },
+    );
+  });
+
+  describe('Activity API behind / local spans multiple post-official days', () => {
+    it.each([
+      {
+        label: 'API through yesterday, local has yesterday + today',
+        today: 2.0,
+        week: 0,
+        month: 0,
+        officialThroughDate: '2026-05-24',
+        officialCost: 10.0,
+        officialRequests: 50,
+        localCost: 4.0,
+        localRequests: 20,
+        combinedCost: 14.0,
+        combinedRequests: 70,
+        expectedTodayDisplay: 'Today ~$2.00',
+        excludedAmount: '4.00',
+      },
+      {
+        label: 'API 5 days behind, local has 5 days',
+        today: 1.5,
+        week: 15.0,
+        month: 50.0,
+        officialThroughDate: '2026-05-20',
+        officialCost: 40.0,
+        officialRequests: 200,
+        localCost: 10.0,
+        localRequests: 50,
+        combinedCost: 50.0,
+        combinedRequests: 250,
+        expectedTodayDisplay: 'Today ~$1.50',
+        excludedAmount: '10.00',
+      },
+    ])(
+      'renders Today using summary.today when $label',
+      ({
+        today,
+        week,
+        month,
+        officialThroughDate,
+        officialCost,
+        officialRequests,
+        localCost,
+        localRequests,
+        combinedCost,
+        combinedRequests,
+        expectedTodayDisplay,
+        excludedAmount,
+      }) => {
+        const summary = createUsageSummary({
+          today,
+          week,
+          month,
+          hasActivityData: true,
+          officialThroughDate,
+          official: createUsageAggregate({
+            cost: officialCost,
+            requests: officialRequests,
+          }),
+          local: createUsageAggregate({
+            cost: localCost,
+            requests: localRequests,
+          }),
+          combined: createUsageAggregate({
+            cost: combinedCost,
+            requests: combinedRequests,
+          }),
+        });
+
+        const component = createComponent(summary);
+        const lines = component.render(120);
+        const todayLine = findTodayLine(lines);
+
+        expect(todayLine).toBeTruthy();
+        expect(todayLine).toContain(expectedTodayDisplay);
+        expect(todayLine).not.toContain(excludedAmount);
+        expect(todayLine).not.toContain('reqs');
+      },
+    );
+  });
+
+  describe('Activity API has today / local is empty', () => {
+    it.each([
+      {
+        label: 'API includes today',
+        today: 3.0,
+        officialThroughDate: '2026-05-25',
+        officialCost: 20.0,
+        officialRequests: 100,
+        expectedTodayDisplay: 'Today ~$3.00',
+      },
+    ])(
+      'renders Today using summary.today when $label',
+      ({ today, officialThroughDate, officialCost, officialRequests, expectedTodayDisplay }) => {
+        const summary = createUsageSummary({
+          today,
+          hasActivityData: true,
+          officialThroughDate,
+          official: createUsageAggregate({
+            cost: officialCost,
+            requests: officialRequests,
+          }),
+          local: createUsageAggregate({
+            cost: 0,
+            requests: 0,
+          }),
+          combined: createUsageAggregate({
+            cost: officialCost,
+            requests: officialRequests,
+          }),
+        });
+
+        const component = createComponent(summary);
+        const lines = component.render(120);
+        const todayLine = findTodayLine(lines);
+
+        expect(todayLine).toBeTruthy();
+        expect(todayLine).toContain(expectedTodayDisplay);
+        expect(todayLine).not.toContain('reqs');
+      },
+    );
+  });
+});