@robhowley/pi-openrouter 0.6.0 → 0.7.1

package/README.md

@@ -21,7 +21,7 @@ export OPENROUTER_MANAGEMENT_KEY=sk-or-...
 
 ## Usage
 
-Type `/openrouter-usage` in Pi to open the usage overlay.
+Type `/openrouter usage` in Pi to open the usage overlay.
 
 The overlay shows:
 - **Month spend** vs cap with percentage
@@ -37,7 +37,7 @@ The extension refreshes data in the background every 30 seconds (with exponentia
 
 ## Account health
 
-Type `/openrouter-account` in Pi to open the account health overlay.
+Type `/openrouter account` in Pi to open the account health overlay.
 
 The overlay shows:
 
@@ -56,25 +56,17 @@ Select a key from the list to inspect its limit, usage, reset cadence, and BYOK
 
 ## Session tracking
 
-`pi-openrouter` automatically tags OpenRouter requests with `session_id` field set to the Pi session's ID.
+`pi-openrouter` automatically tags OpenRouter requests with a `session_id` derived from the Pi session ID.
 
-View the Pi session ID with
+View the OpenRouter session tag with:
 
 ```bash
-/session  # [uuid]
-```
-
-The session can be tracked in OpenRouter's logs under the following ID:
-
-```bash
-/openrouter-session
+/openrouter session
 
 # OpenRouter session_id
 pi:[uuid]
 ```
 
-This enables session-level tracking in the OpenRouter Logs → Sessions page.
-
 ## License
 
 MIT

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

@@ -43,8 +43,10 @@ describe('aggregateUsage', () => {
       totalCredits: 100,
     };
     // Use a date that's within the last 7 days of when the test runs.
-    // We use a date from the past month that's been long enough to survive timezone offsets.
-    const date = '2026-05-01';
+    // Get today's date in UTC and subtract a few days to ensure it's in the week window.
+    const now = new Date();
+    const testDate = new Date(now.getTime() - 3 * 24 * 60 * 60 * 1000); // 3 days ago
+    const date = `${testDate.getUTCFullYear()}-${String(testDate.getUTCMonth() + 1).padStart(2, '0')}-${String(testDate.getUTCDate()).padStart(2, '0')}`;
     const analytics: ActivityItem[] = [
       {
         date: date,
@@ -77,9 +79,9 @@ describe('aggregateUsage', () => {
     const result = aggregateUsage(credits, analytics);
 
     expect(result.month).toBe(38.42);
-    // Data from May 1 should be in the week (but may not be in "today" depending on timezone)
+    // Data from the test date should be in the week (7 days ago window)
     expect(result.week).toBeGreaterThan(0);
-    // Today's data might not be from May 1 due to timezone, so just check month
+    // Today's data might not be from the test date due to timezone, so just check month
   });
 
   it('should calculate burn rate correctly', () => {

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

@@ -1,6 +1,18 @@
 import { describe, it, expect } from 'vitest';
 import { isOpenRouterRequest, formatSessionId } from '../session.js';
 
+// =============================================================================
+// Parameterized Test Types
+// =============================================================================
+
+interface DetectionTestCase {
+  name: string;
+  event: Record<string, unknown>;
+  ctx?: Record<string, unknown>;
+  expected: boolean;
+  description: string;
+}
+
 // =============================================================================
 // Session ID Formatting Tests
 // =============================================================================
@@ -68,7 +80,8 @@ describe('isOpenRouterRequest', () => {
   });
 
   it('does not detect non-ZDR provider', () => {
-    const event = createEvent({ model: 'qwen/qwen3-coder-next', provider: 'openrouter' });
+    // Use provider name that won't match Method 5 (not "openrouter")
+    const event = createEvent({ model: 'qwen/qwen3-coder-next', provider: 'anthropic' });
     expect(isOpenRouterRequest(event, {})).toBe(false);
   });
 
@@ -98,4 +111,311 @@ describe('isOpenRouterRequest', () => {
     const ctx = createContext({ baseUrl: 'https://openrouter.ai/api/v1' });
     expect(isOpenRouterRequest(event, ctx)).toBe(true);
   });
+
+  // =============================================================================
+  // Parameterized Tests - All Detection Methods
+  // =============================================================================
+
+  const detectionCases: DetectionTestCase[] = [
+    // Method 1: Model string prefix
+    {
+      name: 'method1: openrouter/ prefix',
+      event: { payload: { model: 'openrouter/anthropic/claude-3' } },
+      ctx: {},
+      expected: true,
+      description: 'Model with openrouter/ prefix should be detected',
+    },
+    {
+      name: 'method1: no prefix - should fail',
+      event: { payload: { model: 'anthropic/claude-3' } },
+      ctx: {},
+      expected: false,
+      description: 'Model without openrouter/ prefix should not be detected by method 1',
+    },
+    {
+      name: 'method1: similar but not prefix',
+      event: { payload: { model: 'my-openrouter-model' } },
+      ctx: {},
+      expected: false,
+      description: 'Model containing openrouter but not as prefix should not match',
+    },
+
+    // Method 2: baseUrl in context.model
+    {
+      name: 'method2: baseUrl contains openrouter.ai',
+      event: { payload: { model: 'qwen/coder' } },
+      ctx: { model: { baseUrl: 'https://openrouter.ai/api/v1' } },
+      expected: true,
+      description: 'Context with openrouter.ai baseUrl should be detected',
+    },
+    {
+      name: 'method2: different baseUrl',
+      event: { payload: { model: 'claude-3' } },
+      ctx: { model: { baseUrl: 'https://api.anthropic.com' } },
+      expected: false,
+      description: 'Non-OpenRouter baseUrl should not be detected',
+    },
+    {
+      name: 'method2: missing baseUrl',
+      event: { payload: { model: 'claude-3' } },
+      ctx: { model: {} },
+      expected: false,
+      description: 'Missing baseUrl should not be detected by method 2',
+    },
+    {
+      name: 'method2: no model in context',
+      event: { payload: { model: 'claude-3' } },
+      ctx: {},
+      expected: false,
+      description: 'Empty context should not crash method 2',
+    },
+
+    // Method 3: ZDR provider
+    {
+      name: 'method3: ZDR provider flag',
+      event: { payload: { model: 'qwen/coder' }, provider: { zdr: true } },
+      ctx: {},
+      expected: true,
+      description: 'Provider with zdr: true should be detected',
+    },
+    {
+      name: 'method3: non-ZDR provider',
+      event: { payload: { model: 'qwen/coder' }, provider: { zdr: false } },
+      ctx: {},
+      expected: false,
+      description: 'Provider with zdr: false should not be detected',
+    },
+    {
+      name: 'method3: no provider object',
+      event: { payload: { model: 'qwen/coder' } },
+      ctx: {},
+      expected: false,
+      description: 'Missing provider should not be detected by method 3',
+    },
+
+    // Method 4: URL check
+    {
+      name: 'method4: url contains openrouter.ai',
+      event: { payload: { model: 'qwen/coder' }, url: 'https://openrouter.ai/api/v1/chat' },
+      ctx: {},
+      expected: true,
+      description: 'URL containing openrouter.ai should be detected',
+    },
+    {
+      name: 'method4: endpoint property (alternative to url)',
+      event: { payload: { model: 'qwen/coder' }, endpoint: 'https://openrouter.ai/api/v1/chat' },
+      ctx: {},
+      expected: true,
+      description: 'Endpoint property should also be checked (fallback to url)',
+    },
+    {
+      name: 'method4: non-OpenRouter url',
+      event: { payload: { model: 'qwen/coder' }, url: 'https://api.anthropic.com/v1/messages' },
+      ctx: {},
+      expected: false,
+      description: 'Non-OpenRouter URL should not be detected',
+    },
+    {
+      name: 'method4: url with openrouter.ai in path (not just domain)',
+      event: {
+        payload: { model: 'qwen/coder' },
+        url: 'https://proxy.example.com/v1/openrouter.ai/endpoint',
+      },
+      ctx: {},
+      expected: true,
+      description: 'URL containing openrouter.ai anywhere in string should match',
+    },
+    {
+      name: 'method4: url without openrouter.ai string',
+      event: { payload: { model: 'qwen/coder' }, url: 'https://example.com/api' },
+      ctx: {},
+      expected: false,
+      description: 'URL without openrouter.ai should not be detected',
+    },
+
+    // Method 5: Provider name check (Pi coding agent uses "openrouter" provider)
+    {
+      name: 'method5: provider as string "openrouter" at event level',
+      event: { payload: { model: 'claude-3' }, provider: 'openrouter' },
+      ctx: {},
+      expected: true,
+      description: 'Provider name "openrouter" as string should be detected',
+    },
+    {
+      name: 'method5: provider as string "openrouter" in payload',
+      event: { payload: { model: 'claude-3', provider: 'openrouter' } },
+      ctx: {},
+      expected: true,
+      description: 'Provider name "openrouter" in payload should be detected',
+    },
+    {
+      name: 'method5: provider object with name "openrouter"',
+      event: { payload: { model: 'claude-3' }, provider: { name: 'openrouter' } },
+      ctx: {},
+      expected: true,
+      description: 'Provider object with name "openrouter" should be detected',
+    },
+    {
+      name: 'method5: provider in payload with object name',
+      event: { payload: { model: 'claude-3', provider: { name: 'openrouter' } } },
+      ctx: {},
+      expected: true,
+      description: 'Provider object in payload with name "openrouter" should be detected',
+    },
+    {
+      name: 'method5: different provider name',
+      event: { payload: { model: 'claude-3', provider: 'anthropic' } },
+      ctx: {},
+      expected: false,
+      description: 'Different provider name should not be detected',
+    },
+    {
+      name: 'method5: similar but not exact provider name',
+      event: { payload: { model: 'claude-3', provider: 'openrouter-proxy' } },
+      ctx: {},
+      expected: false,
+      description: 'Provider name containing but not exactly "openrouter" should not match',
+    },
+    {
+      name: 'method4: url with openrouter.ai in path (not just domain)',
+      event: {
+        payload: { model: 'qwen/coder' },
+        url: 'https://proxy.example.com/v1/openrouter.ai/endpoint',
+      },
+      ctx: {},
+      expected: true,
+      description: 'URL containing openrouter.ai anywhere in string should match',
+    },
+    {
+      name: 'method4: url without openrouter.ai string',
+      event: { payload: { model: 'qwen/coder' }, url: 'https://example.com/api' },
+      ctx: {},
+      expected: false,
+      description: 'URL without openrouter.ai should not be detected',
+    },
+
+    // Edge cases - missing all detection methods
+    {
+      name: 'edge: empty event',
+      event: {},
+      ctx: {},
+      expected: false,
+      description: 'Empty event should not be detected',
+    },
+    {
+      name: 'edge: payload only with no model',
+      event: { payload: { messages: [] } },
+      ctx: {},
+      expected: false,
+      description: 'Event with payload but no model should not be detected',
+    },
+    {
+      name: 'edge: null model',
+      event: { payload: { model: null } },
+      ctx: {},
+      expected: false,
+      description: 'Null model should be handled as string "null" and not match',
+    },
+    {
+      name: 'edge: undefined model',
+      event: { payload: {} },
+      ctx: {},
+      expected: false,
+      description: 'Undefined model should not crash and not be detected',
+    },
+
+    // turn_end specific - simulating real turn_end event structure
+    {
+      name: 'turn_end style: url at event level with resolved model',
+      event: {
+        type: 'turn_end',
+        payload: { model: 'qwen/qwen3-coder-next', responseId: 'gen-123' },
+        url: 'https://openrouter.ai/api/v1/chat/completions',
+        message: { model: 'qwen/qwen3-coder-next', usage: {} },
+      },
+      ctx: {},
+      expected: true,
+      description: 'turn_end event structure with URL should be detected',
+    },
+    {
+      name: 'turn_end style: no url but endpoint',
+      event: {
+        type: 'turn_end',
+        payload: { model: 'moonshotai/kimi-k2.5' },
+        endpoint: 'https://openrouter.ai/api/v1/chat/completions',
+      },
+      ctx: {},
+      expected: true,
+      description: 'turn_end with endpoint instead of url should be detected',
+    },
+    {
+      name: 'turn_end style: no url or endpoint (would fail)',
+      event: {
+        type: 'turn_end',
+        payload: { model: 'moonshotai/kimi-k2.5' },
+      },
+      ctx: {},
+      expected: false,
+      description: 'turn_end without URL/endpoint and without openrouter/ prefix would fail',
+    },
+
+    // Multiple methods at once
+    {
+      name: 'multi: all methods satisfied',
+      event: {
+        payload: { model: 'openrouter/anthropic/claude-3' },
+        url: 'https://openrouter.ai/api/v1/chat',
+        provider: { zdr: true },
+      },
+      ctx: { model: { baseUrl: 'https://openrouter.ai/api/v1' } },
+      expected: true,
+      description: 'All detection methods satisfied should return true',
+    },
+    {
+      name: 'multi: only method 4 (url) satisfied',
+      event: {
+        payload: { model: 'any-model-name' },
+        url: 'https://openrouter.ai/api/v1',
+      },
+      ctx: {},
+      expected: true,
+      description: 'Only URL method satisfied should be sufficient',
+    },
+    {
+      name: 'multi: only method 2 (baseUrl) satisfied',
+      event: { payload: { model: 'any-model' } },
+      ctx: { model: { baseUrl: 'https://openrouter.ai/api/v1' } },
+      expected: true,
+      description: 'Only baseUrl method satisfied should be sufficient',
+    },
+    {
+      name: 'multi: only method 3 (zdr) satisfied',
+      event: {
+        payload: { model: 'any-model' },
+        provider: { zdr: true },
+      },
+      ctx: {},
+      expected: true,
+      description: 'Only ZDR method satisfied should be sufficient',
+    },
+
+    // Cache mismatch - model appears openrouter but URL doesn't (edge case)
+    {
+      name: 'edge: model says openrouter but URL says different',
+      event: {
+        payload: { model: 'openrouter/anthropic/claude-3' },
+        url: 'https://api.anthropic.com/v1/messages',
+      },
+      expected: true,
+      description: 'Model prefix takes precedence - should still detect as OpenRouter',
+    },
+  ];
+
+  // Run all parameterized tests
+  for (const testCase of detectionCases) {
+    it(testCase.name, () => {
+      const result = isOpenRouterRequest(testCase.event as any, testCase.ctx as any);
+      expect(result).toBe(testCase.expected);
+    });
+  }
 });

package/extensions/openrouter/account-overlay.ts

@@ -173,15 +173,21 @@ export class AccountOverlayComponent {
     return Math.max(MIN_WIDTH, this.keyInfo && this.keyInfo.length > 0 ? 55 : 50);
   }
 
+  /** Get the header row for the account overlay */
+  private getAccountHeaderRow(): string {
+    return row(
+      this.theme.fg('accent', this.theme.bold(' ◈ OpenRouter Account  ·  /openrouter account')),
+      this.width,
+    );
+  }
+
   private buildLines(): string[] {
     const th = this.theme;
     const lines: string[] = [];
 
     if (this.error) {
       lines.push(boxTop(this.width));
-      lines.push(
-        row(th.fg('accent', th.bold(' ◈ OpenRouter Account  ·  /openrouter-account')), this.width),
-      );
+      lines.push(this.getAccountHeaderRow());
       lines.push(emptyRow(this.width));
       lines.push(row(th.fg('error', this.error), this.width));
       lines.push(boxBottom(this.width));
@@ -190,9 +196,7 @@ export class AccountOverlayComponent {
     }
 
     lines.push(boxTop(this.width));
-    lines.push(
-      row(th.fg('accent', th.bold(' ◈ OpenRouter Account  ·  /openrouter-account')), this.width),
-    );
+    lines.push(this.getAccountHeaderRow());
     lines.push(emptyRow(this.width));
 
     // Total spend line (sum of all key spends)

package/extensions/openrouter/index.ts

@@ -95,10 +95,14 @@ export default function (pi: ExtensionAPI) {
       if (!message) return;
 
       // Check if this is an OpenRouter request based on the message content/model
+      // Include url/endpoint from turnEvent so isOpenRouterRequest can check them
       const isOpenRouter = isOpenRouterRequest(
-        { type: 'before_provider_request', payload: message } as unknown as Parameters<
-          typeof isOpenRouterRequest
-        >[0],
+        {
+          type: 'before_provider_request',
+          payload: message,
+          url: turnEvent['url'],
+          endpoint: turnEvent['endpoint'],
+        } as unknown as Parameters<typeof isOpenRouterRequest>[0],
         ctx,
       );
       if (!isOpenRouter) return;
@@ -130,18 +134,20 @@ export default function (pi: ExtensionAPI) {
       // Calculate total cost from usage.cost.total
       const totalCost = usage.cost?.total;
 
-      const localEvent = {
+      const localEvent: LocalUsageEvent = {
         id: crypto.randomUUID(),
-        generationId: message['responseId'],
+        generationId: String(message['responseId'] ?? ''),
         sessionId: getCurrentSessionId(ctx),
         completedAt: new Date().toISOString(),
-        model: modelToLog,
-        promptTokens: usage.input,
-        completionTokens: usage.output,
-        cacheReadTokens: usage.cacheRead,
-        cacheWriteTokens: usage.cacheWrite,
-        cost: totalCost,
-      } as LocalUsageEvent;
+        model: modelToLog ?? 'unknown',
+        requests: 1,
+        promptTokens: usage.input ?? 0,
+        completionTokens: usage.output ?? 0,
+        reasoningTokens: 0,
+        cacheReadTokens: usage.cacheRead ?? 0,
+        cacheWriteTokens: usage.cacheWrite ?? 0,
+        cost: totalCost ?? 0,
+      };
 
       // Write to local JSONL - fail open (don't throw)
       writeLocalUsage(localEvent).catch(() => {});
@@ -180,6 +186,46 @@ export default function (pi: ExtensionAPI) {
       await showAccountOverlay(ctx);
     },
   });
+
+  // Single entry point with subcommands: /openrouter [usage|account|session]
+  pi.registerCommand('openrouter', {
+    description: 'OpenRouter commands: usage, account, session',
+    getArgumentCompletions: (prefix: string) => {
+      const subcommands = ['usage', 'account', 'session'];
+      const items = subcommands
+        .filter((s) => s.startsWith(prefix))
+        .map((s) => ({ value: s, label: s }));
+      return items.length > 0 ? items : null;
+    },
+    handler: async (args, ctx) => {
+      const subcommand = args.trim().split(/\s+/)[0] || '';
+
+      switch (subcommand) {
+        case 'usage': {
+          startBackgroundRefresh();
+          await showUsageOverlay(ctx, undefined);
+          break;
+        }
+        case 'account': {
+          await showAccountOverlay(ctx);
+          break;
+        }
+        case 'session': {
+          ctx.ui.notify(`OpenRouter session_id\n${getCurrentSessionId(ctx)}`, 'info');
+          break;
+        }
+        default: {
+          const available = ['usage', 'account', 'session'];
+          const message =
+            available.length > 0
+              ? `Available subcommands: ${available.join(', ')}${available.length > 1 ? '' : ''}`
+              : 'No subcommands available';
+          ctx.ui.notify(`OpenRouter subcommands\n${message}`, 'error');
+          break;
+        }
+      }
+    },
+  });
 }
 
 async function showAccountOverlay(ctx: ExtensionContext) {

package/extensions/openrouter/overlay.ts

@@ -118,6 +118,14 @@ export class UsageOverlayComponent {
     return Math.max(MIN_WIDTH, innerWidth + 4) + 6; // +4 for borders, +6 for visual padding (3 on each side)
   }
 
+  /** Get the header row for the usage overlay */
+  private getUsageHeaderRow(): string {
+    return row(
+      this.theme.fg('accent', this.theme.bold(' ◈ OpenRouter Usage  ·  /openrouter usage')),
+      this.width,
+    );
+  }
+
   private buildLines(
     summary: UsageSummary | null,
     error: string | null,
@@ -128,9 +136,7 @@ export class UsageOverlayComponent {
 
     if (error) {
       lines.push(boxTop(this.width));
-      lines.push(
-        row(th.fg('accent', th.bold(' ◈ OpenRouter Usage  ·  /openrouter-usage')), this.width),
-      );
+      lines.push(this.getUsageHeaderRow());
       lines.push(emptyRow(this.width));
       lines.push(row(th.fg('error', error), this.width));
       if (cachedMinutesAgo !== null) {
@@ -145,9 +151,7 @@ export class UsageOverlayComponent {
 
     if (!summary) {
       lines.push(boxTop(this.width));
-      lines.push(
-        row(th.fg('accent', th.bold(' ◈ OpenRouter Usage  ·  /openrouter-usage')), this.width),
-      );
+      lines.push(this.getUsageHeaderRow());
       lines.push(emptyRow(this.width));
       lines.push(row(th.fg('dim', 'No usage data available.'), this.width));
       lines.push(boxBottom(this.width));
@@ -157,9 +161,7 @@ export class UsageOverlayComponent {
 
     // Summary view (subcommand views TODO)
     lines.push(boxTop(this.width));
-    lines.push(
-      row(th.fg('accent', th.bold(' ◈ OpenRouter Usage  ·  /openrouter-usage')), this.width),
-    );
+    lines.push(this.getUsageHeaderRow());
     lines.push(emptyRow(this.width));
 
     // Month row: amount stays with label, cap percentage right-aligned

package/extensions/openrouter/session.ts

@@ -25,15 +25,30 @@ export function formatSessionId(sessionId: string): string {
 
 export function isOpenRouterRequest(event: BeforeProviderRequestEvent, _ctx: unknown): boolean {
   const ev = event as unknown as Record<string, unknown>;
-
-  // Method 1: Check model string (e.g., "openrouter/anthropic/claude-3.5-sonnet")
   const payload = ev['payload'] as Record<string, unknown> | undefined;
+
+  // Method 1: Check if provider is explicitly "openrouter" (Pi coding agent first-class)
+  // Provider could be in event.provider, event.payload.provider, as string or object with name
+  const eventProvider = ev['provider'];
+  const payloadProvider = payload?.['provider'];
+  const providerName =
+    typeof eventProvider === 'string'
+      ? eventProvider
+      : typeof payloadProvider === 'string'
+        ? payloadProvider
+        : ((eventProvider as Record<string, unknown> | undefined)?.['name'] ??
+          (payloadProvider as Record<string, unknown> | undefined)?.['name']);
+  if (providerName === 'openrouter') {
+    return true;
+  }
+
+  // Method 2: Check model string (e.g., "openrouter/anthropic/claude-3.5-sonnet")
   const model = String(payload?.['model'] ?? '');
   if (model.includes('openrouter/')) {
     return true;
   }
 
-  // Method 2: Check baseUrl from context.model
+  // Method 3: Check baseUrl from context.model
   // OpenRouter models have baseUrl starting with https://openrouter.ai/api/v1
   const context = _ctx as Record<string, unknown>;
   const ctxModel = context['model'] as Record<string, unknown> | undefined;
@@ -42,13 +57,13 @@ export function isOpenRouterRequest(event: BeforeProviderRequestEvent, _ctx: unk
     return true;
   }
 
-  // Method 3: Check for ZDR provider (Shopify routes to OpenRouter via ZDR)
+  // Method 4: Check for ZDR provider (Shopify routes to OpenRouter via ZDR)
   const provider = ev['provider'] as Record<string, unknown> | undefined;
   if (provider?.['zdr'] === true) {
     return true;
   }
 
-  // Method 4: Check URL
+  // Method 5: Check URL (fallback for events where provider info is missing)
   const url = String(
     (ev['url'] as string | undefined) ?? (ev['endpoint'] as string | undefined) ?? '',
   );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@robhowley/pi-openrouter",
-  "version": "0.6.0",
+  "version": "0.7.1",
   "type": "module",
   "description": "Live OpenRouter TUI overlays for spend, credits, key limits, burn rate, model usage, and session tagging.",
   "license": "MIT",
@@ -27,7 +27,7 @@
     "url": "https://github.com/robhowley/pi-userland.git",
     "directory": "packages/pi-openrouter"
   },
-  "homepage": "https://github.com/robhowley/pi-userland/tree/main/packages/pi-openrouter",
+  "homepage": "https://pi-userland.dev",
   "scripts": {
     "lint": "eslint extensions/",
     "format:check": "prettier --check extensions/",