@robhowley/pi-openrouter 0.8.0 → 0.8.2

package/extensions/openrouter/index.ts

@@ -27,11 +27,15 @@ import {
   groupSkipReasons,
 } from './models/sync.js';
 import { loadCache, getCacheAgeMs, formatDuration } from './models/cache.js';
+import { mapOpenRouterModels } from './models/mapper.js';
 
 // Store the current session state for use in command handlers
 let currentSessionState: OpenRouterSessionState | null = null;
 let sessionTrackingInstalled = false;
 
+// Store startup cache state for notifications
+let startupCacheInfo: { count: number; age: string } | undefined;
+
 // =============================================================================
 // Utility Functions
 // =============================================================================
@@ -87,7 +91,36 @@ function getCurrentSessionId(ctx: { sessionManager: { getSessionId(): string } }
   }
 }
 
-export default function (pi: ExtensionAPI) {
+export default async function (pi: ExtensionAPI) {
+  // Eager cache load on extension startup (before any sessions)
+  startupCacheInfo = undefined;
+  let startupCacheWarning: string | undefined;
+  if (isSyncEnabled()) {
+    const cache = await loadCache().catch(() => null);
+
+    if (cache?.models.length) {
+      try {
+        const { configs } = await mapOpenRouterModels(cache.models);
+
+        // Register models directly with Pi's OpenRouter provider
+        pi.registerProvider('openrouter', {
+          baseUrl: 'https://openrouter.ai/api/v1',
+          apiKey: 'OPENROUTER_API_KEY',
+          api: 'openai-completions',
+          models: configs,
+          authHeader: true,
+        });
+
+        // Store for session_start notification
+        const age = formatDuration(getCacheAgeMs(cache));
+        startupCacheInfo = { count: configs.length, age };
+      } catch (error) {
+        startupCacheInfo = undefined;
+        startupCacheWarning = `OpenRouter: cached models found but failed to register: ${error instanceof Error ? error.message : String(error)}`;
+      }
+    }
+  }
+
   // Install before_provider_request hook once
   if (!sessionTrackingInstalled) {
     sessionTrackingInstalled = true;
@@ -198,6 +231,27 @@ export default function (pi: ExtensionAPI) {
     stopBackgroundRefresh();
   });
 
+  // Notify on first session start after extension load
+  pi.on('session_start', (event, ctx) => {
+    if (!ctx.hasUI) return;
+
+    // Show a persistent status indicator
+    if (startupCacheInfo) {
+      const statusText = `OpenRouter ${startupCacheInfo.count} models`;
+      ctx.ui.setStatus('openrouter', ctx.ui.theme.fg('dim', statusText));
+    }
+
+    // Show a one-time notification on startup
+    if (event.reason === 'startup' && startupCacheInfo) {
+      const notice = `OpenRouter: ${startupCacheInfo.count} models loaded from cache (${startupCacheInfo.age} old). Run /openrouter models-sync to refresh.`;
+      ctx.ui.notify(notice, 'info');
+    }
+
+    if (event.reason === 'startup' && startupCacheWarning) {
+      ctx.ui.notify(startupCacheWarning, 'warning');
+    }
+  });
+
   pi.registerCommand('openrouter-usage', {
     description: 'Show OpenRouter usage: caps, spend, burn rate, and model breakdowns',
     getArgumentCompletions: () => null,

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

@@ -4,9 +4,9 @@ import { createValidModel } from '../../__tests__/fixtures.js';
 import type { OpenRouterModel, MapResult } from '../types.js';
 
 describe('mapOpenRouterModel', () => {
-  it('should map a valid model correctly', () => {
+  it('should map a valid model correctly', async () => {
     const model = createValidModel();
-    const result = mapOpenRouterModel(model);
+    const result = await mapOpenRouterModel(model);
 
     expect(result).not.toBeNull();
     expect(result!.id).toBe('test/model');
@@ -17,11 +17,11 @@ describe('mapOpenRouterModel', () => {
     expect(result!.cost.output).toBe(1.5); // 0.0000015 * 1M
   });
 
-  it('should use name fallback to id when name missing', () => {
+  it('should use name fallback to id when name missing', async () => {
     const model = createValidModel();
     // @ts-expect-error: intentionally setting name to undefined for test
     model.name = undefined;
-    const result = mapOpenRouterModel(model);
+    const result = await mapOpenRouterModel(model);
 
     expect(result!.name).toBe('test/model');
   });
@@ -46,78 +46,78 @@ describe('mapOpenRouterModel', () => {
     ];
 
     skipCases.forEach(({ name, overrides }) => {
-      it(`should skip model with ${name}`, () => {
+      it(`should skip model with ${name}`, async () => {
         const model = createValidModel();
         if (typeof overrides === 'function') {
           overrides(model);
         } else {
           Object.assign(model, overrides);
         }
-        expect(mapOpenRouterModel(model)).toBeNull();
+        expect(await mapOpenRouterModel(model)).toBeNull();
       });
     });
   });
 
   describe('reasoning detection', () => {
-    it("should detect reasoning from 'reasoning' parameter", () => {
+    it("should detect reasoning from 'reasoning' parameter", async () => {
       const model = createValidModel({
         supported_parameters: ['temperature', 'reasoning', 'max_tokens'],
       });
-      expect(mapOpenRouterModel(model)!.reasoning).toBe(true);
+      expect((await mapOpenRouterModel(model))!.reasoning).toBe(true);
     });
 
-    it("should detect reasoning from 'include_reasoning' parameter", () => {
+    it("should detect reasoning from 'include_reasoning' parameter", async () => {
       const model = createValidModel({
         supported_parameters: ['include_reasoning'],
       });
-      expect(mapOpenRouterModel(model)!.reasoning).toBe(true);
+      expect((await mapOpenRouterModel(model))!.reasoning).toBe(true);
     });
 
-    it('should not detect reasoning when neither parameter present', () => {
+    it('should not detect reasoning when neither parameter present', async () => {
       const model = createValidModel({
         supported_parameters: ['temperature', 'max_tokens'],
       });
-      expect(mapOpenRouterModel(model)!.reasoning).toBe(false);
+      expect((await mapOpenRouterModel(model))!.reasoning).toBe(false);
     });
 
-    it('should handle missing supported_parameters', () => {
+    it('should handle missing supported_parameters', async () => {
       const model = createValidModel({ supported_parameters: [] as any });
-      expect(mapOpenRouterModel(model)!.reasoning).toBe(false);
+      expect((await mapOpenRouterModel(model))!.reasoning).toBe(false);
     });
   });
 
   describe('input modality detection', () => {
-    it('should detect image support from input_modalities', () => {
+    it('should detect image support from input_modalities', async () => {
       const model = createValidModel({
         architecture: { input_modalities: ['text', 'image'] } as any,
       });
-      expect(mapOpenRouterModel(model)!.input).toEqual(['text', 'image']);
+      expect((await mapOpenRouterModel(model))!.input).toEqual(['text', 'image']);
     });
 
-    it('should default to text-only without image in modalities', () => {
+    it('should default to text-only without image in modalities', async () => {
       const model = createValidModel({
         architecture: { input_modalities: ['text'] } as any,
       });
-      expect(mapOpenRouterModel(model)!.input).toEqual(['text']);
+      expect((await mapOpenRouterModel(model))!.input).toEqual(['text']);
     });
 
-    it('should default to text-only when architecture missing', () => {
+    it('should default to text-only when architecture missing', async () => {
       const model = createValidModel({ architecture: null as any });
-      expect(mapOpenRouterModel(model)!.input).toEqual(['text']);
+      expect((await mapOpenRouterModel(model))!.input).toEqual(['text']);
     });
   });
 
   describe('cost calculation', () => {
-    it('should convert per-token to per-1M-tokens', () => {
+    it('should convert per-token to per-1M-tokens', async () => {
       const model = createValidModel({
         pricing: { prompt: '0.000002', completion: '0.000006' },
       });
-      const result = mapOpenRouterModel(model);
+      const result = await 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', () => {
+    it('should handle cache pricing when present', async () => {
       const model = createValidModel({
         pricing: {
           prompt: '0.000001',
@@ -126,71 +126,90 @@ describe('mapOpenRouterModel', () => {
           input_cache_write: '0.000001',
         },
       });
-      const result = mapOpenRouterModel(model);
+      const result = await 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', () => {
+    it('should default cache pricing to 0 when missing', async () => {
       const model = createValidModel({
         pricing: { prompt: '0.000001', completion: '0.000003' },
       });
-      const result = mapOpenRouterModel(model);
+      const result = await mapOpenRouterModel(model);
       expect(result!.cost.cacheRead).toBe(0);
       expect(result!.cost.cacheWrite).toBe(0);
     });
   });
 
   describe('contextWindow fallback', () => {
-    it('should prefer top_provider.context_length', () => {
+    it('should prefer top_provider.context_length', async () => {
       const model = createValidModel({
         context_length: 8000,
         top_provider: { context_length: 128000 },
       });
-      expect(mapOpenRouterModel(model)!.contextWindow).toBe(128000);
+      expect((await mapOpenRouterModel(model))!.contextWindow).toBe(128000);
     });
 
-    it('should fall back to context_length', () => {
+    it('should fall back to context_length', async () => {
       const model = createValidModel({
         context_length: 32000,
         top_provider: null as any,
       });
-      expect(mapOpenRouterModel(model)!.contextWindow).toBe(32000);
+      expect((await mapOpenRouterModel(model))!.contextWindow).toBe(32000);
     });
   });
 
   describe('maxTokens fallback', () => {
-    it('should prefer top_provider.max_completion_tokens', () => {
+    it('should prefer top_provider.max_completion_tokens', async () => {
       const model = createValidModel({
         top_provider: { max_completion_tokens: 8192 },
         per_request_limits: { completion_tokens: 4096 },
       });
-      expect(mapOpenRouterModel(model)!.maxTokens).toBe(8192);
+      expect((await mapOpenRouterModel(model))!.maxTokens).toBe(8192);
     });
 
-    it('should fall back to per_request_limits.completion_tokens', () => {
+    it('should fall back to per_request_limits.completion_tokens', async () => {
       const model = createValidModel({
         per_request_limits: { completion_tokens: 8192 },
       });
-      expect(mapOpenRouterModel(model)!.maxTokens).toBe(8192);
+      expect((await mapOpenRouterModel(model))!.maxTokens).toBe(8192);
     });
 
-    it('should use default when neither present', () => {
+    it('should use default when neither present', async () => {
       const model = createValidModel();
-      expect(mapOpenRouterModel(model)!.maxTokens).toBe(4096);
+      expect((await mapOpenRouterModel(model))!.maxTokens).toBe(4096);
+    });
+  });
+
+  describe('thinkingLevelMap', () => {
+    it('should include thinkingLevelMap when available from built-in registry', async () => {
+      // This test documents the expected behavior when the model exists
+      // in Pi's built-in registry. The actual lookup happens via dynamic import
+      // of @mariozechner/pi-ai or @earendil-works/pi-ai at runtime.
+      const model = createValidModel({
+        id: 'deepseek/deepseek-v4-pro',
+        supported_parameters: ['reasoning'],
+      });
+      const result = await mapOpenRouterModel(model);
+      expect(result).not.toBeNull();
+      // If pi-ai is available and has this model, thinkingLevelMap will be set
+      // Otherwise it will be undefined (which is valid)
+      expect(
+        result!.thinkingLevelMap === undefined || typeof result!.thinkingLevelMap === 'object',
+      ).toBe(true);
     });
   });
 });
 
 describe('mapOpenRouterModels', () => {
-  it('should map multiple models and track skips', () => {
+  it('should map multiple models and track skips', async () => {
     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);
+    const result: MapResult = await mapOpenRouterModels(models);
 
     expect(result.configs).toHaveLength(2);
     expect(result.skipped).toBe(1);
@@ -198,13 +217,13 @@ describe('mapOpenRouterModels', () => {
     expect(result.configs[1]!.id).toBe('model/valid-2');
   });
 
-  it('should handle empty array', () => {
-    const result = mapOpenRouterModels([] as OpenRouterModel[]);
+  it('should handle empty array', async () => {
+    const result = await mapOpenRouterModels([] as OpenRouterModel[]);
     expect(result.configs).toHaveLength(0);
     expect(result.skipped).toBe(0);
   });
 
-  it('should skip all invalid models', () => {
+  it('should skip all invalid models', async () => {
     const models: OpenRouterModel[] = [
       createValidModel({ id: '' }),
       createValidModel({ pricing: { prompt: '0.000001' } as any }),
@@ -214,7 +233,7 @@ describe('mapOpenRouterModels', () => {
       }),
     ];
 
-    const result = mapOpenRouterModels(models);
+    const result = await mapOpenRouterModels(models);
     expect(result.configs).toHaveLength(0);
     expect(result.skipped).toBe(3);
   });

package/extensions/openrouter/models/mapper.ts

@@ -2,6 +2,58 @@ import type { OpenRouterModel, PiModelConfig, SkipReason, MapResult } from './ty
 import { ROUTER_ALIASES } from './types.js';
 import type { Model as SDKModel } from '@openrouter/sdk/models/index.js';
 
+// Cache for built-in OpenRouter models from pi-ai
+// Populated lazily on first access
+let builtInOpenRouterModels: Map<string, PiModelConfig> | undefined;
+
+/**
+ * Load built-in OpenRouter models from pi-ai package if available.
+ * This allows us to preserve thinkingLevelMap and other metadata from
+ * Pi's built-in registry when syncing models from OpenRouter API.
+ */
+async function loadBuiltInOpenRouterModels(): Promise<Map<string, PiModelConfig>> {
+  if (builtInOpenRouterModels !== undefined) {
+    return builtInOpenRouterModels;
+  }
+
+  const models = new Map<string, PiModelConfig>();
+
+  try {
+    // Import from pi-ai to get built-in model registry
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const { getModels } = (await import('@earendil-works/pi-ai')) as {
+      getModels: (provider: string) => unknown[];
+    };
+
+    const openrouterModels = getModels('openrouter');
+    if (Array.isArray(openrouterModels)) {
+      for (const model of openrouterModels) {
+        // Extract thinkingLevelMap from built-in model if present
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const modelWithThinking = model as { id: string; thinkingLevelMap?: unknown };
+        if (modelWithThinking.id) {
+          models.set(modelWithThinking.id, model as PiModelConfig);
+        }
+      }
+    }
+  } catch {
+    // Ignore - built-in registry not available, will sync without merging
+  }
+
+  builtInOpenRouterModels = models;
+  return models;
+}
+
+/**
+ * Get thinkingLevelMap from built-in registry for a model, if available.
+ */
+async function getBuiltInThinkingLevelMap(
+  modelId: string,
+): Promise<PiModelConfig['thinkingLevelMap'] | undefined> {
+  const builtIn = await loadBuiltInOpenRouterModels();
+  return builtIn.get(modelId)?.thinkingLevelMap;
+}
+
 const COST_PER_MILLION = 1_000_000;
 const DEFAULT_MAX_TOKENS = 4096;
 
@@ -103,15 +155,22 @@ function validateModel(model: OpenRouterModel): ValidationResult {
 
 /**
  * Build PiModelConfig from a validated OpenRouterModel.
+ * Merges thinkingLevelMap from Pi's built-in registry if available.
  */
-function buildPiConfig(model: OpenRouterModel, contextWindow: number): PiModelConfig {
+async function buildPiConfig(
+  model: OpenRouterModel,
+  contextWindow: number,
+): Promise<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 {
+  // Fetch thinkingLevelMap from built-in registry if this is a reasoning model
+  const thinkingLevelMap = hasReasoning ? await getBuiltInThinkingLevelMap(model.id) : undefined;
+
+  const config: PiModelConfig = {
     id: model.id,
     name: model.name ?? model.id,
     reasoning: hasReasoning,
@@ -128,12 +187,25 @@ function buildPiConfig(model: OpenRouterModel, contextWindow: number): PiModelCo
       model.per_request_limits?.completion_tokens ??
       DEFAULT_MAX_TOKENS,
   };
+
+  // Only add thinkingLevelMap if it's defined for exactOptionalPropertyTypes compatibility
+  if (thinkingLevelMap !== undefined) {
+    config.thinkingLevelMap = thinkingLevelMap;
+  }
+
+  return config;
 }
 
 /**
  * Maps multiple OpenRouter models, tracking skips.
+ * Async to allow fetching thinkingLevelMap from built-in registry.
  */
-export function mapOpenRouterModels(models: OpenRouterModel[] | SDKModel[]): MapResult {
+export async function mapOpenRouterModels(
+  models: OpenRouterModel[] | SDKModel[],
+): Promise<MapResult> {
+  // Pre-load built-in models for efficient lookup during mapping
+  await loadBuiltInOpenRouterModels();
+
   const configs: PiModelConfig[] = [];
   let skipped = 0;
   const skippedDetails: SkipReason[] = [];
@@ -154,7 +226,7 @@ export function mapOpenRouterModels(models: OpenRouterModel[] | SDKModel[]): Map
       continue;
     }
 
-    configs.push(buildPiConfig(model, validation.contextWindow));
+    configs.push(await buildPiConfig(model, validation.contextWindow));
   }
 
   return { configs, skipped, skippedDetails };
@@ -163,8 +235,13 @@ export function mapOpenRouterModels(models: OpenRouterModel[] | SDKModel[]): Map
 /**
  * Maps a single OpenRouter model to Pi model config.
  * Returns null if the model should be skipped.
+ * Async to allow fetching thinkingLevelMap from built-in registry.
  */
-export function mapOpenRouterModel(model: OpenRouterModel | SDKModel): PiModelConfig | null {
+export async function mapOpenRouterModel(
+  model: OpenRouterModel | SDKModel,
+): Promise<PiModelConfig | null> {
+  await loadBuiltInOpenRouterModels();
+
   const normalized = normalizeModel(model);
 
   // Router aliases are handled separately, skip them here

package/extensions/openrouter/models/sync.ts

@@ -66,7 +66,7 @@ export function getSyncState(): SyncResult | null {
  * Uses modelRegistry.registerProvider() to add models to the built-in openrouter provider.
  * The models array replaces all existing models for the provider.
  */
-async function registerModelsWithProvider(
+export async function registerModelsWithProvider(
   ctx: ExtensionContext,
   configs: PiModelConfig[],
 ): Promise<void> {
@@ -79,8 +79,6 @@ async function registerModelsWithProvider(
     models: configs,
     authHeader: true,
   });
-
-  console.log(`[pi-openrouter] Registered ${configs.length} models with OpenRouter provider`);
 }
 
 /**
@@ -134,7 +132,7 @@ export async function syncModels(_ctx: ExtensionContext): Promise<SyncResult> {
   // Attempt 1: Fetch from API
   try {
     const response = await fetchUserModels();
-    const { configs, skipped, skippedDetails } = mapOpenRouterModels(response.data);
+    const { configs, skipped, skippedDetails } = await mapOpenRouterModels(response.data);
 
     // Add built-in router aliases that don't appear in /models/user endpoint
     const configsWithRouters = [...configs, ...BUILTIN_ROUTER_MODELS];
@@ -174,7 +172,7 @@ export async function syncModels(_ctx: ExtensionContext): Promise<SyncResult> {
 
     if (cache) {
       // Attempt 2: Use cached models
-      const { configs, skipped } = mapOpenRouterModels(cache.models);
+      const { configs, skipped } = await mapOpenRouterModels(cache.models);
 
       await registerModelsWithProvider(_ctx, configs);
 

package/extensions/openrouter/models/types.ts

@@ -32,6 +32,20 @@ export interface OpenRouterModelsResponse {
   data: OpenRouterModel[];
 }
 
+/**
+ * Pi thinking level map - copied from pi-ai's Model type.
+ * Levels mapped to null are hidden in Pi's UI.
+ * Levels mapped to strings are sent to the provider API.
+ */
+export interface ThinkingLevelMap {
+  off?: string | null;
+  minimal?: string | null;
+  low?: string | null;
+  medium?: string | null;
+  high?: string | null;
+  xhigh?: string | null;
+}
+
 /**
  * Mapped Pi model configuration for provider registration
  */
@@ -48,6 +62,7 @@ export interface PiModelConfig {
   };
   contextWindow: number;
   maxTokens: number;
+  thinkingLevelMap?: ThinkingLevelMap;
 }
 
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@robhowley/pi-openrouter",
-  "version": "0.8.0",
+  "version": "0.8.2",
   "type": "module",
   "description": "Live OpenRouter spend/account TUI overlays, user-scoped model sync, and session tagging for Pi.",
   "license": "MIT",
@@ -40,10 +40,13 @@
     "@openrouter/sdk": "^0.12.21"
   },
   "peerDependencies": {
-    "@mariozechner/pi-ai": "*",
-    "@mariozechner/pi-coding-agent": "*"
+    "@earendil-works/pi-ai": "*",
+    "@earendil-works/pi-coding-agent": "*"
   },
   "devDependencies": {
+    "@earendil-works/pi-ai": "*",
+    "@earendil-works/pi-coding-agent": "*",
+    "@mariozechner/pi-coding-agent": "*",
     "@types/node": "^22.15.17"
   }
 }