@robhowley/pi-openrouter 0.8.2 → 0.9.0

package/README.md

@@ -1,6 +1,6 @@
 # pi-openrouter
 
-A [Pi](https://pi.dev/) extension for live OpenRouter visibility and environment sync: usage/account TUI overlays, automatic `session_id` tagging, and user-scoped model catalog sync.
+A [Pi](https://pi.dev/) extension for live OpenRouter visibility and environment sync: usage/account TUI overlays, automatic `session_id` tagging, user-scoped model catalog sync, and local model field overrides.
 
 ## Installation
 
@@ -28,6 +28,9 @@ export OPENROUTER_MANAGEMENT_KEY=sk-or-...
 /openrouter models-sync              # sync user-scoped OpenRouter models into Pi
 /openrouter models-status            # show model sync/cache status
 /openrouter models-status --skipped  # show skipped model reasons
+/openrouter model-override-set       # set local model field overrides
+/openrouter model-override-list      # list local model field overrides
+/openrouter model-override-clear     # clear local model field overrides
 ```
 
 ## Model catalog sync
@@ -64,6 +67,7 @@ Run '/openrouter models-sync' to register models
 Type `/openrouter usage` in Pi to open the usage overlay.
 
 The overlay shows:
+
 - **Month spend** vs cap with percentage
 - **7-day spend** with burn rate projection
 - **Today's spend** from live tracked turns while Activity API data catches up
@@ -107,6 +111,50 @@ View the OpenRouter session tag with:
 pi:[uuid]
 ```
 
+## Model field overrides
+
+Some OpenRouter models don't have complete metadata in Pi's built-in registry or the OpenRouter model catalog. You can manually configure supported `PiModelConfig` fields using scoped syntax:
+
+```bash
+# Override thinking levels for DeepSeek V4 Pro
+/openrouter model-override-set deepseek/deepseek-v4-pro thinking.high=high thinking.xhigh=max
+
+# Same thing with exact field names
+/openrouter model-override-set deepseek/deepseek-v4-pro thinkingLevelMap.high=high thinkingLevelMap.xhigh=max
+
+# Override context window or max tokens
+/openrouter model-override-set custom/model contextWindow=128000 maxTokens=8192
+```
+
+**Scoped field names:**
+
+- `thinking.off`, `thinking.minimal`, `thinking.low`, `thinking.medium`, `thinking.high`, `thinking.xhigh` → map to `thinkingLevelMap.*`
+- `contextWindow` → `contextWindow` (number)
+- `maxTokens` → `maxTokens` (number)
+- `reasoning` → `reasoning` (boolean)
+
+Use `null` to hide a level from Pi's UI:
+
+```bash
+/openrouter model-override-set deepseek/deepseek-v4-pro thinking.off=null
+```
+
+List your overrides:
+
+```bash
+/openrouter model-override-list                    # all models
+/openrouter model-override-list --fields           # available fields
+/openrouter model-override-list deepseek/deepseek-v4-pro  # specific model
+```
+
+Clear overrides:
+
+```bash
+/openrouter model-override-clear deepseek/deepseek-v4-pro
+```
+
+Overrides are stored in `~/.pi/openrouter/model-overrides.json` and merge on top of OpenRouter catalog data and Pi's built-in registry. Run `/openrouter models-sync` after changing overrides to apply them to the registered OpenRouter model list.
+
 ## License
 
 MIT

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/__tests__/index.test.ts

@@ -0,0 +1,414 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import type { ModelOverridesFile } from '../models/types.js';
+
+const { loadModelOverrides, saveModelOverrides } = vi.hoisted(() => ({
+  loadModelOverrides: vi.fn<() => Promise<ModelOverridesFile>>(),
+  saveModelOverrides: vi.fn(),
+}));
+
+vi.mock('../models/overrides.js', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('../models/overrides.js')>();
+  return {
+    ...actual,
+    loadModelOverrides,
+    saveModelOverrides,
+  };
+});
+
+import {
+  applyNestedValue,
+  handleModelOverrideClear,
+  handleModelOverrideList,
+  handleModelOverrideSet,
+  parseScopedAssignment,
+} from '../index.js';
+
+const emptyOverrides = (): ModelOverridesFile => ({ version: 1, overrides: {} });
+
+describe('parseScopedAssignment', () => {
+  it('parses thinking shorthand aliases', () => {
+    expect(parseScopedAssignment('thinking.high=high')).toEqual({
+      fullPath: 'thinkingLevelMap.high',
+      value: 'high',
+    });
+  });
+
+  it('parses exact thinkingLevelMap field names', () => {
+    expect(parseScopedAssignment('thinkingLevelMap.xhigh=max')).toEqual({
+      fullPath: 'thinkingLevelMap.xhigh',
+      value: 'max',
+    });
+  });
+
+  it('parses null string values for thinking levels', () => {
+    expect(parseScopedAssignment('thinking.off=null')).toEqual({
+      fullPath: 'thinkingLevelMap.off',
+      value: null,
+    });
+  });
+
+  it('parses numeric and boolean top-level fields', () => {
+    expect(parseScopedAssignment('contextWindow=64000')).toEqual({
+      fullPath: 'contextWindow',
+      value: 64000,
+    });
+    expect(parseScopedAssignment('maxTokens=8192')).toEqual({
+      fullPath: 'maxTokens',
+      value: 8192,
+    });
+    expect(parseScopedAssignment('reasoning=false')).toEqual({
+      fullPath: 'reasoning',
+      value: false,
+    });
+  });
+
+  it('rejects malformed or unsupported assignments', () => {
+    expect(parseScopedAssignment('thinking.high')).toBeNull();
+    expect(parseScopedAssignment('unknown.field=value')).toBeNull();
+    expect(parseScopedAssignment('contextWindow=large')).toBeNull();
+    expect(parseScopedAssignment('reasoning=yes')).toBeNull();
+  });
+});
+
+describe('applyNestedValue', () => {
+  it('applies nested and top-level values', () => {
+    const target: Record<string, unknown> = {};
+
+    applyNestedValue(target, 'thinkingLevelMap.high', 'high');
+    applyNestedValue(target, 'contextWindow', 64000);
+
+    expect(target).toEqual({
+      thinkingLevelMap: { high: 'high' },
+      contextWindow: 64000,
+    });
+  });
+
+  it('replaces non-object intermediate values with objects', () => {
+    const target: Record<string, unknown> = { thinkingLevelMap: 'bad' };
+
+    applyNestedValue(target, 'thinkingLevelMap.high', 'high');
+
+    expect(target).toEqual({ thinkingLevelMap: { high: 'high' } });
+  });
+});
+
+describe('handleModelOverrideSet', () => {
+  beforeEach(() => {
+    loadModelOverrides.mockReset();
+    saveModelOverrides.mockReset();
+    loadModelOverrides.mockResolvedValue(emptyOverrides());
+    saveModelOverrides.mockResolvedValue(undefined);
+  });
+
+  it('returns usage when no model id is provided', async () => {
+    const result = await handleModelOverrideSet('', emptyOverrides());
+
+    expect(result.success).toBe(false);
+    expect(result.message).toContain('Usage: /openrouter model-override-set');
+    expect(saveModelOverrides).not.toHaveBeenCalled();
+  });
+
+  it('rejects model IDs without provider/model format', async () => {
+    const result = await handleModelOverrideSet(
+      'not-a-model contextWindow=64000',
+      emptyOverrides(),
+    );
+
+    expect(result).toEqual({
+      success: false,
+      message:
+        'Invalid model ID format: "not-a-model"\nExpected format: provider/model (e.g., "deepseek/deepseek-v4-pro")',
+    });
+    expect(saveModelOverrides).not.toHaveBeenCalled();
+  });
+
+  it('rejects missing field assignments', async () => {
+    const result = await handleModelOverrideSet('test/model --dry-run', emptyOverrides());
+
+    expect(result.success).toBe(false);
+    expect(result.message).toContain('No field assignments provided');
+    expect(saveModelOverrides).not.toHaveBeenCalled();
+  });
+
+  it('rejects invalid assignments', async () => {
+    const result = await handleModelOverrideSet('test/model unknown=value', emptyOverrides());
+
+    expect(result.success).toBe(false);
+    expect(result.message).toContain('Invalid assignment: "unknown=value"');
+    expect(saveModelOverrides).not.toHaveBeenCalled();
+  });
+
+  it('does not create thinkingLevelMap for non-thinking overrides', async () => {
+    const userOverrides = emptyOverrides();
+
+    const result = await handleModelOverrideSet('test/model contextWindow=64000', userOverrides);
+
+    expect(result.success).toBe(true);
+    expect(saveModelOverrides).toHaveBeenCalledWith({
+      version: 1,
+      overrides: {
+        'test/model': {
+          contextWindow: 64000,
+        },
+      },
+    });
+  });
+
+  it('stores sparse thinking overrides without nulling unrelated levels', async () => {
+    const userOverrides = emptyOverrides();
+
+    const result = await handleModelOverrideSet('test/model thinking.high=high', userOverrides);
+
+    expect(result.success).toBe(true);
+    expect(saveModelOverrides).toHaveBeenCalledWith({
+      version: 1,
+      overrides: {
+        'test/model': {
+          thinkingLevelMap: {
+            high: 'high',
+          },
+        },
+      },
+    });
+  });
+
+  it('persists all supported field types in one command', async () => {
+    const userOverrides = emptyOverrides();
+
+    const result = await handleModelOverrideSet(
+      'test/model thinking.high=high thinking.xhigh=max thinking.off=null contextWindow=64000 maxTokens=8192 reasoning=true',
+      userOverrides,
+    );
+
+    expect(result).toMatchObject({ success: true, modelId: 'test/model' });
+    expect(result.message).toContain('Saved overrides for test/model');
+    expect(saveModelOverrides).toHaveBeenCalledWith({
+      version: 1,
+      overrides: {
+        'test/model': {
+          thinkingLevelMap: {
+            high: 'high',
+            xhigh: 'max',
+            off: null,
+          },
+          contextWindow: 64000,
+          maxTokens: 8192,
+          reasoning: true,
+        },
+      },
+    });
+  });
+
+  it('merges with existing overrides instead of replacing them', async () => {
+    const userOverrides: ModelOverridesFile = {
+      version: 1,
+      overrides: {
+        'test/model': {
+          thinkingLevelMap: { minimal: null, high: 'old-high' },
+          contextWindow: 128000,
+        },
+      },
+    };
+
+    const result = await handleModelOverrideSet(
+      'test/model thinking.high=high maxTokens=8192',
+      userOverrides,
+    );
+
+    expect(result.success).toBe(true);
+    expect(saveModelOverrides).toHaveBeenCalledWith({
+      version: 1,
+      overrides: {
+        'test/model': {
+          thinkingLevelMap: { minimal: null, high: 'high' },
+          contextWindow: 128000,
+          maxTokens: 8192,
+        },
+      },
+    });
+  });
+
+  it('returns a handler failure when saving overrides fails', async () => {
+    const userOverrides = emptyOverrides();
+    saveModelOverrides.mockRejectedValue(new Error('disk full'));
+
+    const result = await handleModelOverrideSet('test/model contextWindow=64000', userOverrides);
+
+    expect(result).toEqual({
+      success: false,
+      message: 'Failed to save overrides for test/model: disk full',
+    });
+  });
+});
+
+describe('handleModelOverrideClear', () => {
+  beforeEach(() => {
+    saveModelOverrides.mockReset();
+    saveModelOverrides.mockResolvedValue(undefined);
+  });
+
+  it('returns usage when no model id is provided', async () => {
+    const result = await handleModelOverrideClear('', emptyOverrides());
+
+    expect(result).toEqual({
+      success: false,
+      message: 'Usage: /openrouter model-override-clear <model-id>',
+    });
+    expect(saveModelOverrides).not.toHaveBeenCalled();
+  });
+
+  it('rejects model IDs without provider/model format', async () => {
+    const result = await handleModelOverrideClear('bad-model', emptyOverrides());
+
+    expect(result).toEqual({
+      success: false,
+      message: 'Invalid model ID format: "bad-model"\nExpected format: provider/model',
+    });
+    expect(saveModelOverrides).not.toHaveBeenCalled();
+  });
+
+  it('reports when the model has no overrides', async () => {
+    const result = await handleModelOverrideClear('test/model', emptyOverrides());
+
+    expect(result).toEqual({
+      success: false,
+      message: 'No overrides found for test/model',
+    });
+    expect(saveModelOverrides).not.toHaveBeenCalled();
+  });
+
+  it('removes an existing override and preserves other models', async () => {
+    const userOverrides: ModelOverridesFile = {
+      version: 1,
+      overrides: {
+        'test/model': { contextWindow: 64000 },
+        'other/model': { maxTokens: 8192 },
+      },
+    };
+
+    const result = await handleModelOverrideClear('test/model', userOverrides);
+
+    expect(result).toEqual({
+      success: true,
+      message: 'Cleared all overrides for test/model',
+      modelId: 'test/model',
+    });
+    expect(saveModelOverrides).toHaveBeenCalledWith({
+      version: 1,
+      overrides: {
+        'other/model': { maxTokens: 8192 },
+      },
+    });
+  });
+
+  it('returns a handler failure when clearing overrides fails', async () => {
+    const userOverrides: ModelOverridesFile = {
+      version: 1,
+      overrides: {
+        'test/model': {
+          contextWindow: 64000,
+        },
+      },
+    };
+    saveModelOverrides.mockRejectedValue(new Error('permission denied'));
+
+    const result = await handleModelOverrideClear('test/model', userOverrides);
+
+    expect(result).toEqual({
+      success: false,
+      message: 'Failed to clear overrides for test/model: permission denied',
+    });
+  });
+});
+
+describe('handleModelOverrideList', () => {
+  beforeEach(() => {
+    loadModelOverrides.mockReset();
+    loadModelOverrides.mockResolvedValue(emptyOverrides());
+  });
+
+  it('lists available fields', async () => {
+    const result = await handleModelOverrideList('--fields');
+
+    expect(result).toContain('Available override fields:');
+    expect(result).toContain('thinking.high: thinkingLevelMap.high (string)');
+    expect(result).toContain('contextWindow: contextWindow (number)');
+    expect(result).toContain('reasoning: reasoning (boolean)');
+  });
+
+  it('shows an empty state when no overrides exist', async () => {
+    const result = await handleModelOverrideList('');
+
+    expect(result).toBe(
+      'No model overrides configured.\nUse /openrouter model-override-set to add overrides.',
+    );
+  });
+
+  it('reports a missing specific model override', async () => {
+    loadModelOverrides.mockResolvedValue({
+      version: 1,
+      overrides: {
+        'other/model': { maxTokens: 8192 },
+      },
+    });
+
+    const result = await handleModelOverrideList('test/model');
+
+    expect(result).toBe('No overrides configured for test/model');
+  });
+
+  it('formats a specific model override with nested thinking values', async () => {
+    loadModelOverrides.mockResolvedValue({
+      version: 1,
+      overrides: {
+        'test/model': {
+          thinkingLevelMap: { off: null, high: 'high', xhigh: 'max' },
+          contextWindow: 64000,
+          maxTokens: 8192,
+          reasoning: true,
+        },
+      },
+    });
+
+    const result = await handleModelOverrideList('test/model');
+
+    expect(result).toBe(
+      [
+        'Overrides for test/model:',
+        '  thinkingLevelMap:',
+        '    off: null',
+        '    high: high',
+        '    xhigh: max',
+        '  contextWindow: 64000',
+        '  maxTokens: 8192',
+        '  reasoning: true',
+      ].join('\n'),
+    );
+  });
+
+  it('lists all override model IDs and summarizes non-null thinking values', async () => {
+    loadModelOverrides.mockResolvedValue({
+      version: 1,
+      overrides: {
+        'thinking/model': {
+          thinkingLevelMap: { off: null, high: 'high', xhigh: 'max' },
+        },
+        'top-level/model': {
+          contextWindow: 64000,
+        },
+      },
+    });
+
+    const result = await handleModelOverrideList('');
+
+    expect(result).toBe(
+      [
+        '2 model(s) with overrides:',
+        '  thinking/model [high=high,xhigh=max]',
+        '  top-level/model',
+        '',
+        'Use /openrouter model-override-list <model-id> for details',
+      ].join('\n'),
+    );
+  });
+});

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