@robhowley/pi-openrouter 0.8.3 → 0.9.1

package/extensions/openrouter/models/__tests__/overrides.test.ts

@@ -0,0 +1,237 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import {
+  loadModelOverrides,
+  ModelOverridesLoadError,
+  saveModelOverrides,
+  setModelOverride,
+  removeModelOverride,
+} from '../overrides.js';
+import type { ModelOverridesFile, UserModelOverride } from '../types.js';
+import { existsSync } from 'node:fs';
+import { readFile, writeFile, mkdir, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+
+// Mock node:fs
+vi.mock('node:fs', () => ({
+  existsSync: vi.fn(),
+}));
+
+// Mock node:fs/promises
+vi.mock('node:fs/promises', () => ({
+  readFile: vi.fn(),
+  writeFile: vi.fn(),
+  mkdir: vi.fn(),
+  rm: vi.fn(),
+}));
+
+// Mock node:os
+vi.mock('node:os', () => ({
+  homedir: vi.fn(),
+}));
+
+const OVERRIDES_FILE = join('/mock/home', '.pi', 'openrouter', 'model-overrides.json');
+
+describe('overrides', () => {
+  beforeEach(() => {
+    vi.mocked(homedir).mockReturnValue('/mock/home');
+    vi.mocked(existsSync).mockReturnValue(false);
+    vi.mocked(readFile).mockRejectedValue(new Error('ENOENT'));
+    vi.mocked(writeFile).mockResolvedValue(undefined);
+    vi.mocked(mkdir).mockResolvedValue(undefined);
+    vi.mocked(rm).mockResolvedValue(undefined);
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('loadModelOverrides', () => {
+    it('should return empty overrides when file does not exist', async () => {
+      vi.mocked(existsSync).mockReturnValue(false);
+
+      const result = await loadModelOverrides();
+
+      expect(result).toEqual({ version: 1, overrides: {} });
+    });
+
+    it('should throw when file is invalid JSON', async () => {
+      vi.mocked(existsSync).mockReturnValue(true);
+      vi.mocked(readFile).mockResolvedValue('invalid json');
+
+      await expect(loadModelOverrides()).rejects.toThrow(ModelOverridesLoadError);
+      await expect(loadModelOverrides()).rejects.toThrow('Invalid JSON in model overrides file');
+    });
+
+    it('should throw when file has wrong structure', async () => {
+      vi.mocked(existsSync).mockReturnValue(true);
+      vi.mocked(readFile).mockResolvedValue(JSON.stringify({ foo: 'bar' }));
+
+      await expect(loadModelOverrides()).rejects.toThrow(ModelOverridesLoadError);
+      await expect(loadModelOverrides()).rejects.toThrow('Invalid model overrides file structure');
+    });
+
+    it('should throw when existing file cannot be read', async () => {
+      vi.mocked(existsSync).mockReturnValue(true);
+      vi.mocked(readFile).mockRejectedValue(new Error('permission denied'));
+
+      await expect(loadModelOverrides()).rejects.toThrow(ModelOverridesLoadError);
+      await expect(loadModelOverrides()).rejects.toThrow('Failed to read model overrides file');
+    });
+
+    it('should load valid overrides file', async () => {
+      const mockData: ModelOverridesFile = {
+        version: 1,
+        overrides: {
+          'test/model': {
+            thinkingLevelMap: { high: 'high', xhigh: 'max' },
+          },
+        },
+      };
+      vi.mocked(existsSync).mockReturnValue(true);
+      vi.mocked(readFile).mockResolvedValue(JSON.stringify(mockData));
+
+      const result = await loadModelOverrides();
+
+      expect(result).toEqual(mockData);
+    });
+  });
+
+  describe('saveModelOverrides', () => {
+    it('should create directory if it does not exist', async () => {
+      vi.mocked(existsSync).mockReturnValue(false);
+
+      const overrides: ModelOverridesFile = { version: 1, overrides: {} };
+      await saveModelOverrides(overrides);
+
+      expect(mkdir).toHaveBeenCalledWith(join('/mock/home', '.pi', 'openrouter'), {
+        recursive: true,
+      });
+    });
+
+    it('should write JSON to file', async () => {
+      const overrides: ModelOverridesFile = {
+        version: 1,
+        overrides: {
+          'test/model': {
+            thinkingLevelMap: { high: 'high' },
+          },
+        },
+      };
+
+      await saveModelOverrides(overrides);
+
+      expect(writeFile).toHaveBeenCalledWith(
+        OVERRIDES_FILE,
+        JSON.stringify(overrides, null, 2),
+        'utf-8',
+      );
+    });
+  });
+
+  describe('setModelOverride', () => {
+    it('should add new override', () => {
+      const overrides: ModelOverridesFile = { version: 1, overrides: {} };
+      const override: UserModelOverride = {
+        thinkingLevelMap: { high: 'high' },
+      };
+
+      const result = setModelOverride(overrides, 'test/model', override);
+
+      expect(result.overrides['test/model']).toEqual({
+        thinkingLevelMap: { high: 'high' },
+      });
+    });
+
+    it('should merge with existing override', () => {
+      const existing: UserModelOverride = {
+        thinkingLevelMap: { minimal: null, high: 'low' },
+        contextWindow: 128000,
+      };
+      const overrides: ModelOverridesFile = {
+        version: 1,
+        overrides: { 'test/model': existing },
+      };
+
+      const newOverride: UserModelOverride = {
+        thinkingLevelMap: { high: 'high' },
+        maxTokens: 8192,
+      };
+
+      const result = setModelOverride(overrides, 'test/model', newOverride);
+
+      expect(result.overrides['test/model']).toEqual({
+        thinkingLevelMap: { minimal: null, high: 'high' },
+        contextWindow: 128000,
+        maxTokens: 8192,
+      });
+    });
+
+    it('should clean up undefined thinkingLevelMap entries', () => {
+      const overrides: ModelOverridesFile = { version: 1, overrides: {} };
+      const override: UserModelOverride = {
+        thinkingLevelMap: { high: 'high', medium: undefined as unknown as null },
+      };
+
+      const result = setModelOverride(overrides, 'test/model', override);
+
+      expect(result.overrides['test/model']?.thinkingLevelMap).toEqual({
+        high: 'high',
+      });
+    });
+
+    it('should remove empty thinkingLevelMap', () => {
+      const overrides: ModelOverridesFile = { version: 1, overrides: {} };
+      const override: UserModelOverride = {
+        thinkingLevelMap: {},
+        contextWindow: 128000,
+      };
+
+      const result = setModelOverride(overrides, 'test/model', override);
+
+      expect(result.overrides['test/model']?.thinkingLevelMap).toBeUndefined();
+      expect(result.overrides['test/model']?.contextWindow).toBe(128000);
+    });
+
+    it('should not create thinkingLevelMap for non-thinking overrides', () => {
+      const overrides: ModelOverridesFile = { version: 1, overrides: {} };
+
+      const result = setModelOverride(overrides, 'test/model', {
+        contextWindow: 64000,
+      });
+
+      expect(result.overrides['test/model']).toEqual({
+        contextWindow: 64000,
+      });
+    });
+  });
+
+  describe('removeModelOverride', () => {
+    it('should remove existing override', () => {
+      const overrides: ModelOverridesFile = {
+        version: 1,
+        overrides: {
+          'test/model': { thinkingLevelMap: { high: 'high' } },
+        },
+      };
+
+      const result = removeModelOverride(overrides, 'test/model');
+
+      expect(result.overrides['test/model']).toBeUndefined();
+      expect(Object.keys(result.overrides)).toHaveLength(0);
+    });
+
+    it('should be idempotent for non-existent model', () => {
+      const overrides: ModelOverridesFile = {
+        version: 1,
+        overrides: {
+          'other/model': { thinkingLevelMap: { high: 'high' } },
+        },
+      };
+
+      const result = removeModelOverride(overrides, 'unknown/model');
+
+      expect(result).toEqual(overrides);
+    });
+  });
+});

package/extensions/openrouter/models/__tests__/sync.test.ts

@@ -4,7 +4,9 @@
 
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import type { ExtensionContext, ModelRegistry } from '@mariozechner/pi-coding-agent';
-import type { SyncResult } from '../types.js';
+import type { PiModelConfig, SyncResult } from '../types.js';
+import { ROUTER_ALIASES } from '../types.js';
+import { createPiModelConfig, createValidModel } from '../../__tests__/fixtures.js';
 
 // Import modules
 import {
@@ -13,9 +15,10 @@ import {
   getSyncState,
   getStatusText,
   areModelsAvailable,
+  includeBuiltinRouterModels,
 } from '../sync.js';
 import { fetchUserModels, AuthError } from '../../client.js';
-import { loadCache } from '../cache.js';
+import { loadCache, saveCache } from '../cache.js';
 
 // Mock the client module to control API behavior
 vi.mock('../../client.js', () => ({
@@ -133,8 +136,13 @@ describe('syncModels', () => {
   it('should return failure when API key is missing and no cache', async () => {
     // Ensure API key is not set
     delete process.env['OPENROUTER_API_KEY'];
+    delete process.env['OPENROUTER_MANAGEMENT_KEY'];
     // Mock fetchUserModels to throw AuthError
-    vi.mocked(fetchUserModels).mockRejectedValueOnce(new AuthError('OPENROUTER_API_KEY not set'));
+    vi.mocked(fetchUserModels).mockRejectedValueOnce(
+      new AuthError(
+        'OpenRouter API key not configured. Set OPENROUTER_API_KEY or OPENROUTER_MANAGEMENT_KEY.',
+      ),
+    );
     // Mock loadCache to return null (no cache available)
     vi.mocked(loadCache).mockResolvedValueOnce(null);
 
@@ -143,7 +151,7 @@ describe('syncModels', () => {
     expect(result.success).toBe(false);
     expect(result.registeredCount).toBe(0);
     expect(result.source).toBe('none');
-    expect(result.error).toContain('OPENROUTER_API_KEY not set');
+    expect(result.error).toContain('OpenRouter API key not configured');
   });
 
   it('should sync models from API and register with provider', async () => {
@@ -182,6 +190,150 @@ describe('syncModels', () => {
     expect(result.registeredCount).toBeGreaterThan(0);
     expect(mockRegisterProvider).toHaveBeenCalled();
   });
+
+  it('should register the API user catalog plus router aliases exactly once', async () => {
+    const mockModel = {
+      id: 'user/model-a',
+      name: 'User Model A',
+      architecture: {
+        inputModalities: ['text'],
+        outputModalities: ['text'],
+      },
+      contextLength: 128000,
+      pricing: {
+        prompt: 0.000001,
+        completion: 0.000002,
+      },
+      supportedParameters: [],
+      topProvider: {
+        contextLength: 128000,
+        maxCompletionTokens: 4096,
+      },
+    };
+
+    vi.mocked(fetchUserModels).mockResolvedValueOnce({
+      data: [mockModel],
+    } as any);
+
+    const result = await syncModels(mockCtx);
+    const providerConfig = mockRegisterProvider.mock.calls[0]![1] as { models: PiModelConfig[] };
+    const registeredIds = providerConfig.models.map((model) => model.id);
+
+    expect(result.registeredCount).toBe(1 + ROUTER_ALIASES.length);
+    expect(registeredIds).toEqual(['user/model-a', ...ROUTER_ALIASES]);
+    expect(registeredIds).not.toContain('anthropic/claude-3-opus');
+  });
+
+  it('should register cached user models plus router aliases on API failure', async () => {
+    vi.mocked(fetchUserModels).mockRejectedValueOnce(new Error('api down'));
+    vi.mocked(loadCache).mockResolvedValueOnce({
+      models: [createValidModel({ id: 'cached/model-a', name: 'Cached Model A' })],
+      skippedDetails: [
+        {
+          id: 'bad/model',
+          reason: 'missing context window',
+          hint: "Add a local contextWindow override with '/openrouter model-override-set <model-id> contextWindow=<tokens>' if the model's limit is known.",
+        },
+      ],
+      timestamp: Date.now() - 60000,
+    });
+
+    const result = await syncModels(mockCtx);
+    const providerConfig = mockRegisterProvider.mock.calls[0]![1] as { models: PiModelConfig[] };
+    const registeredIds = providerConfig.models.map((model) => model.id);
+
+    expect(result.source).toBe('cache');
+    expect(result.registeredCount).toBe(1 + ROUTER_ALIASES.length);
+    expect(registeredIds).toEqual(['cached/model-a', ...ROUTER_ALIASES]);
+    expect(result.skippedDetails).toEqual([
+      {
+        id: 'bad/model',
+        reason: 'missing context window',
+        hint: "Add a local contextWindow override with '/openrouter model-override-set <model-id> contextWindow=<tokens>' if the model's limit is known.",
+      },
+    ]);
+  });
+
+  it('should persist skipped reason hints in the saved cache', async () => {
+    vi.mocked(fetchUserModels).mockResolvedValueOnce({
+      data: [
+        {
+          id: 'user/model-a',
+          name: 'User Model A',
+          architecture: {
+            inputModalities: ['text'],
+            outputModalities: ['text'],
+          },
+          contextLength: 128000,
+          pricing: {
+            prompt: 0.000001,
+            completion: 0.000002,
+          },
+          supportedParameters: [],
+          topProvider: {
+            contextLength: 128000,
+            maxCompletionTokens: 4096,
+          },
+        },
+        {
+          id: 'bad/model',
+          name: 'Bad Model',
+          architecture: {
+            inputModalities: ['text'],
+            outputModalities: ['text'],
+          },
+          contextLength: 0,
+          pricing: {
+            prompt: 0.000001,
+            completion: 0.000002,
+          },
+          supportedParameters: [],
+          topProvider: {
+            contextLength: 0,
+            maxCompletionTokens: 4096,
+          },
+        },
+      ],
+    } as any);
+
+    const result = await syncModels(mockCtx);
+
+    expect(result.skippedDetails).toEqual([
+      {
+        id: 'bad/model',
+        reason: 'missing context window',
+        hint: expect.stringContaining(
+          '/openrouter model-override-set <model-id> contextWindow=<tokens>',
+        ),
+      },
+    ]);
+    expect(vi.mocked(saveCache)).toHaveBeenCalledWith(
+      expect.objectContaining({
+        skippedDetails: [
+          {
+            id: 'bad/model',
+            reason: 'missing context window',
+            hint: expect.stringContaining(
+              '/openrouter model-override-set <model-id> contextWindow=<tokens>',
+            ),
+          },
+        ],
+      }),
+    );
+  });
+
+  it('should include router aliases at most once', () => {
+    const configs = includeBuiltinRouterModels([
+      createPiModelConfig({ id: 'user/model-a' }),
+      createPiModelConfig({ id: ROUTER_ALIASES[0]! }),
+    ]);
+    const registeredIds = configs.map((model) => model.id);
+
+    expect(registeredIds).toEqual(['user/model-a', ...ROUTER_ALIASES]);
+    for (const routerId of ROUTER_ALIASES) {
+      expect(registeredIds.filter((id) => id === routerId)).toHaveLength(1);
+    }
+  });
 });
 
 describe('syncState management', () => {

package/extensions/openrouter/models/cache.ts

@@ -6,6 +6,7 @@ import { MS_PER_MINUTE } from './types.js';
 
 const CACHE_FILENAME = 'models-cache.json';
 const DEFAULT_CACHE_DIR = join(homedir(), '.pi', 'openrouter');
+const MAX_FUTURE_SKEW_MS = 5 * MS_PER_MINUTE;
 
 // Allow overriding cache directory for testing
 let cacheDirOverride: string | null = null;
@@ -40,6 +41,21 @@ async function ensureCacheDir(): Promise<void> {
   await mkdir(getCacheDir(), { recursive: true });
 }
 
+/**
+ * Returns true when a cache timestamp is structurally valid and not too far in the future.
+ */
+function isValidCacheTimestamp(timestamp: number, now = Date.now()): boolean {
+  return Number.isFinite(timestamp) && timestamp <= now + MAX_FUTURE_SKEW_MS;
+}
+
+/**
+ * Clamp future timestamps when saving so new cache writes never persist negative ages.
+ */
+function normalizeTimestampForSave(timestamp: number, now = Date.now()): number {
+  if (!isValidCacheTimestamp(timestamp, now)) return now;
+  return Math.min(timestamp, now);
+}
+
 /**
  * Load cached models from disk.
  * Returns null if cache doesn't exist or is corrupted.
@@ -55,6 +71,10 @@ export async function loadCache(): Promise<ModelsCache | null> {
       return null;
     }
 
+    if (!isValidCacheTimestamp(parsed.timestamp)) {
+      return null;
+    }
+
     return parsed;
   } catch {
     // File doesn't exist, permission error, or invalid JSON
@@ -68,14 +88,18 @@ export async function loadCache(): Promise<ModelsCache | null> {
 export async function saveCache(cache: ModelsCache): Promise<void> {
   await ensureCacheDir();
   const cachePath = getCachePath();
-  await writeFile(cachePath, JSON.stringify(cache, null, 2));
+  const normalizedCache: ModelsCache = {
+    ...cache,
+    timestamp: normalizeTimestampForSave(cache.timestamp),
+  };
+  await writeFile(cachePath, JSON.stringify(normalizedCache, null, 2));
 }
 
 /**
  * Get the age of the cache in milliseconds.
  */
 export function getCacheAgeMs(cache: ModelsCache): number {
-  return Date.now() - cache.timestamp;
+  return Math.max(0, Date.now() - cache.timestamp);
 }
 
 /**
@@ -84,6 +108,7 @@ export function getCacheAgeMs(cache: ModelsCache): number {
  */
 export function formatDuration(ms: number | null): string {
   if (ms === null) return 'unknown';
+  if (ms <= 0) return '<1m';
 
   const minutes = Math.floor(ms / MS_PER_MINUTE);
   if (minutes < 1) return '<1m';