@robhowley/pi-openrouter 0.7.0 → 0.7.1

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/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(() => {});

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.7.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",