@robhowley/pi-openrouter 0.8.1 → 0.8.3

package/extensions/openrouter/__tests__/fixtures.ts

@@ -132,3 +132,30 @@ export function createPiModelConfig(overrides?: Partial<PiModelConfig>): PiModel
     ...overrides,
   };
 }
+
+// =============================================================================
+// LocalUsageEvent Fixtures
+// =============================================================================
+
+import type { LocalUsageEvent } from '../types.js';
+
+/**
+ * Creates LocalUsageEvent objects for testing local usage aggregation.
+ * Use daysAgo=0 for today, daysAgo=3 for within 7d window, etc.
+ */
+export function createLocalEvents(
+  events: Array<{ daysAgo: number; cost: number; model?: string; provider?: string }>,
+): LocalUsageEvent[] {
+  return events.map((e, i) => ({
+    id: `local-${i}`,
+    sessionId: 'test-session',
+    generationId: `gen-${i}`,
+    completedAt: `${createTestDate(e.daysAgo)}T12:00:00.000Z`,
+    requests: 1,
+    model: e.model ?? 'gpt-4',
+    provider: e.provider ?? 'openai',
+    promptTokens: 100,
+    completionTokens: 50,
+    cost: e.cost,
+  }));
+}

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

@@ -1,7 +1,7 @@
 import { describe, it, expect } from 'vitest';
 import { aggregateUsage } from '../format.js';
 import { renderSpendSparkline } from '../chart.js';
-import { createTestDate, createActivityItem } from './fixtures.js';
+import { createTestDate, createActivityItem, createLocalEvents } from './fixtures.js';
 import type { ActivityItem } from '@openrouter/sdk/models/index.js';
 
 describe('aggregateUsage', () => {
@@ -224,6 +224,54 @@ describe('aggregateUsage', () => {
     expect(result.byProvider[0]?.tokens.output).toBe(80); // 50 + 30
     expect(result.byProvider[0]?.requests).toBe(8); // 5 + 3
   });
+
+  it.each([
+    {
+      name: 'local today included in 7d model stats',
+      api: { daysAgo: 3, cost: 5, model: 'gpt-4' },
+      local: { daysAgo: 0, cost: 2.5, model: 'gpt-4' },
+      expectSpend7d: 7.5,
+    },
+    {
+      name: 'local outside 7d window excluded from 7d stats',
+      api: { daysAgo: 3, cost: 5, model: 'gpt-4' },
+      local: { daysAgo: 10, cost: 100, model: 'gpt-4' },
+      expectSpend7d: 5,
+    },
+    {
+      name: 'different models tracked separately',
+      api: { daysAgo: 1, cost: 5, model: 'gpt-4' },
+      local: { daysAgo: 0, cost: 3, model: 'claude-3' },
+      expectSpend7d: null,
+      expectModels: [
+        { name: 'gpt-4', spend7d: 5 },
+        { name: 'claude-3', spend7d: 3 },
+      ],
+    },
+  ])('$name', ({ api, local, expectSpend7d, expectModels }) => {
+    const credits = { totalUsage: 1000, totalCredits: 2000 };
+
+    const result = aggregateUsage(
+      credits,
+      [
+        createActivityItem({
+          date: createTestDate(api.daysAgo),
+          usage: api.cost,
+          model: api.model,
+        }),
+      ],
+      Date.now(),
+      createLocalEvents([local]),
+    );
+
+    if (expectModels) {
+      for (const { name, spend7d } of expectModels) {
+        expect(result.topModels.find((m) => m.name === name)?.spend7d).toBe(spend7d);
+      }
+    } else {
+      expect(result.topModels[0]?.spend7d).toBe(expectSpend7d);
+    }
+  });
 });
 
 describe('renderSpendSparkline', () => {

package/extensions/openrouter/format.ts

@@ -25,13 +25,10 @@ export function aggregateUsage(
     return d.date >= utcISODate(startOfWeek);
   });
 
-  const todayData = analytics.filter((d) => {
-    // API dates are YYYY-MM-DD in UTC; compare by UTC date boundary
-    return d.date >= utcISODate(startOfDay);
-  });
-
   const weekFromAnalytics = sumSpend(weekData);
-  const todayFromAnalytics = sumSpend(todayData);
+  const todayFromAnalytics = analytics
+    .filter((d) => d.date >= utcISODate(startOfDay))
+    .reduce((sum, d) => sum + d.usage, 0);
   const month = credits.totalUsage;
 
   // Add local events to compute combined totals
@@ -65,8 +62,10 @@ export function aggregateUsage(
   const allData = [...analytics, ...localItems];
 
   // Build model stats for both 7d and 30d windows
-  // Use allData (combined API + local) for 30d, weekData (combined) for 7d
-  const modelStatsMap = buildModelStats(weekData, allData);
+  // Combine weekData with local events in the 7d window
+  const weekLocalItems = localItems.filter((e) => e.date >= utcISODate(startOfWeek));
+  const weekAllData = [...weekData, ...weekLocalItems];
+  const modelStatsMap = buildModelStats(weekAllData, allData);
   const topModels = Array.from(modelStatsMap.values())
     .sort((a, b) => b.spend30d - a.spend30d)
     .slice(0, 10);

package/extensions/openrouter/index.ts

@@ -100,7 +100,7 @@ export default async function (pi: ExtensionAPI) {
 
     if (cache?.models.length) {
       try {
-        const { configs } = mapOpenRouterModels(cache.models);
+        const { configs } = await mapOpenRouterModels(cache.models);
 
         // Register models directly with Pi's OpenRouter provider
         pi.registerProvider('openrouter', {

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

@@ -132,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];
@@ -172,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.1",
+  "version": "0.8.3",
   "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"
   }
 }