@robhowley/pi-openrouter 0.9.1 → 0.11.0

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

@@ -1,4 +1,4 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
 const mocks = vi.hoisted(() => ({
   stopBackgroundRefresh: vi.fn(),
@@ -10,6 +10,7 @@ const mocks = vi.hoisted(() => ({
   mapOpenRouterModels: vi.fn(),
   includeBuiltinRouterModels: vi.fn(),
   isSyncEnabled: vi.fn(),
+  loadOpenRouterStatusBar: vi.fn(),
 }));
 
 vi.mock('../cache.js', () => ({
@@ -40,6 +41,10 @@ vi.mock('../models/sync.js', () => ({
   isSyncEnabled: mocks.isSyncEnabled,
 }));
 
+vi.mock('../status-bar.js', () => ({
+  loadOpenRouterStatusBar: mocks.loadOpenRouterStatusBar,
+}));
+
 function createMockPi() {
   const handlers = new Map<string, any>();
   return {
@@ -69,6 +74,14 @@ function createMockContext(overrides: { hasUI?: boolean } = {}) {
   } as any;
 }
 
+function createDeferredPromise<T>() {
+  let resolve!: (value: T | PromiseLike<T>) => void;
+  const promise = new Promise<T>((res) => {
+    resolve = res;
+  });
+  return { promise, resolve };
+}
+
 async function loadHooksModule() {
   return import('../hooks.js');
 }
@@ -77,6 +90,7 @@ describe('openrouter hooks', () => {
   beforeEach(() => {
     vi.resetModules();
     vi.resetAllMocks();
+    vi.useRealTimers();
 
     mocks.isOpenRouterRequest.mockReturnValue(true);
     mocks.writeLocalUsage.mockResolvedValue(undefined);
@@ -86,9 +100,14 @@ describe('openrouter hooks', () => {
     mocks.mapOpenRouterModels.mockResolvedValue({ configs: [{ id: 'model-a' }] });
     mocks.includeBuiltinRouterModels.mockReturnValue([{ id: 'model-a' }, { id: 'router' }]);
     mocks.isSyncEnabled.mockReturnValue(true);
+    mocks.loadOpenRouterStatusBar.mockResolvedValue({ kind: 'empty' });
   });
 
-  it('loads cached startup models and preserves startup status text', async () => {
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it('loads cached startup models and preserves startup cache info', async () => {
     const { pi } = createMockPi();
     const { loadStartupCacheState } = await loadHooksModule();
 
@@ -148,41 +167,89 @@ describe('openrouter hooks', () => {
     expect(pi.on.mock.calls.filter(([event]) => event === 'session_shutdown')).toHaveLength(2);
   });
 
-  it('keeps session_start status and startup notifications unchanged', async () => {
+  it('sets startup usage status from the local burn-rate helper and keeps cache notifications', async () => {
     const { handlers, pi } = createMockPi();
     const ctx = createMockContext();
     const { initializeSessionState, installOpenRouterHooks } = await loadHooksModule();
 
+    mocks.loadOpenRouterStatusBar.mockResolvedValue({
+      kind: 'ready',
+      text: 'OR $2.14 today · 1.3x 30d avg',
+    });
+
     initializeSessionState();
     installOpenRouterHooks(pi as any, {
       info: { count: 5, age: '3 minutes' },
     });
 
-    handlers.get('session_start')({ reason: 'startup' }, ctx);
+    await handlers.get('session_start')({ reason: 'startup' }, ctx);
 
-    expect(ctx.ui.setStatus).toHaveBeenCalledWith('openrouter', 'dim:OpenRouter 5 models');
+    expect(mocks.loadOpenRouterStatusBar).toHaveBeenCalledTimes(1);
+    await vi.waitFor(() => {
+      expect(ctx.ui.setStatus).toHaveBeenCalledWith(
+        'openrouter',
+        'dim:OR $2.14 today · 1.3x 30d avg',
+      );
+    });
+    expect(String(ctx.ui.setStatus.mock.calls[0]?.[1] ?? '')).not.toContain('models');
     expect(ctx.ui.notify).toHaveBeenCalledWith(
       'OpenRouter: 5 models loaded from cache (3 minutes old). Run /openrouter models-sync to refresh.',
       'info',
     );
   });
 
-  it('keeps startup warning notifications unchanged', async () => {
+  it('clears stale startup status asynchronously when cached models exist but local spend is empty', async () => {
     const { handlers, pi } = createMockPi();
     const ctx = createMockContext();
     const { initializeSessionState, installOpenRouterHooks } = await loadHooksModule();
+    const statusLoad = createDeferredPromise<{ kind: 'ready'; text: string } | { kind: 'empty' }>();
+
+    mocks.loadOpenRouterStatusBar.mockReturnValue(statusLoad.promise);
+
+    initializeSessionState();
+    installOpenRouterHooks(pi as any, {
+      info: { count: 5, age: '3 minutes' },
+    });
+
+    await handlers.get('session_start')({ reason: 'startup' }, ctx);
+
+    expect(mocks.loadOpenRouterStatusBar).toHaveBeenCalledTimes(1);
+    expect(ctx.ui.notify).toHaveBeenCalledWith(
+      'OpenRouter: 5 models loaded from cache (3 minutes old). Run /openrouter models-sync to refresh.',
+      'info',
+    );
+    expect(ctx.ui.setStatus).not.toHaveBeenCalled();
+
+    statusLoad.resolve({ kind: 'empty' });
+
+    await vi.waitFor(() => {
+      expect(ctx.ui.setStatus).toHaveBeenCalledWith('openrouter', undefined);
+    });
+    expect(ctx.ui.theme.fg).not.toHaveBeenCalled();
+  });
+
+  it('preserves the existing startup status when the usage helper fails open', async () => {
+    const { handlers, pi } = createMockPi();
+    const ctx = createMockContext();
+    const { initializeSessionState, installOpenRouterHooks } = await loadHooksModule();
+
+    mocks.loadOpenRouterStatusBar.mockResolvedValue({ kind: 'failed' });
 
     initializeSessionState();
     installOpenRouterHooks(pi as any, {
       warning: 'OpenRouter: cached models found but failed to register: mapper failed',
     });
 
-    handlers.get('session_start')({ reason: 'startup' }, ctx);
+    await handlers.get('session_start')({ reason: 'startup' }, ctx);
 
+    expect(mocks.loadOpenRouterStatusBar).toHaveBeenCalledTimes(1);
     expect(ctx.ui.notify).toHaveBeenCalledWith(
       'OpenRouter: cached models found but failed to register: mapper failed',
       'warning',
     );
+    await Promise.resolve();
+    expect(ctx.ui.setStatus).not.toHaveBeenCalled();
+    expect(ctx.ui.theme.fg).not.toHaveBeenCalled();
   });
 
   it('keeps before_provider_request session tagging behavior unchanged through the installed hook', async () => {
@@ -214,13 +281,20 @@ describe('openrouter hooks', () => {
     });
   });
 
-  it('keeps turn_end local usage logging unchanged', async () => {
+  it('refreshes the usage status after a successful OpenRouter turn_end local write without blocking the hook', async () => {
     const { handlers, pi } = createMockPi();
     const ctx = createMockContext();
     const { initializeSessionState, installOpenRouterHooks } = await loadHooksModule();
     const randomUuidSpy = vi
       .spyOn(globalThis.crypto, 'randomUUID')
       .mockReturnValue('11111111-1111-4111-8111-111111111111');
+    const writeLocalUsageDeferred = createDeferredPromise<void>();
+
+    mocks.writeLocalUsage.mockReturnValue(writeLocalUsageDeferred.promise);
+    mocks.loadOpenRouterStatusBar.mockResolvedValue({
+      kind: 'ready',
+      text: 'OR $1.25 today · 30.0x 30d avg',
+    });
 
     initializeSessionState();
     installOpenRouterHooks(pi as any, {});
@@ -258,19 +332,198 @@ describe('openrouter hooks', () => {
         cost: 1.25,
       }),
     );
+    expect(mocks.loadOpenRouterStatusBar).not.toHaveBeenCalled();
+    expect(ctx.ui.setStatus).not.toHaveBeenCalled();
+
+    writeLocalUsageDeferred.resolve();
+
+    await vi.waitFor(() => {
+      expect(mocks.loadOpenRouterStatusBar).toHaveBeenCalledTimes(1);
+    });
+    const writeCallOrder = mocks.writeLocalUsage.mock.invocationCallOrder[0] ?? 0;
+    const refreshCallOrder = mocks.loadOpenRouterStatusBar.mock.invocationCallOrder[0] ?? 0;
+    expect(writeCallOrder).toBeLessThan(refreshCallOrder);
+    await vi.waitFor(() => {
+      expect(ctx.ui.setStatus).toHaveBeenCalledWith(
+        'openrouter',
+        'dim:OR $1.25 today · 30.0x 30d avg',
+      );
+    });
+    expect(String(ctx.ui.setStatus.mock.calls[0]?.[1] ?? '')).not.toContain('models');
 
     randomUuidSpy.mockRestore();
   });
 
-  it('stops background refresh on session shutdown', async () => {
+  it('does not write local usage or update status for non-OpenRouter turns', async () => {
     const { handlers, pi } = createMockPi();
+    const ctx = createMockContext();
     const { initializeSessionState, installOpenRouterHooks } = await loadHooksModule();
 
+    mocks.isOpenRouterRequest.mockReturnValue(false);
+    mocks.loadOpenRouterStatusBar.mockResolvedValue({
+      kind: 'ready',
+      text: 'OR $9.99 today · 9.9x 30d avg',
+    });
+
     initializeSessionState();
     installOpenRouterHooks(pi as any, {});
 
+    await handlers.get('turn_end')(
+      {
+        url: 'https://api.anthropic.com/v1/messages',
+        message: {
+          model: 'claude-sonnet-4',
+          responseId: 'resp-2',
+          usage: {
+            input: 4,
+            output: 2,
+            cost: { total: 0.42 },
+          },
+        },
+      },
+      ctx,
+    );
+
+    expect(mocks.writeLocalUsage).not.toHaveBeenCalled();
+    expect(mocks.loadOpenRouterStatusBar).not.toHaveBeenCalled();
+    expect(ctx.ui.setStatus).not.toHaveBeenCalled();
+  });
+
+  it('clears stale status after a turn when the usage helper reports empty local spend', async () => {
+    const { handlers, pi } = createMockPi();
+    const ctx = createMockContext();
+    const { initializeSessionState, installOpenRouterHooks } = await loadHooksModule();
+
+    mocks.loadOpenRouterStatusBar.mockResolvedValue({ kind: 'empty' });
+
+    initializeSessionState();
+    installOpenRouterHooks(pi as any, {});
+
+    await handlers.get('turn_end')(
+      {
+        url: 'https://openrouter.ai/api/v1/chat/completions',
+        message: {
+          model: 'openrouter/anthropic/claude-sonnet-4',
+          responseId: 'resp-3',
+          usage: {
+            input: 1,
+            output: 1,
+            cost: { total: 0.01 },
+          },
+        },
+      },
+      ctx,
+    );
+
+    await vi.waitFor(() => {
+      expect(ctx.ui.setStatus).toHaveBeenCalledWith('openrouter', undefined);
+    });
+  });
+
+  it('preserves the existing status after a turn when the usage helper fails open', async () => {
+    const { handlers, pi } = createMockPi();
+    const ctx = createMockContext();
+    const { initializeSessionState, installOpenRouterHooks } = await loadHooksModule();
+
+    mocks.loadOpenRouterStatusBar.mockResolvedValue({ kind: 'failed' });
+
+    initializeSessionState();
+    installOpenRouterHooks(pi as any, {});
+
+    await handlers.get('turn_end')(
+      {
+        url: 'https://openrouter.ai/api/v1/chat/completions',
+        message: {
+          model: 'openrouter/anthropic/claude-sonnet-4',
+          responseId: 'resp-4',
+          usage: {
+            input: 1,
+            output: 1,
+            cost: { total: 0.01 },
+          },
+        },
+      },
+      ctx,
+    );
+
+    await Promise.resolve();
+    expect(ctx.ui.setStatus).not.toHaveBeenCalled();
+    expect(ctx.ui.theme.fg).not.toHaveBeenCalled();
+  });
+
+  it('refreshes the status at UTC midnight and reschedules while the session stays active', async () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date('2026-05-22T23:59:50.000Z'));
+
+    const { handlers, pi } = createMockPi();
+    const ctx = createMockContext();
+    const { initializeSessionState, installOpenRouterHooks } = await loadHooksModule();
+
+    mocks.loadOpenRouterStatusBar
+      .mockResolvedValueOnce({ kind: 'ready', text: 'OR $4.50 today · 2.0x 30d avg' })
+      .mockResolvedValueOnce({ kind: 'ready', text: 'OR $0.25 today · 0.2x 30d avg' })
+      .mockResolvedValueOnce({ kind: 'ready', text: 'OR $0.30 today · 0.2x 30d avg' });
+
+    initializeSessionState();
+    installOpenRouterHooks(pi as any, {});
+
+    await handlers.get('session_start')({ reason: 'startup' }, ctx);
+
+    await vi.waitFor(() => {
+      expect(ctx.ui.setStatus).toHaveBeenCalledWith(
+        'openrouter',
+        'dim:OR $4.50 today · 2.0x 30d avg',
+      );
+    });
+    expect(mocks.loadOpenRouterStatusBar).toHaveBeenCalledTimes(1);
+
+    await vi.advanceTimersByTimeAsync(10_000);
+
+    await vi.waitFor(() => {
+      expect(mocks.loadOpenRouterStatusBar).toHaveBeenCalledTimes(2);
+    });
+    expect(ctx.ui.setStatus).toHaveBeenLastCalledWith(
+      'openrouter',
+      'dim:OR $0.25 today · 0.2x 30d avg',
+    );
+
+    await vi.advanceTimersByTimeAsync(24 * 60 * 60 * 1000);
+
+    await vi.waitFor(() => {
+      expect(mocks.loadOpenRouterStatusBar).toHaveBeenCalledTimes(3);
+    });
+    expect(ctx.ui.setStatus).toHaveBeenLastCalledWith(
+      'openrouter',
+      'dim:OR $0.30 today · 0.2x 30d avg',
+    );
+  });
+
+  it('clears the UTC-midnight rollover timer on session shutdown', async () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date('2026-05-22T23:59:50.000Z'));
+
+    const { handlers, pi } = createMockPi();
+    const ctx = createMockContext();
+    const { initializeSessionState, installOpenRouterHooks } = await loadHooksModule();
+
+    mocks.loadOpenRouterStatusBar.mockResolvedValue({
+      kind: 'ready',
+      text: 'OR $1.00 today · 1.0x 30d avg',
+    });
+
+    initializeSessionState();
+    installOpenRouterHooks(pi as any, {});
+
+    await handlers.get('session_start')({ reason: 'startup' }, ctx);
+    await vi.waitFor(() => {
+      expect(mocks.loadOpenRouterStatusBar).toHaveBeenCalledTimes(1);
+    });
+
     handlers.get('session_shutdown')();
 
+    await vi.advanceTimersByTimeAsync(24 * 60 * 60 * 1000);
+
+    expect(mocks.loadOpenRouterStatusBar).toHaveBeenCalledTimes(1);
     expect(mocks.stopBackgroundRefresh).toHaveBeenCalledTimes(1);
   });
 });

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

@@ -1,6 +1,11 @@
 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 type {
+  CreateKeysData,
+  GetCurrentKeyData,
+  ListData,
+  UpdateKeysData,
+} from '@openrouter/sdk/models/operations/index.js';
 import {
   normalizeOpenRouterModel,
   normalizeSdkKeyMetadata,
@@ -89,6 +94,58 @@ function createListKeyData(overrides: Partial<ListData> = {}): ListData {
   };
 }
 
+function createCreateKeysData(overrides: Partial<CreateKeysData> = {}): CreateKeysData {
+  return {
+    byokUsage: 0,
+    byokUsageDaily: 0,
+    byokUsageMonthly: 0,
+    byokUsageWeekly: 0,
+    createdAt: '2026-05-22T00:00:00.000Z',
+    creatorUserId: null,
+    disabled: false,
+    hash: 'hash-create',
+    includeByokInLimit: true,
+    label: 'sk-or-v1-create',
+    limit: 100,
+    limitRemaining: 40,
+    limitReset: 'weekly',
+    name: 'Created Key',
+    updatedAt: null,
+    usage: 60,
+    usageDaily: 0,
+    usageMonthly: 0,
+    usageWeekly: 0,
+    workspaceId: 'ws-create',
+    ...overrides,
+  };
+}
+
+function createUpdateKeysData(overrides: Partial<UpdateKeysData> = {}): UpdateKeysData {
+  return {
+    byokUsage: 0,
+    byokUsageDaily: 0,
+    byokUsageMonthly: 0,
+    byokUsageWeekly: 0,
+    createdAt: '2026-05-22T00:00:00.000Z',
+    creatorUserId: null,
+    disabled: false,
+    hash: 'hash-update',
+    includeByokInLimit: false,
+    label: 'sk-or-v1-update',
+    limit: 100,
+    limitRemaining: 40,
+    limitReset: null,
+    name: 'Updated Key',
+    updatedAt: null,
+    usage: 60,
+    usageDaily: 0,
+    usageMonthly: 0,
+    usageWeekly: 0,
+    workspaceId: 'ws-update',
+    ...overrides,
+  };
+}
+
 describe('sdkModelToOpenRouterModel', () => {
   it('normalizes SDK camelCase fields into canonical snake_case model shape', () => {
     const normalized = sdkModelToOpenRouterModel(
@@ -237,9 +294,9 @@ describe('normalizeSdkKeyMetadata', () => {
       remaining: 0,
       byok: 'excl',
       resetCadence: 'daily',
-      hash: 'unknown',
       disabled: false,
     });
+    expect(normalized).not.toHaveProperty('hash');
     expect('limit' in normalized).toBe(true);
     expect('remaining' in normalized).toBe(true);
   });
@@ -258,9 +315,9 @@ describe('normalizeSdkKeyMetadata', () => {
       name: 'sk-or-v1-current',
       byok: '?',
       resetCadence: 'partial',
-      hash: 'unknown',
       disabled: false,
     });
+    expect(normalized).not.toHaveProperty('hash');
     expect(normalized).not.toHaveProperty('limit');
     expect(normalized).not.toHaveProperty('remaining');
   });
@@ -285,4 +342,30 @@ describe('normalizeSdkKeyMetadata', () => {
       remaining: 40,
     });
   });
+
+  it('normalizes create responses with weekly resets', () => {
+    const normalized = normalizeSdkKeyMetadata(createCreateKeysData());
+
+    expect(normalized).toMatchObject({
+      name: 'Created Key',
+      label: 'sk-or-v1-create',
+      byok: 'incl',
+      resetCadence: 'weekly',
+      hash: 'hash-create',
+      disabled: false,
+    });
+  });
+
+  it('treats null limitReset in update responses as never', () => {
+    const normalized = normalizeSdkKeyMetadata(createUpdateKeysData());
+
+    expect(normalized).toMatchObject({
+      name: 'Updated Key',
+      label: 'sk-or-v1-update',
+      byok: 'excl',
+      resetCadence: 'never',
+      hash: 'hash-update',
+      disabled: false,
+    });
+  });
 });