@robhowley/pi-openrouter 0.7.0 → 0.8.0

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));
+}

package/extensions/openrouter/models/mapper.ts

@@ -0,0 +1,182 @@
+import type { OpenRouterModel, PiModelConfig, SkipReason, MapResult } from './types.js';
+import { ROUTER_ALIASES } from './types.js';
+import type { Model as SDKModel } from '@openrouter/sdk/models/index.js';
+
+const COST_PER_MILLION = 1_000_000;
+const DEFAULT_MAX_TOKENS = 4096;
+
+/**
+ * Convert SDK Model to our OpenRouterModel type for compatibility.
+ * Handles SDK's camelCase naming convention.
+ */
+export function sdkModelToOpenRouterModel(model: SDKModel): OpenRouterModel {
+  const topProvider = model.topProvider
+    ? {
+        context_length: model.topProvider.contextLength ?? 0,
+        max_completion_tokens: model.topProvider.maxCompletionTokens ?? 0,
+      }
+    : undefined;
+
+  const perRequestLimits = model.perRequestLimits
+    ? {
+        completion_tokens: model.perRequestLimits.completionTokens ?? 0,
+      }
+    : undefined;
+
+  // Build the object conditionally to avoid undefined property issues
+  const result: OpenRouterModel = {
+    id: model.id,
+    name: model.name,
+    architecture: {
+      input_modalities: model.architecture.inputModalities ?? [],
+      output_modalities: model.architecture.outputModalities ?? [],
+    },
+    context_length: model.contextLength ?? 0,
+    pricing: {
+      prompt: String(model.pricing.prompt ?? 0),
+      completion: String(model.pricing.completion ?? 0),
+      input_cache_read: String(model.pricing.inputCacheRead ?? 0),
+      input_cache_write: String(model.pricing.inputCacheWrite ?? 0),
+    },
+    supported_parameters: model.supportedParameters,
+  };
+
+  // Conditionally add optional properties to avoid explicit undefined
+  if (topProvider) {
+    result.top_provider = topProvider;
+  }
+  if (perRequestLimits) {
+    result.per_request_limits = perRequestLimits;
+  }
+
+  return result;
+}
+
+/**
+ * Normalize input model to OpenRouterModel format.
+ */
+function normalizeModel(model: OpenRouterModel | SDKModel): OpenRouterModel {
+  return 'contextLength' in model
+    ? sdkModelToOpenRouterModel(model as SDKModel)
+    : (model as OpenRouterModel);
+}
+
+/**
+ * Validation result for a model check.
+ */
+type ValidationResult =
+  | { valid: true; model: OpenRouterModel; contextWindow: number }
+  | { valid: false; reason: string; modelId: string };
+
+/**
+ * Validate a model and return either a valid result with extracted context window
+ * or a failure reason.
+ */
+function validateModel(model: OpenRouterModel): ValidationResult {
+  // Check: missing required id
+  if (!model.id) {
+    return { valid: false, reason: 'missing id', modelId: 'unknown' };
+  }
+
+  // Check: missing required pricing fields
+  if (!model.pricing?.prompt) {
+    return { valid: false, reason: 'missing prompt pricing', modelId: model.id };
+  }
+  if (!model.pricing?.completion) {
+    return { valid: false, reason: 'missing completion pricing', modelId: model.id };
+  }
+
+  // Check: missing context window (both primary and fallback)
+  const contextWindow = model.top_provider?.context_length ?? model.context_length;
+  if (!contextWindow) {
+    return { valid: false, reason: 'missing context window', modelId: model.id };
+  }
+
+  // Check: explicitly non-text output (if specified)
+  const outputModalities = model.architecture?.output_modalities;
+  if (outputModalities && !outputModalities.includes('text')) {
+    return { valid: false, reason: 'non-text output modalities', modelId: model.id };
+  }
+
+  return { valid: true, model, contextWindow };
+}
+
+/**
+ * Build PiModelConfig from a validated OpenRouterModel.
+ */
+function buildPiConfig(model: OpenRouterModel, contextWindow: number): PiModelConfig {
+  const supportedParams = model.supported_parameters ?? [];
+  const hasReasoning =
+    supportedParams.includes('reasoning') || supportedParams.includes('include_reasoning');
+  const inputModalities = model.architecture?.input_modalities;
+  const supportsImages = inputModalities?.includes('image') ?? false;
+
+  return {
+    id: model.id,
+    name: model.name ?? model.id,
+    reasoning: hasReasoning,
+    input: supportsImages ? ['text', 'image'] : ['text'],
+    cost: {
+      input: Number(model.pricing.prompt) * COST_PER_MILLION,
+      output: Number(model.pricing.completion) * COST_PER_MILLION,
+      cacheRead: Number(model.pricing.input_cache_read ?? 0) * COST_PER_MILLION,
+      cacheWrite: Number(model.pricing.input_cache_write ?? 0) * COST_PER_MILLION,
+    },
+    contextWindow,
+    maxTokens:
+      model.top_provider?.max_completion_tokens ??
+      model.per_request_limits?.completion_tokens ??
+      DEFAULT_MAX_TOKENS,
+  };
+}
+
+/**
+ * Maps multiple OpenRouter models, tracking skips.
+ */
+export function mapOpenRouterModels(models: OpenRouterModel[] | SDKModel[]): MapResult {
+  const configs: PiModelConfig[] = [];
+  let skipped = 0;
+  const skippedDetails: SkipReason[] = [];
+
+  for (const rawModel of models) {
+    const model = normalizeModel(rawModel);
+
+    // Skip router aliases - they're added manually after mapping
+    if (ROUTER_ALIASES.includes(model.id)) {
+      continue;
+    }
+
+    const validation = validateModel(model);
+
+    if (!validation.valid) {
+      skipped++;
+      skippedDetails.push({ id: validation.modelId, reason: validation.reason });
+      continue;
+    }
+
+    configs.push(buildPiConfig(model, validation.contextWindow));
+  }
+
+  return { configs, skipped, skippedDetails };
+}
+
+/**
+ * Maps a single OpenRouter model to Pi model config.
+ * Returns null if the model should be skipped.
+ */
+export function mapOpenRouterModel(model: OpenRouterModel | SDKModel): PiModelConfig | null {
+  const normalized = normalizeModel(model);
+
+  // Router aliases are handled separately, skip them here
+  if (ROUTER_ALIASES.includes(normalized.id)) {
+    return null;
+  }
+
+  const validation = validateModel(normalized);
+
+  if (!validation.valid) {
+    return null;
+  }
+
+  return buildPiConfig(normalized, validation.contextWindow);
+}