@robhowley/pi-openrouter 0.14.1 → 0.14.2

package/README.md

@@ -200,10 +200,10 @@ Some OpenRouter models don't have complete metadata in Pi's built-in registry or
 
 ```bash
 # Override thinking levels for DeepSeek V4 Pro
-/openrouter model-override-set deepseek/deepseek-v4-pro thinking.high=high thinking.xhigh=max
+/openrouter model-override-set deepseek/deepseek-v4-pro thinking.high=high thinking.max=max
 
 # Same thing with exact field names
-/openrouter model-override-set deepseek/deepseek-v4-pro thinkingLevelMap.high=high thinkingLevelMap.xhigh=max
+/openrouter model-override-set deepseek/deepseek-v4-pro thinkingLevelMap.high=high thinkingLevelMap.max=max
 
 # Override context window or max tokens
 /openrouter model-override-set custom/model contextWindow=128000 maxTokens=8192
@@ -211,7 +211,8 @@ Some OpenRouter models don't have complete metadata in Pi's built-in registry or
 
 **Scoped field names:**
 
-- `thinking.off`, `thinking.minimal`, `thinking.low`, `thinking.medium`, `thinking.high`, `thinking.xhigh` → map to `thinkingLevelMap.*`
+- `thinking.off`, `thinking.minimal`, `thinking.low`, `thinking.medium`, `thinking.high`, `thinking.xhigh`, `thinking.max` → map to `thinkingLevelMap.*`
+- `thinkingLevelMap.off`, `thinkingLevelMap.minimal`, `thinkingLevelMap.low`, `thinkingLevelMap.medium`, `thinkingLevelMap.high`, `thinkingLevelMap.xhigh`, `thinkingLevelMap.max` → map to `thinkingLevelMap.*`
 - `contextWindow` → `contextWindow` (number)
 - `maxTokens` → `maxTokens` (number)
 - `reasoning` → `reasoning` (boolean)

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

@@ -1,5 +1,6 @@
 import { describe, expect, it } from 'vitest';
 import type { Model as SDKModel } from '@openrouter/sdk/models/index.js';
+import { modelFromJSON } from '@openrouter/sdk/models/model.js';
 import type {
   CreateKeysData,
   GetCurrentKeyData,
@@ -33,6 +34,7 @@ function createSdkModel(overrides: Partial<SDKModel> = {}): SDKModel {
       completion: '0.0000015',
     },
     supportedParameters: [],
+    supportedVoices: null,
     topProvider: {
       isModerated: false,
     },
@@ -146,6 +148,37 @@ function createUpdateKeysData(overrides: Partial<UpdateKeysData> = {}): UpdateKe
   };
 }
 
+function createSdkModelJson(supportedEfforts?: ReadonlyArray<string | null> | null): string {
+  return JSON.stringify({
+    architecture: {
+      input_modalities: ['text'],
+      modality: 'text',
+      output_modalities: ['text'],
+    },
+    canonical_slug: 'test/model',
+    context_length: 128000,
+    created: 0,
+    default_parameters: null,
+    id: 'test/model',
+    links: { details: 'https://openrouter.ai/test/model' },
+    name: 'Test Model',
+    per_request_limits: null,
+    pricing: {
+      prompt: '0.0000005',
+      completion: '0.0000015',
+    },
+    reasoning: {
+      mandatory: false,
+      ...(supportedEfforts === undefined ? {} : { supported_efforts: supportedEfforts }),
+    },
+    supported_parameters: ['reasoning'],
+    supported_voices: null,
+    top_provider: {
+      is_moderated: false,
+    },
+  });
+}
+
 describe('sdkModelToOpenRouterModel', () => {
   it('normalizes SDK camelCase fields into canonical snake_case model shape', () => {
     const normalized = sdkModelToOpenRouterModel(
@@ -197,6 +230,43 @@ describe('sdkModelToOpenRouterModel', () => {
     });
   });
 
+  it('parses snake_case reasoning metadata through the SDK before normalizing it', () => {
+    const parsed = modelFromJSON(createSdkModelJson(['low', null, 'future-effort']));
+
+    expect(parsed.ok).toBe(true);
+    if (!parsed.ok) return;
+
+    const normalized = sdkModelToOpenRouterModel(parsed.value);
+    expect(normalized.reasoning).toEqual({
+      mandatory: false,
+      supported_efforts: ['low', null, 'future-effort'],
+    });
+  });
+
+  it.each([
+    ['omitted', undefined],
+    ['null', null],
+    ['empty', []],
+    ['nullable element', [null]],
+    ['unknown string', ['future-effort']],
+    ['mixed values', ['low', null, 'future-effort']],
+  ] as const)('preserves %s supported_efforts during SDK normalization', (_name, efforts) => {
+    const parsed = modelFromJSON(createSdkModelJson(efforts));
+
+    expect(parsed.ok).toBe(true);
+    if (!parsed.ok) return;
+
+    const normalized = sdkModelToOpenRouterModel(parsed.value);
+    if (efforts === undefined) {
+      expect(normalized.reasoning).toEqual({ mandatory: false });
+    } else {
+      expect(normalized.reasoning).toEqual({
+        mandatory: false,
+        supported_efforts: efforts,
+      });
+    }
+  });
+
   it('omits optional provider/request blocks when the SDK omits them', () => {
     const normalized = sdkModelToOpenRouterModel(
       createSdkModel({

package/extensions/openrouter/models/__tests__/cache.test.ts

@@ -45,15 +45,26 @@ describe('loadCache', () => {
   });
 
   it('should return parsed cache when file exists and is valid', async () => {
-    const mockCache = createMockCache({ catalogMode: 'free-only', timestamp: 1234567890 });
+    const mockCache = createMockCache({
+      catalogMode: 'free-only',
+      timestamp: 1234567890,
+      models: [
+        {
+          ...createMockCache().models[0]!,
+          reasoning: {
+            mandatory: false,
+            supported_efforts: ['low', null, 'future-effort'],
+          },
+        },
+      ],
+    });
     await saveCache(mockCache);
 
     const result = await loadCache();
     expect(result).not.toBeNull();
     expect(result!.catalogMode).toBe('free-only');
     expect(result!.timestamp).toBe(1234567890);
-    expect(result!.models).toHaveLength(1);
-    expect(result!.models[0]!.id).toBe('test/model');
+    expect(result!.models).toEqual(mockCache.models);
   });
 
   it('should return null when cache file contains invalid JSON', async () => {

package/extensions/openrouter/models/__tests__/mapper-overrides.test.ts

@@ -12,14 +12,15 @@ vi.mock('../overrides.js', () => ({
     overrides.overrides[modelId],
 }));
 
-vi.mock('@earendil-works/pi-ai', () => ({
-  getModels: vi.fn(() => [
+vi.mock('@earendil-works/pi-ai/providers/all', () => ({
+  getBuiltinModels: vi.fn(() => [
     {
       id: 'test/model',
       thinkingLevelMap: {
         minimal: 'builtin-minimal',
         high: 'builtin-high',
         xhigh: 'builtin-xhigh',
+        max: 'builtin-max',
       },
     },
   ]),
@@ -43,6 +44,7 @@ describe('mapOpenRouterModels overrides', () => {
           thinkingLevelMap: {
             high: 'override-high',
             xhigh: null,
+            max: null,
           },
         },
       },
@@ -52,6 +54,10 @@ describe('mapOpenRouterModels overrides', () => {
       createValidModel({
         id: 'test/model',
         supported_parameters: ['reasoning'],
+        reasoning: {
+          mandatory: false,
+          supported_efforts: ['minimal', 'low', 'medium', 'high', 'xhigh', 'max'],
+        },
       }),
     ]);
 
@@ -61,21 +67,163 @@ describe('mapOpenRouterModels overrides', () => {
       contextWindow: 64000,
       maxTokens: 8192,
       reasoning: false,
+    });
+    expect(result.configs[0]?.thinkingLevelMap).toEqual({
+      minimal: 'builtin-minimal',
+      high: 'override-high',
+      xhigh: null,
+      max: null,
+    });
+  });
+
+  it('derives the exact GLM 5.3 effort map from API metadata', async () => {
+    const result = await mapOpenRouterModels([
+      createValidModel({
+        id: 'z-ai/glm-5.3',
+        reasoning: { mandatory: true, supported_efforts: ['low', 'high', 'max'] },
+      }),
+    ]);
+
+    expect(result.configs[0]?.thinkingLevelMap).toEqual({
+      off: null,
+      minimal: null,
+      low: 'low',
+      medium: null,
+      high: 'high',
+      xhigh: null,
+      max: 'max',
+    });
+  });
+
+  it('derives an API map when an unrelated user override is present', async () => {
+    loadModelOverrides.mockResolvedValue({
+      version: 1,
+      overrides: {
+        'api/model': { contextWindow: 64000 },
+      },
+    });
+
+    const result = await mapOpenRouterModels([
+      createValidModel({
+        id: 'api/model',
+        reasoning: {
+          mandatory: false,
+          supported_efforts: ['low', null, 'future-effort', 'max', 'none'],
+        },
+      }),
+    ]);
+
+    expect(result.configs[0]).toMatchObject({
+      reasoning: true,
+      contextWindow: 64000,
       thinkingLevelMap: {
-        minimal: 'builtin-minimal',
-        high: 'override-high',
+        off: 'none',
+        minimal: null,
+        low: 'low',
+        medium: null,
+        high: null,
         xhigh: null,
+        max: 'max',
       },
     });
   });
 
-  it('applies user thinkingLevelMap when the built-in registry has no map for the model', async () => {
+  it.each([
+    [true, null],
+    [false, 'none'],
+  ] as const)('maps mandatory=%s to off=%s for API maps', async (mandatory, off) => {
+    const result = await mapOpenRouterModels([
+      createValidModel({
+        id: `api/mandatory-${mandatory}`,
+        reasoning: { mandatory, supported_efforts: ['high'] },
+      }),
+    ]);
+
+    expect(result.configs[0]?.thinkingLevelMap).toEqual({
+      off,
+      minimal: null,
+      low: null,
+      medium: null,
+      high: 'high',
+      xhigh: null,
+      max: null,
+    });
+  });
+
+  it.each([
+    [true, null],
+    [false, 'none'],
+  ] as const)('maps explicit null supported_efforts with mandatory=%s', async (mandatory, off) => {
+    const result = await mapOpenRouterModels([
+      createValidModel({
+        id: `api/unrestricted-${mandatory}`,
+        reasoning: { mandatory, supported_efforts: null },
+      }),
+    ]);
+
+    expect(result.configs[0]?.thinkingLevelMap).toEqual({
+      off,
+      minimal: 'minimal',
+      low: 'low',
+      medium: 'medium',
+      high: 'high',
+      xhigh: 'xhigh',
+      max: 'max',
+    });
+  });
+
+  it('does not derive an API map from absent or unusable effort metadata', async () => {
+    const cases: Array<Array<string | null> | undefined> = [
+      undefined,
+      [],
+      [null],
+      ['none'],
+      ['future-effort'],
+    ];
+
+    for (const [index, supported_efforts] of cases.entries()) {
+      const reasoning =
+        supported_efforts === undefined
+          ? { mandatory: false }
+          : { mandatory: false, supported_efforts };
+      const result = await mapOpenRouterModels([
+        createValidModel({ id: `api/unusable-${index}`, reasoning }),
+      ]);
+
+      expect(result.configs[0]?.thinkingLevelMap).toBeUndefined();
+    }
+  });
+
+  it('hides off for mandatory reasoning metadata with no usable effort', async () => {
+    const result = await mapOpenRouterModels([
+      createValidModel({
+        id: 'api/mandatory-unknown-effort',
+        reasoning: { mandatory: true, supported_efforts: [null, 'none', 'future-effort'] },
+      }),
+    ]);
+
+    expect(result.configs[0]?.thinkingLevelMap).toEqual({ off: null });
+  });
+
+  it('does not derive an API map from supported_parameters alone', async () => {
+    const result = await mapOpenRouterModels([
+      createValidModel({
+        id: 'api/parameter-only',
+        supported_parameters: ['reasoning'],
+      }),
+    ]);
+
+    expect(result.configs[0]?.reasoning).toBe(true);
+    expect(result.configs[0]?.thinkingLevelMap).toBeUndefined();
+  });
+
+  it('merges sparse user thinkingLevelMap over the API map', async () => {
     loadModelOverrides.mockResolvedValue({
       version: 1,
       overrides: {
         'new/model': {
           thinkingLevelMap: {
-            high: 'high',
+            high: 'override-high',
             xhigh: 'max',
           },
         },
@@ -86,6 +234,7 @@ describe('mapOpenRouterModels overrides', () => {
       createValidModel({
         id: 'new/model',
         supported_parameters: ['reasoning'],
+        reasoning: { mandatory: true, supported_efforts: ['low', 'high', 'max'] },
       }),
     ]);
 
@@ -93,10 +242,15 @@ describe('mapOpenRouterModels overrides', () => {
     expect(result.configs[0]).toMatchObject({
       id: 'new/model',
       reasoning: true,
-      thinkingLevelMap: {
-        high: 'high',
-        xhigh: 'max',
-      },
+    });
+    expect(result.configs[0]?.thinkingLevelMap).toEqual({
+      off: null,
+      minimal: null,
+      low: 'low',
+      medium: null,
+      high: 'override-high',
+      xhigh: 'max',
+      max: 'max',
     });
   });
 });

package/extensions/openrouter/models/__tests__/override-commands.test.ts

@@ -111,6 +111,11 @@ describe('parseScopedAssignment', () => {
         fullPath: 'thinkingLevelMap.xhigh',
         value: 'max',
       });
+      expect(parseScopedAssignment('thinkingLevelMap.max=max')).toEqual({
+        ok: true,
+        fullPath: 'thinkingLevelMap.max',
+        value: 'max',
+      });
     });
 
     it('parses null string values for thinking levels', () => {
@@ -247,6 +252,7 @@ describe('parseScopedAssignment', () => {
         ['thinking.high=high', 'high'],
         ['thinking.xhigh=max', 'max'],
         ['thinking.xhigh=xhigh', 'xhigh'],
+        ['thinking.max=max', 'max'],
       ];
 
       for (const [input, expectedValue] of validPairs) {
@@ -402,7 +408,7 @@ describe('handleModelOverrideSet', () => {
     const userOverrides = emptyOverrides();
 
     const result = await handleModelOverrideSet(
-      'test/model thinking.high=high thinking.xhigh=max thinking.off=null contextWindow=64000 maxTokens=8192 reasoning=true',
+      'test/model thinking.high=high thinking.xhigh=max thinking.max=max thinking.off=null contextWindow=64000 maxTokens=8192 reasoning=true',
       userOverrides,
     );
 
@@ -415,6 +421,7 @@ describe('handleModelOverrideSet', () => {
           thinkingLevelMap: {
             high: 'high',
             xhigh: 'max',
+            max: 'max',
             off: null,
           },
           contextWindow: 64000,
@@ -553,6 +560,8 @@ describe('handleModelOverrideList', () => {
 
     expect(result).toContain('Available override fields');
     expect(result).toContain('thinking.high');
+    expect(result).toContain('thinking.max');
+    expect(result).toContain('thinkingLevelMap.max');
     expect(result).toContain('contextWindow');
   });
 
@@ -578,7 +587,7 @@ describe('handleModelOverrideList', () => {
       version: 1,
       overrides: {
         'test/model': {
-          thinkingLevelMap: { high: 'high', xhigh: 'max', off: null },
+          thinkingLevelMap: { high: 'high', xhigh: 'max', max: 'max', off: null },
           contextWindow: 64000,
         },
       },
@@ -590,6 +599,7 @@ describe('handleModelOverrideList', () => {
     expect(result).toContain('thinkingLevelMap:');
     expect(result).toContain('high: high');
     expect(result).toContain('xhigh: max');
+    expect(result).toContain('max: max');
     expect(result).toContain('off: null');
     expect(result).toContain('contextWindow: 64000');
   });
@@ -625,6 +635,7 @@ describe('SCOPED_FIELD_MAP', () => {
       'thinking.medium',
       'thinking.high',
       'thinking.xhigh',
+      'thinking.max',
     ];
 
     for (const shorthand of expectedShorthands) {
@@ -642,6 +653,7 @@ describe('SCOPED_FIELD_MAP', () => {
       'thinkingLevelMap.medium',
       'thinkingLevelMap.high',
       'thinkingLevelMap.xhigh',
+      'thinkingLevelMap.max',
     ];
 
     for (const exact of expectedExact) {

package/extensions/openrouter/models/mapper.ts

@@ -23,11 +23,9 @@ async function loadBuiltInOpenRouterModels(): Promise<Map<string, PiModelConfig>
 
   try {
     // Import from pi-ai to get built-in model registry
-    const { getModels } = (await import('@earendil-works/pi-ai')) as {
-      getModels: (provider: string) => unknown[];
-    };
+    const { getBuiltinModels } = await import('@earendil-works/pi-ai/providers/all');
 
-    const openrouterModels = getModels('openrouter');
+    const openrouterModels = getBuiltinModels('openrouter');
     if (Array.isArray(openrouterModels)) {
       for (const model of openrouterModels) {
         // Extract thinkingLevelMap from built-in model if present
@@ -57,6 +55,40 @@ async function getBuiltInThinkingLevelMap(
 
 const COST_PER_MILLION = 1_000_000;
 const DEFAULT_MAX_TOKENS = 4096;
+const API_THINKING_LEVELS = ['minimal', 'low', 'medium', 'high', 'xhigh', 'max'] as const;
+type ApiThinkingLevel = (typeof API_THINKING_LEVELS)[number];
+
+function buildApiThinkingLevelMap(
+  reasoning: OpenRouterModel['reasoning'],
+): PiModelConfig['thinkingLevelMap'] {
+  if (reasoning === undefined) {
+    return undefined;
+  }
+
+  const supportedEfforts = new Set(
+    reasoning?.supported_efforts === null
+      ? API_THINKING_LEVELS
+      : (reasoning?.supported_efforts?.filter(
+          (effort): effort is ApiThinkingLevel =>
+            typeof effort === 'string' &&
+            (API_THINKING_LEVELS as readonly string[]).includes(effort),
+        ) ?? []),
+  );
+
+  if (supportedEfforts.size === 0) {
+    return reasoning.mandatory ? { off: null } : undefined;
+  }
+
+  return {
+    off: reasoning.mandatory ? null : 'none',
+    minimal: supportedEfforts.has('minimal') ? 'minimal' : null,
+    low: supportedEfforts.has('low') ? 'low' : null,
+    medium: supportedEfforts.has('medium') ? 'medium' : null,
+    high: supportedEfforts.has('high') ? 'high' : null,
+    xhigh: supportedEfforts.has('xhigh') ? 'xhigh' : null,
+    max: supportedEfforts.has('max') ? 'max' : null,
+  };
+}
 
 /**
  * Validation result for a model check.
@@ -123,7 +155,9 @@ async function buildPiConfig(
 ): Promise<PiModelConfig> {
   const supportedParams = model.supported_parameters ?? [];
   const hasReasoning =
-    supportedParams.includes('reasoning') || supportedParams.includes('include_reasoning');
+    model.reasoning !== undefined
+      ? true
+      : supportedParams.includes('reasoning') || supportedParams.includes('include_reasoning');
   const inputModalities = model.architecture?.input_modalities;
   const supportsImages = inputModalities?.includes('image') ?? false;
 
@@ -134,11 +168,13 @@ async function buildPiConfig(
 
   // Fetch user override for this model
   const userOverride = userOverrides ? getModelOverride(userOverrides, model.id) : undefined;
+  const apiThinkingLevelMap = buildApiThinkingLevelMap(model.reasoning);
 
+  const baseThinkingLevelMap = builtInThinkingLevelMap ?? apiThinkingLevelMap;
   const thinkingLevelMap =
-    builtInThinkingLevelMap !== undefined || userOverride?.thinkingLevelMap !== undefined
+    baseThinkingLevelMap !== undefined || userOverride?.thinkingLevelMap !== undefined
       ? {
-          ...builtInThinkingLevelMap,
+          ...baseThinkingLevelMap,
           ...userOverride?.thinkingLevelMap,
         }
       : undefined;

package/extensions/openrouter/models/override-commands.ts

@@ -50,6 +50,7 @@ export const SCOPED_FIELD_MAP: Record<string, ScopedField> = {
   'thinking.medium': { targetField: 'thinkingLevelMap.medium', targetType: 'string' },
   'thinking.high': { targetField: 'thinkingLevelMap.high', targetType: 'string' },
   'thinking.xhigh': { targetField: 'thinkingLevelMap.xhigh', targetType: 'string' },
+  'thinking.max': { targetField: 'thinkingLevelMap.max', targetType: 'string' },
 
   // exact field names (passthrough)
   'thinkingLevelMap.off': { targetField: 'thinkingLevelMap.off', targetType: 'string' },
@@ -58,6 +59,7 @@ export const SCOPED_FIELD_MAP: Record<string, ScopedField> = {
   'thinkingLevelMap.medium': { targetField: 'thinkingLevelMap.medium', targetType: 'string' },
   'thinkingLevelMap.high': { targetField: 'thinkingLevelMap.high', targetType: 'string' },
   'thinkingLevelMap.xhigh': { targetField: 'thinkingLevelMap.xhigh', targetType: 'string' },
+  'thinkingLevelMap.max': { targetField: 'thinkingLevelMap.max', targetType: 'string' },
 
   // top-level fields (future extensibility)
   contextWindow: { targetField: 'contextWindow', targetType: 'number' },

package/extensions/openrouter/models/types.ts

@@ -16,6 +16,10 @@ export interface OpenRouterModel {
     input_cache_write?: string;
   };
   supported_parameters?: string[];
+  reasoning?: {
+    mandatory: boolean;
+    supported_efforts?: Array<string | null> | null;
+  };
   top_provider?: {
     context_length?: number;
     max_completion_tokens?: number;
@@ -44,6 +48,7 @@ export interface ThinkingLevelMap {
   medium?: string | null;
   high?: string | null;
   xhigh?: string | null;
+  max?: string | null;
 }
 
 /**

package/extensions/openrouter/normalizers.ts

@@ -62,6 +62,16 @@ export function sdkModelToOpenRouterModel(model: SDKModel): OpenRouterModel {
     supported_parameters: model.supportedParameters,
   };
 
+  if (model.reasoning !== undefined) {
+    const reasoning: NonNullable<OpenRouterModel['reasoning']> = {
+      mandatory: model.reasoning.mandatory,
+    };
+    if (model.reasoning.supportedEfforts !== undefined) {
+      reasoning.supported_efforts = model.reasoning.supportedEfforts;
+    }
+    result.reasoning = reasoning;
+  }
+
   if (architecture) {
     result.architecture = architecture;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@robhowley/pi-openrouter",
-  "version": "0.14.1",
+  "version": "0.14.2",
   "type": "module",
   "description": "Live OpenRouter spend/account TUI overlays, user-scoped or free-only model sync, api key management, and session tagging for Pi.",
   "license": "MIT",
@@ -38,15 +38,15 @@
   },
   "dependencies": {
     "@mariozechner/pi-tui": "*",
-    "@openrouter/sdk": "^0.12.21"
+    "@openrouter/sdk": "^0.13.13"
   },
   "peerDependencies": {
-    "@earendil-works/pi-ai": "*",
-    "@earendil-works/pi-coding-agent": "*"
+    "@earendil-works/pi-ai": ">=0.84.4",
+    "@earendil-works/pi-coding-agent": ">=0.84.4"
   },
   "devDependencies": {
-    "@earendil-works/pi-ai": "*",
-    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-ai": "0.84.4",
+    "@earendil-works/pi-coding-agent": "0.84.4",
     "@mariozechner/pi-coding-agent": "*",
     "@types/node": "^22.15.17"
   }