@robhowley/pi-openrouter 0.7.1 → 0.8.1

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

@@ -0,0 +1,221 @@
+import { describe, it, expect } from 'vitest';
+import { mapOpenRouterModel, mapOpenRouterModels } from '../mapper.js';
+import { createValidModel } from '../../__tests__/fixtures.js';
+import type { OpenRouterModel, MapResult } from '../types.js';
+
+describe('mapOpenRouterModel', () => {
+  it('should map a valid model correctly', () => {
+    const model = createValidModel();
+    const result = mapOpenRouterModel(model);
+
+    expect(result).not.toBeNull();
+    expect(result!.id).toBe('test/model');
+    expect(result!.name).toBe('Test Model');
+    expect(result!.contextWindow).toBe(128000);
+    expect(result!.maxTokens).toBe(4096); // default
+    expect(result!.cost.input).toBe(0.5); // 0.0000005 * 1M
+    expect(result!.cost.output).toBe(1.5); // 0.0000015 * 1M
+  });
+
+  it('should use name fallback to id when name missing', () => {
+    const model = createValidModel();
+    // @ts-expect-error: intentionally setting name to undefined for test
+    model.name = undefined;
+    const result = mapOpenRouterModel(model);
+
+    expect(result!.name).toBe('test/model');
+  });
+
+  describe('skip conditions', () => {
+    const skipCases: Array<{
+      name: string;
+      overrides: Partial<OpenRouterModel> | ((m: OpenRouterModel) => void);
+    }> = [
+      { name: 'empty id', overrides: { id: '' } },
+      { name: 'undefined id (deleted property)', overrides: (m) => delete (m as any).id },
+      { name: 'missing pricing.prompt', overrides: { pricing: { completion: '0.000001' } as any } },
+      { name: 'missing pricing.completion', overrides: { pricing: { prompt: '0.000001' } as any } },
+      {
+        name: 'missing context_length and top_provider',
+        overrides: { context_length: 0, top_provider: { context_length: 0 } },
+      },
+      {
+        name: 'non-text output modalities',
+        overrides: { architecture: { output_modalities: ['image', 'audio'] } as any },
+      },
+    ];
+
+    skipCases.forEach(({ name, overrides }) => {
+      it(`should skip model with ${name}`, () => {
+        const model = createValidModel();
+        if (typeof overrides === 'function') {
+          overrides(model);
+        } else {
+          Object.assign(model, overrides);
+        }
+        expect(mapOpenRouterModel(model)).toBeNull();
+      });
+    });
+  });
+
+  describe('reasoning detection', () => {
+    it("should detect reasoning from 'reasoning' parameter", () => {
+      const model = createValidModel({
+        supported_parameters: ['temperature', 'reasoning', 'max_tokens'],
+      });
+      expect(mapOpenRouterModel(model)!.reasoning).toBe(true);
+    });
+
+    it("should detect reasoning from 'include_reasoning' parameter", () => {
+      const model = createValidModel({
+        supported_parameters: ['include_reasoning'],
+      });
+      expect(mapOpenRouterModel(model)!.reasoning).toBe(true);
+    });
+
+    it('should not detect reasoning when neither parameter present', () => {
+      const model = createValidModel({
+        supported_parameters: ['temperature', 'max_tokens'],
+      });
+      expect(mapOpenRouterModel(model)!.reasoning).toBe(false);
+    });
+
+    it('should handle missing supported_parameters', () => {
+      const model = createValidModel({ supported_parameters: [] as any });
+      expect(mapOpenRouterModel(model)!.reasoning).toBe(false);
+    });
+  });
+
+  describe('input modality detection', () => {
+    it('should detect image support from input_modalities', () => {
+      const model = createValidModel({
+        architecture: { input_modalities: ['text', 'image'] } as any,
+      });
+      expect(mapOpenRouterModel(model)!.input).toEqual(['text', 'image']);
+    });
+
+    it('should default to text-only without image in modalities', () => {
+      const model = createValidModel({
+        architecture: { input_modalities: ['text'] } as any,
+      });
+      expect(mapOpenRouterModel(model)!.input).toEqual(['text']);
+    });
+
+    it('should default to text-only when architecture missing', () => {
+      const model = createValidModel({ architecture: null as any });
+      expect(mapOpenRouterModel(model)!.input).toEqual(['text']);
+    });
+  });
+
+  describe('cost calculation', () => {
+    it('should convert per-token to per-1M-tokens', () => {
+      const model = createValidModel({
+        pricing: { prompt: '0.000002', completion: '0.000006' },
+      });
+      const result = mapOpenRouterModel(model);
+      expect(result!.cost.input).toBe(2.0); // 0.000002 * 1,000,000
+      expect(result!.cost.output).toBe(6.0); // 0.000006 * 1,000,000
+    });
+
+    it('should handle cache pricing when present', () => {
+      const model = createValidModel({
+        pricing: {
+          prompt: '0.000001',
+          completion: '0.000003',
+          input_cache_read: '0.0000005',
+          input_cache_write: '0.000001',
+        },
+      });
+      const result = mapOpenRouterModel(model);
+      expect(result!.cost.cacheRead).toBe(0.5);
+      expect(result!.cost.cacheWrite).toBe(1.0);
+    });
+
+    it('should default cache pricing to 0 when missing', () => {
+      const model = createValidModel({
+        pricing: { prompt: '0.000001', completion: '0.000003' },
+      });
+      const result = mapOpenRouterModel(model);
+      expect(result!.cost.cacheRead).toBe(0);
+      expect(result!.cost.cacheWrite).toBe(0);
+    });
+  });
+
+  describe('contextWindow fallback', () => {
+    it('should prefer top_provider.context_length', () => {
+      const model = createValidModel({
+        context_length: 8000,
+        top_provider: { context_length: 128000 },
+      });
+      expect(mapOpenRouterModel(model)!.contextWindow).toBe(128000);
+    });
+
+    it('should fall back to context_length', () => {
+      const model = createValidModel({
+        context_length: 32000,
+        top_provider: null as any,
+      });
+      expect(mapOpenRouterModel(model)!.contextWindow).toBe(32000);
+    });
+  });
+
+  describe('maxTokens fallback', () => {
+    it('should prefer top_provider.max_completion_tokens', () => {
+      const model = createValidModel({
+        top_provider: { max_completion_tokens: 8192 },
+        per_request_limits: { completion_tokens: 4096 },
+      });
+      expect(mapOpenRouterModel(model)!.maxTokens).toBe(8192);
+    });
+
+    it('should fall back to per_request_limits.completion_tokens', () => {
+      const model = createValidModel({
+        per_request_limits: { completion_tokens: 8192 },
+      });
+      expect(mapOpenRouterModel(model)!.maxTokens).toBe(8192);
+    });
+
+    it('should use default when neither present', () => {
+      const model = createValidModel();
+      expect(mapOpenRouterModel(model)!.maxTokens).toBe(4096);
+    });
+  });
+});
+
+describe('mapOpenRouterModels', () => {
+  it('should map multiple models and track skips', () => {
+    const models: OpenRouterModel[] = [
+      createValidModel({ id: 'model/valid-1', name: 'Valid 1' }),
+      createValidModel({ id: '', name: 'Invalid (no id)' }), // will skip
+      createValidModel({ id: 'model/valid-2', name: 'Valid 2' }),
+    ];
+
+    const result: MapResult = mapOpenRouterModels(models);
+
+    expect(result.configs).toHaveLength(2);
+    expect(result.skipped).toBe(1);
+    expect(result.configs[0]!.id).toBe('model/valid-1');
+    expect(result.configs[1]!.id).toBe('model/valid-2');
+  });
+
+  it('should handle empty array', () => {
+    const result = mapOpenRouterModels([] as OpenRouterModel[]);
+    expect(result.configs).toHaveLength(0);
+    expect(result.skipped).toBe(0);
+  });
+
+  it('should skip all invalid models', () => {
+    const models: OpenRouterModel[] = [
+      createValidModel({ id: '' }),
+      createValidModel({ pricing: { prompt: '0.000001' } as any }),
+      createValidModel({
+        context_length: 0,
+        top_provider: { context_length: 0 },
+      }),
+    ];
+
+    const result = mapOpenRouterModels(models);
+    expect(result.configs).toHaveLength(0);
+    expect(result.skipped).toBe(3);
+  });
+});

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

@@ -0,0 +1,313 @@
+/**
+ * Tests for the sync engine.
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import type { ExtensionContext, ModelRegistry } from '@mariozechner/pi-coding-agent';
+import type { SyncResult } from '../types.js';
+
+// Import modules
+import {
+  syncModels,
+  setSyncState,
+  getSyncState,
+  getStatusText,
+  areModelsAvailable,
+} from '../sync.js';
+import { fetchUserModels, AuthError } from '../../client.js';
+import { loadCache } from '../cache.js';
+
+// Mock the client module to control API behavior
+vi.mock('../../client.js', () => ({
+  fetchUserModels: vi.fn(),
+  isConfigured: vi.fn(),
+  getApiKey: vi.fn(),
+  AuthError: class AuthError extends Error {
+    constructor(message: string) {
+      super(message);
+      this.name = 'AuthError';
+    }
+  },
+}));
+
+// Mock the cache module
+vi.mock('../cache.js', () => ({
+  loadCache: vi.fn(),
+  saveCache: vi.fn(),
+  setCacheDir: vi.fn(),
+}));
+
+/**
+ * Factory for creating minimal mock ExtensionContext.
+ * Only implements methods/properties actually used by sync tests.
+ */
+function createMockExtensionContext(
+  overrides: {
+    registerProvider?: typeof vi.fn;
+  } = {},
+): ExtensionContext {
+  const mockFn = vi.fn;
+
+  return {
+    modelRegistry: {
+      registerProvider: overrides.registerProvider ?? mockFn(),
+    } as unknown as ModelRegistry,
+    ui: createMockUI(),
+    hasUI: true,
+    cwd: '/tmp',
+    sessionManager: createMockSessionManager(),
+    model: undefined,
+    isIdle: () => true,
+    signal: undefined,
+    abort: mockFn(),
+    hasPendingMessages: () => false,
+    shutdown: mockFn(),
+    getContextUsage: mockFn(),
+    compact: mockFn(),
+    getSystemPrompt: mockFn(),
+  } satisfies ExtensionContext;
+}
+
+function createMockUI(): ExtensionContext['ui'] {
+  const mockFn = vi.fn;
+  return {
+    select: mockFn(),
+    confirm: mockFn(),
+    input: mockFn(),
+    notify: mockFn(),
+    onTerminalInput: mockFn(),
+    setStatus: mockFn(),
+    setWorkingMessage: mockFn(),
+    setWorkingIndicator: mockFn(),
+    setHiddenThinkingLabel: mockFn(),
+    setWidget: mockFn(),
+    setFooter: mockFn(),
+    setHeader: mockFn(),
+    setTitle: mockFn(),
+    custom: mockFn(),
+    pasteToEditor: mockFn(),
+    setEditorText: mockFn(),
+    getEditorText: mockFn(),
+    editor: mockFn(),
+    setEditorComponent: mockFn(),
+    theme: {} as any,
+    getAllThemes: mockFn(),
+    getTheme: mockFn(),
+    setTheme: mockFn(),
+    getToolsExpanded: mockFn(),
+    setToolsExpanded: mockFn(),
+  };
+}
+
+/**
+ * Creates a mock session manager for testing.
+ * Uses `as any` since we only need the mock to satisfy ExtensionContext type,
+ * and sync tests don't actually use the session manager.
+ */
+function createMockSessionManager(): ExtensionContext['sessionManager'] {
+  const mockFn = vi.fn;
+  return {
+    getCurrentSessionId: mockFn(),
+    getCurrentSessionPath: mockFn(),
+    getEntry: mockFn(),
+    getEntryHistory: mockFn(),
+    getEntryById: mockFn(),
+    getBranchEntries: mockFn(),
+    getBranchSummary: mockFn(),
+    getRecentEntries: mockFn(),
+    getEntryCount: mockFn(),
+  } as any;
+}
+
+describe('syncModels', () => {
+  const mockRegisterProvider = vi.fn();
+  const mockCtx = createMockExtensionContext({ registerProvider: mockRegisterProvider });
+
+  beforeEach(() => {
+    vi.resetAllMocks();
+    (setSyncState as (result: SyncResult | null) => void)(null);
+    // Explicitly delete API key
+    delete process.env['OPENROUTER_API_KEY'];
+  });
+
+  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'];
+    // Mock fetchUserModels to throw AuthError
+    vi.mocked(fetchUserModels).mockRejectedValueOnce(new AuthError('OPENROUTER_API_KEY not set'));
+    // Mock loadCache to return null (no cache available)
+    vi.mocked(loadCache).mockResolvedValueOnce(null);
+
+    const result = await syncModels(mockCtx);
+
+    expect(result.success).toBe(false);
+    expect(result.registeredCount).toBe(0);
+    expect(result.source).toBe('none');
+    expect(result.error).toContain('OPENROUTER_API_KEY not set');
+  });
+
+  it('should sync models from API and register with provider', async () => {
+    // Mock successful API response with minimal model data
+    const mockModel = {
+      id: 'anthropic/claude-3-opus',
+      name: 'Claude 3 Opus',
+      architecture: {
+        inputModalities: ['text', 'image'],
+        outputModalities: ['text'],
+      },
+      contextLength: 200000,
+      pricing: {
+        prompt: 0.000015,
+        completion: 0.000075,
+        inputCacheRead: 0.0000015,
+        inputCacheWrite: 0.0000075,
+      },
+      supportedParameters: ['reasoning'],
+      topProvider: {
+        contextLength: 200000,
+        maxCompletionTokens: 4096,
+      },
+    };
+
+    vi.mocked(fetchUserModels).mockResolvedValueOnce({
+      data: [mockModel],
+    } as any);
+
+    vi.mocked(loadCache).mockResolvedValueOnce(null);
+
+    const result = await syncModels(mockCtx);
+
+    expect(result.success).toBe(true);
+    expect(result.source).toBe('api');
+    expect(result.registeredCount).toBeGreaterThan(0);
+    expect(mockRegisterProvider).toHaveBeenCalled();
+  });
+});
+
+describe('syncState management', () => {
+  it('should store and retrieve sync state', () => {
+    const mockResult: SyncResult = {
+      success: true,
+      registeredCount: 10,
+      skippedCount: 2,
+      source: 'api',
+      cacheUpdated: true,
+      cacheAgeMs: null,
+      error: null,
+    };
+
+    setSyncState(mockResult);
+
+    const retrieved = getSyncState();
+    expect(retrieved).toEqual(mockResult);
+  });
+
+  it('should return null when no state set', () => {
+    (setSyncState as (result: SyncResult | null) => void)(null);
+    expect(getSyncState()).toBeNull();
+  });
+});
+
+describe('getStatusText', () => {
+  beforeEach(() => {
+    (setSyncState as (result: SyncResult | null) => void)(null);
+  });
+
+  it('should return not synced when no state', () => {
+    expect(getStatusText()).toBe('OpenRouter models: not synced');
+  });
+
+  it('should return healthy for successful sync', () => {
+    setSyncState({
+      success: true,
+      registeredCount: 312,
+      skippedCount: 18,
+      source: 'api',
+      cacheUpdated: true,
+      cacheAgeMs: null,
+      error: null,
+    } as SyncResult);
+    const text = getStatusText();
+    expect(text).toContain('healthy');
+    expect(text).toContain('312 registered');
+  });
+
+  it('should return cached for cache fallback', () => {
+    setSyncState({
+      success: false,
+      registeredCount: 287,
+      skippedCount: 21,
+      source: 'cache',
+      cacheUpdated: false,
+      cacheAgeMs: 7200000, // 2 hours
+      error: '401 unauthorized',
+    } as SyncResult);
+    const text = getStatusText();
+    expect(text).toContain('cached');
+    expect(text).toContain('287 registered');
+  });
+
+  it('should return broken for complete failure', () => {
+    setSyncState({
+      success: false,
+      registeredCount: 0,
+      skippedCount: 0,
+      source: 'none',
+      cacheUpdated: false,
+      cacheAgeMs: null,
+      error: 'missing or invalid OpenRouter auth',
+    } as SyncResult);
+    const text = getStatusText();
+    expect(text).toContain('broken');
+    expect(text).toContain('0 registered');
+  });
+});
+
+describe('areModelsAvailable', () => {
+  beforeEach(() => {
+    (setSyncState as (result: SyncResult | null) => void)(null);
+  });
+
+  it('should return false when no state', async () => {
+    expect(await areModelsAvailable()).toBe(false);
+  });
+
+  it('should return true when models are synced', async () => {
+    setSyncState({
+      success: true,
+      registeredCount: 10,
+      skippedCount: 0,
+      source: 'api',
+      cacheUpdated: true,
+      cacheAgeMs: null,
+      error: null,
+    } as SyncResult);
+    expect(await areModelsAvailable()).toBe(true);
+  });
+
+  it('should return true when using cache (models still available)', async () => {
+    setSyncState({
+      success: false,
+      registeredCount: 5,
+      skippedCount: 0,
+      source: 'cache',
+      cacheUpdated: false,
+      cacheAgeMs: 7200000,
+      error: 'API error',
+    } as SyncResult);
+    expect(await areModelsAvailable()).toBe(true);
+  });
+
+  it('should return false when no models registered', async () => {
+    setSyncState({
+      success: false,
+      registeredCount: 0,
+      skippedCount: 0,
+      source: 'none',
+      cacheUpdated: false,
+      cacheAgeMs: null,
+      error: 'Complete failure',
+    } as SyncResult);
+    expect(await areModelsAvailable()).toBe(false);
+  });
+});

package/extensions/openrouter/models/cache.ts

@@ -0,0 +1,105 @@
+import { readFile, writeFile, mkdir } from 'fs/promises';
+import { join } from 'path';
+import { homedir } from 'os';
+import type { ModelsCache } from './types.js';
+import { MS_PER_MINUTE } from './types.js';
+
+const CACHE_FILENAME = 'models-cache.json';
+const DEFAULT_CACHE_DIR = join(homedir(), '.pi', 'openrouter');
+
+// Allow overriding cache directory for testing
+let cacheDirOverride: string | null = null;
+
+/**
+ * Get the cache directory.
+ * Uses override if set (for testing), otherwise uses default.
+ */
+function getCacheDir(): string {
+  return cacheDirOverride ?? DEFAULT_CACHE_DIR;
+}
+
+/**
+ * Set a custom cache directory (for testing).
+ * Pass null to reset to default.
+ */
+export function setCacheDir(dir: string | null): void {
+  cacheDirOverride = dir;
+}
+
+/**
+ * Get the full path to the cache file.
+ */
+function getCachePath(): string {
+  return join(getCacheDir(), CACHE_FILENAME);
+}
+
+/**
+ * Ensure the cache directory exists.
+ */
+async function ensureCacheDir(): Promise<void> {
+  await mkdir(getCacheDir(), { recursive: true });
+}
+
+/**
+ * Load cached models from disk.
+ * Returns null if cache doesn't exist or is corrupted.
+ */
+export async function loadCache(): Promise<ModelsCache | null> {
+  try {
+    const cachePath = getCachePath();
+    const data = await readFile(cachePath, 'utf-8');
+    const parsed = JSON.parse(data) as ModelsCache;
+
+    // Validate structure
+    if (!parsed.models || !Array.isArray(parsed.models) || typeof parsed.timestamp !== 'number') {
+      return null;
+    }
+
+    return parsed;
+  } catch {
+    // File doesn't exist, permission error, or invalid JSON
+    return null;
+  }
+}
+
+/**
+ * Save models to cache on disk.
+ */
+export async function saveCache(cache: ModelsCache): Promise<void> {
+  await ensureCacheDir();
+  const cachePath = getCachePath();
+  await writeFile(cachePath, JSON.stringify(cache, null, 2));
+}
+
+/**
+ * Get the age of the cache in milliseconds.
+ */
+export function getCacheAgeMs(cache: ModelsCache): number {
+  return Date.now() - cache.timestamp;
+}
+
+/**
+ * Format milliseconds duration for display.
+ * Examples: "<1m", "4m", "2h", "1d"
+ */
+export function formatDuration(ms: number | null): string {
+  if (ms === null) return 'unknown';
+
+  const minutes = Math.floor(ms / MS_PER_MINUTE);
+  if (minutes < 1) return '<1m';
+  if (minutes < 60) return `${minutes}m`;
+
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) return `${hours}h`;
+
+  return `${Math.floor(hours / 24)}d`;
+}
+
+/**
+ * Format cache age for display.
+ * Examples: "4m", "2h", "1d" (returns null for null cache)
+ */
+export function formatCacheAge(cache: ModelsCache | null): string | null {
+  if (!cache) return null;
+  return formatDuration(getCacheAgeMs(cache));
+}