@robhowley/pi-openrouter 0.8.3 → 0.9.1

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

@@ -0,0 +1,233 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { createSessionState } from '../session-state.js';
+import type { SessionState } from '../session-state.js';
+import { createSessionCtx, THROW_SESSION_ID } from './fixtures.js';
+
+describe('SessionState', () => {
+  describe('createSessionState', () => {
+    it('should create a new session state instance', () => {
+      const state = createSessionState();
+      expect(state).toBeDefined();
+      expect(typeof state.getCurrentSessionId).toBe('function');
+      expect(typeof state.reset).toBe('function');
+    });
+
+    it('should produce different instances with different initial IDs', () => {
+      const state1 = createSessionState();
+      const state2 = createSessionState();
+
+      const mockCtx = createSessionCtx('test-session-1');
+      const mockCtx2 = createSessionCtx('test-session-2');
+
+      const id1 = state1.getCurrentSessionId(mockCtx);
+      const id2 = state2.getCurrentSessionId(mockCtx2);
+
+      expect(id1).not.toBe(id2);
+      expect(id1).toBe('pi:test-session-1');
+      expect(id2).toBe('pi:test-session-2');
+    });
+  });
+
+  describe('getCurrentSessionId', () => {
+    let state: SessionState;
+
+    beforeEach(() => {
+      state = createSessionState();
+    });
+
+    it('should return the same ID on multiple calls within same session', () => {
+      const mockCtx = createSessionCtx('stable-session');
+
+      const id1 = state.getCurrentSessionId(mockCtx);
+      const id2 = state.getCurrentSessionId(mockCtx);
+      const id3 = state.getCurrentSessionId(mockCtx);
+
+      expect(id1).toBe(id2);
+      expect(id2).toBe(id3);
+      expect(id1).toBe('pi:stable-session');
+    });
+
+    it('should cache the session ID even if context changes', () => {
+      const mockCtx1 = createSessionCtx('session-1');
+      const mockCtx2 = createSessionCtx('session-2');
+
+      const id1 = state.getCurrentSessionId(mockCtx1);
+      // Second call with different context should return cached ID
+      const id2 = state.getCurrentSessionId(mockCtx2);
+
+      expect(id1).toBe(id2);
+      expect(id1).toBe('pi:session-1');
+    });
+
+    it.each([
+      ['empty string', ''],
+      ['throwing manager', THROW_SESSION_ID],
+    ])(
+      'should generate stable fallback UUID when sessionManager returns %s',
+      (_label, sessionIdOrMarker) => {
+        const mockCtx = createSessionCtx(sessionIdOrMarker);
+
+        const id1 = state.getCurrentSessionId(mockCtx);
+        const id2 = state.getCurrentSessionId(mockCtx);
+
+        expect(id1).toBe(id2);
+        expect(id1).toMatch(
+          /^pi:[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,
+        );
+      },
+    );
+
+    it('should format session ID with pi: prefix', () => {
+      const mockCtx = createSessionCtx('my-session');
+
+      const id = state.getCurrentSessionId(mockCtx);
+      expect(id).toBe('pi:my-session');
+    });
+
+    it('should not double-prefix if session ID already starts with pi:', () => {
+      const mockCtx = createSessionCtx('pi:already-prefixed');
+
+      const id = state.getCurrentSessionId(mockCtx);
+      expect(id).toBe('pi:already-prefixed');
+      expect(id).not.toMatch(/^pi:pi:/);
+    });
+  });
+
+  describe('reset', () => {
+    let state: SessionState;
+
+    beforeEach(() => {
+      state = createSessionState();
+    });
+
+    it('should clear cached session ID', () => {
+      const mockCtx1 = createSessionCtx('session-1');
+      const mockCtx2 = createSessionCtx('session-2');
+
+      const id1 = state.getCurrentSessionId(mockCtx1);
+      expect(id1).toBe('pi:session-1');
+
+      state.reset();
+
+      const id2 = state.getCurrentSessionId(mockCtx2);
+      expect(id2).toBe('pi:session-2');
+      expect(id2).not.toBe(id1);
+    });
+
+    it('should allow new fallback UUID after reset', () => {
+      const mockCtx = createSessionCtx('');
+
+      const id1 = state.getCurrentSessionId(mockCtx);
+      state.reset();
+      const id2 = state.getCurrentSessionId(mockCtx);
+
+      expect(id1).not.toBe(id2);
+      expect(id1).toMatch(/^pi:/);
+      expect(id2).toMatch(/^pi:/);
+    });
+  });
+
+  describe('peek', () => {
+    let state: SessionState;
+
+    beforeEach(() => {
+      state = createSessionState();
+    });
+
+    it('should return null before first call to getCurrentSessionId', () => {
+      expect(state.peek()).toBeNull();
+    });
+
+    it('should return cached session ID without initializing', () => {
+      const mockCtx = createSessionCtx('my-session');
+
+      state.getCurrentSessionId(mockCtx);
+      expect(state.peek()).toBe('pi:my-session');
+    });
+
+    it('should return null after reset', () => {
+      const mockCtx = createSessionCtx('my-session');
+
+      state.getCurrentSessionId(mockCtx);
+      expect(state.peek()).toBe('pi:my-session');
+
+      state.reset();
+      expect(state.peek()).toBeNull();
+    });
+  });
+
+  describe('startSession', () => {
+    let state: SessionState;
+
+    beforeEach(() => {
+      state = createSessionState();
+    });
+
+    it('should preserve cached ID when raw session ID is the same', () => {
+      const mockCtx = createSessionCtx('stable-session');
+
+      // Initialize with first call
+      const id1 = state.getCurrentSessionId(mockCtx);
+      expect(id1).toBe('pi:stable-session');
+
+      // Call startSession with same raw ID
+      state.startSession(mockCtx);
+
+      // Should preserve the same ID
+      const id2 = state.peek();
+      expect(id2).toBe('pi:stable-session');
+      expect(id2).toBe(id1);
+    });
+
+    it('should update ID when raw session ID changes', () => {
+      const mockCtx1 = createSessionCtx('session-1');
+      const mockCtx2 = createSessionCtx('session-2');
+
+      // Initialize with first session
+      const id1 = state.getCurrentSessionId(mockCtx1);
+      expect(id1).toBe('pi:session-1');
+
+      // Call startSession with different raw ID
+      state.startSession(mockCtx2);
+
+      // Should have new ID
+      const id2 = state.peek();
+      expect(id2).toBe('pi:session-2');
+      expect(id2).not.toBe(id1);
+    });
+
+    it.each([
+      ['empty string', ''],
+      ['throwing manager', THROW_SESSION_ID],
+    ])('should clear state when session manager returns %s', (_label, sessionIdOrMarker) => {
+      const mockCtx1 = createSessionCtx('my-session');
+      const mockCtx2 = createSessionCtx(sessionIdOrMarker);
+
+      // Initialize with valid session
+      state.getCurrentSessionId(mockCtx1);
+      expect(state.peek()).toBe('pi:my-session');
+
+      // Call startSession with fallback case
+      state.startSession(mockCtx2);
+
+      // Should have cleared state
+      expect(state.peek()).toBeNull();
+
+      // Next getCurrentSessionId should generate fresh fallback
+      const newId = state.getCurrentSessionId(mockCtx2);
+      expect(newId).toMatch(
+        /^pi:[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,
+      );
+    });
+
+    it('should create and cache ID when called before getCurrentSessionId', () => {
+      const mockCtx = createSessionCtx('my-session');
+
+      // Call startSession without prior getCurrentSessionId
+      state.startSession(mockCtx);
+
+      // Should have created a cached ID
+      expect(state.peek()).toBe('pi:my-session');
+    });
+  });
+});

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

@@ -33,110 +33,111 @@ describe('formatSessionId', () => {
 
 describe('isOpenRouterRequest', () => {
   // =============================================================================
-  // Parameterized Tests - All Detection Methods (single source of truth)
+  // Parameterized tests - detection signals (single source of truth)
   // =============================================================================
 
   const detectionCases: DetectionTestCase[] = [
-    // Method 1: Model string prefix
+    // Model prefix signal
     {
-      name: 'method1: openrouter/ prefix',
+      name: 'model prefix: openrouter/',
       event: { payload: { model: 'openrouter/anthropic/claude-3' } },
       ctx: {},
       expected: true,
       description: 'Model with openrouter/ prefix should be detected',
     },
     {
-      name: 'method1: no prefix - should fail',
+      name: 'model prefix: missing prefix',
       event: { payload: { model: 'anthropic/claude-3' } },
       ctx: {},
       expected: false,
-      description: 'Model without openrouter/ prefix should not be detected by method 1',
+      description:
+        'Model without openrouter/ prefix should not be detected by the model-prefix signal',
     },
     {
-      name: 'method1: similar but not prefix',
+      name: 'model prefix: 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
+    // Context baseUrl signal
     {
-      name: 'method2: baseUrl contains openrouter.ai',
+      name: 'context 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',
+      name: 'context baseUrl: 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',
+      name: 'context baseUrl: missing baseUrl',
       event: { payload: { model: 'claude-3' } },
       ctx: { model: {} },
       expected: false,
-      description: 'Missing baseUrl should not be detected by method 2',
+      description: 'Missing baseUrl should not be detected by the context baseUrl signal',
     },
     {
-      name: 'method2: no model in context',
+      name: 'context baseUrl: no model in context',
       event: { payload: { model: 'claude-3' } },
       ctx: {},
       expected: false,
-      description: 'Empty context should not crash method 2',
+      description: 'Empty context should not crash the context baseUrl signal',
     },
 
-    // Method 3: ZDR provider
+    // ZDR provider signal
     {
-      name: 'method3: ZDR provider flag',
+      name: 'zdr provider: flag set',
       event: { payload: { model: 'qwen/coder' }, provider: { zdr: true } },
       ctx: {},
       expected: true,
       description: 'Provider with zdr: true should be detected',
     },
     {
-      name: 'method3: non-ZDR provider',
+      name: 'zdr provider: flag not set',
       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',
+      name: 'zdr provider: no provider object',
       event: { payload: { model: 'qwen/coder' } },
       ctx: {},
       expected: false,
-      description: 'Missing provider should not be detected by method 3',
+      description: 'Missing provider should not be detected by the ZDR provider signal',
     },
 
-    // Method 4: URL check
+    // URL / endpoint signal
     {
-      name: 'method4: url contains openrouter.ai',
+      name: '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)',
+      name: 'endpoint: 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',
+      name: 'url: 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)',
+      name: 'url: contains openrouter.ai in path',
       event: {
         payload: { model: 'qwen/coder' },
         url: 'https://proxy.example.com/v1/openrouter.ai/endpoint',
@@ -146,58 +147,58 @@ describe('isOpenRouterRequest', () => {
       description: 'URL containing openrouter.ai anywhere in string should match',
     },
     {
-      name: 'method4: url without openrouter.ai string',
+      name: '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)
+    // Provider name signal (Pi coding agent uses "openrouter" provider)
     {
-      name: 'method5: provider as string "openrouter" at event level',
+      name: 'provider name: event-level string "openrouter"',
       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',
+      name: 'provider name: payload string "openrouter"',
       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"',
+      name: 'provider name: event-level object 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',
+      name: 'provider name: payload object name "openrouter"',
       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',
+      name: 'provider name: 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',
+      name: 'provider name: similar but not exact',
       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)',
+      name: 'url: contains openrouter.ai in path (duplicate coverage)',
       event: {
         payload: { model: 'qwen/coder' },
         url: 'https://proxy.example.com/v1/openrouter.ai/endpoint',
@@ -207,14 +208,14 @@ describe('isOpenRouterRequest', () => {
       description: 'URL containing openrouter.ai anywhere in string should match',
     },
     {
-      name: 'method4: url without openrouter.ai string',
+      name: 'url: without openrouter.ai string (duplicate coverage)',
       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
+    // Edge cases - missing all detection signals
     {
       name: 'edge: empty event',
       event: {},
@@ -279,9 +280,9 @@ describe('isOpenRouterRequest', () => {
       description: 'turn_end without URL/endpoint and without openrouter/ prefix would fail',
     },
 
-    // Multiple methods at once
+    // Multiple signals at once
     {
-      name: 'multi: all methods satisfied',
+      name: 'multi: all signals satisfied',
       event: {
         payload: { model: 'openrouter/anthropic/claude-3' },
         url: 'https://openrouter.ai/api/v1/chat',
@@ -289,34 +290,34 @@ describe('isOpenRouterRequest', () => {
       },
       ctx: { model: { baseUrl: 'https://openrouter.ai/api/v1' } },
       expected: true,
-      description: 'All detection methods satisfied should return true',
+      description: 'All detection signals satisfied should return true',
     },
     {
-      name: 'multi: only method 4 (url) satisfied',
+      name: 'multi: only url signal satisfied',
       event: {
         payload: { model: 'any-model-name' },
         url: 'https://openrouter.ai/api/v1',
       },
       ctx: {},
       expected: true,
-      description: 'Only URL method satisfied should be sufficient',
+      description: 'Only URL signal satisfied should be sufficient',
     },
     {
-      name: 'multi: only method 2 (baseUrl) satisfied',
+      name: 'multi: only context baseUrl signal satisfied',
       event: { payload: { model: 'any-model' } },
       ctx: { model: { baseUrl: 'https://openrouter.ai/api/v1' } },
       expected: true,
-      description: 'Only baseUrl method satisfied should be sufficient',
+      description: 'Only context baseUrl signal satisfied should be sufficient',
     },
     {
-      name: 'multi: only method 3 (zdr) satisfied',
+      name: 'multi: only ZDR provider signal satisfied',
       event: {
         payload: { model: 'any-model' },
         provider: { zdr: true },
       },
       ctx: {},
       expected: true,
-      description: 'Only ZDR method satisfied should be sufficient',
+      description: 'Only ZDR provider signal satisfied should be sufficient',
     },
 
     // Cache mismatch - model appears openrouter but URL doesn't (edge case)

package/extensions/openrouter/account-client.ts

@@ -3,6 +3,7 @@ import type { KeyInfo, KeyStatus } from './account-types.js';
 
 // Re-export error types from client.ts
 import { AuthError, ApiError } from './client.js';
+import { normalizeSdkKeyMetadata } from './normalizers.js';
 
 let client: OpenRouter | null = null;
 
@@ -33,8 +34,6 @@ export async function getAccountCredits(): Promise<number | null> {
 // Key Management API
 // =============================================================================
 
-import type { GetCurrentKeyData, ListData } from '@openrouter/sdk/models/operations/index.js';
-
 // Workspace ID for the default workspace (empty string) - used when workspaceId is not specified
 const DEFAULT_WORKSPACE_ID = '';
 
@@ -61,7 +60,9 @@ export async function getAllKeys(): Promise<KeyInfo[] | null> {
       const response = await client.apiKeys.list({ workspaceId, includeDisabled: true });
       const rawKeys = response.data;
 
-      const keys = rawKeys.map((raw) => rawToKeyInfo(raw, workspace.name));
+      const keys = rawKeys.map((raw) =>
+        keyMetadataToKeyInfo(normalizeSdkKeyMetadata(raw), workspace.name),
+      );
       allKeys.push(...keys);
     }
 
@@ -81,7 +82,7 @@ export async function getCurrentKey(): Promise<KeyInfo | null> {
   if (!client) return null;
   try {
     const response = await client.apiKeys.getCurrentKeyMetadata();
-    return rawToKeyInfo(response.data, 'Current Workspace');
+    return keyMetadataToKeyInfo(normalizeSdkKeyMetadata(response.data), 'Current Workspace');
   } catch (err) {
     throw mapSdkError(err);
   }
@@ -91,60 +92,11 @@ export async function getCurrentKey(): Promise<KeyInfo | null> {
 // Helper Functions
 // =============================================================================
 
-function rawToKeyInfo(raw: GetCurrentKeyData | ListData, workspaceName: string): KeyInfo {
-  const used = raw.usage ?? raw.usageMonthly ?? 0;
-
-  // limit is number | null in both GetCurrentKeyData and ListData
-  const limitValue = raw.limit;
-
-  // remaining is number | null in both types
-  const remainingValue = raw.limitRemaining;
-
-  // Determine BYOK status
-  let byok: 'incl' | 'excl' | '?' = '?';
-  if (raw.includeByokInLimit === true) {
-    byok = 'incl';
-  } else if (raw.includeByokInLimit === false) {
-    byok = 'excl';
-  }
-
-  // Determine reset cadence
-  let resetCadence: 'monthly' | 'daily' | 'never' | 'partial' = 'partial';
-  if (raw.limitReset) {
-    const reset = raw.limitReset.toLowerCase();
-    if (reset === 'monthly') {
-      resetCadence = 'monthly';
-    } else if (reset === 'daily') {
-      resetCadence = 'daily';
-    } else if (reset === 'never') {
-      resetCadence = 'never';
-    }
-  }
-
-  // Determine hash (ListData has hash, GetCurrentKeyData doesn't)
-  const hash = 'hash' in raw ? (raw as ListData).hash : 'unknown';
-
-  // Determine name (ListData has name, GetCurrentKeyData doesn't - use label as fallback)
-  const name = 'name' in raw ? (raw as ListData).name : raw.label;
-
-  // Get disabled status (ListData has it, GetCurrentKeyData doesn't)
-  const disabled = 'disabled' in raw ? (raw as ListData).disabled : false;
-
-  // For exactOptionalPropertyTypes, we need to handle optional properties carefully
-  // The SDK returns number | null but KeyInfo expects number | undefined (or just number)
-  // We use type assertion to tell TypeScript that limit/remaining are either number or not set
-
-  // When limitValue is null, we set limit to undefined (or omit it)
-  // When limitValue is a number, we keep it as is
-  let limit: number | undefined;
-  if (limitValue !== null) {
-    limit = limitValue;
-  }
-
-  let remaining: number | undefined;
-  if (remainingValue !== null) {
-    remaining = remainingValue;
-  }
+function keyMetadataToKeyInfo(
+  metadata: ReturnType<typeof normalizeSdkKeyMetadata>,
+  workspaceName: string,
+): KeyInfo {
+  const { name, label, used, limit, remaining, resetCadence, byok, hash, disabled } = metadata;
 
   // Calculate status based on usage percentage
   let status: KeyStatus;
@@ -167,10 +119,9 @@ function rawToKeyInfo(raw: GetCurrentKeyData | ListData, workspaceName: string):
     }
   }
 
-  // Create the object
   const keyInfo: KeyInfo = {
     name,
-    label: raw.label,
+    label,
     status,
     used,
     spend: used, // spend is the same as usage (in USD)
@@ -181,7 +132,6 @@ function rawToKeyInfo(raw: GetCurrentKeyData | ListData, workspaceName: string):
     workspaceName,
   };
 
-  // Set optional properties explicitly
   if (limit !== undefined) {
     keyInfo.limit = limit;
   }