@robhowley/pi-openrouter 0.9.0 → 0.10.0

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

@@ -0,0 +1,668 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import type { ModelOverridesFile } from '../types.js';
+
+const { loadModelOverrides, saveModelOverrides } = vi.hoisted(() => ({
+  loadModelOverrides: vi.fn<() => Promise<ModelOverridesFile>>(),
+  saveModelOverrides: vi.fn(),
+}));
+
+vi.mock('../overrides.js', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('../overrides.js')>();
+  return {
+    ...actual,
+    loadModelOverrides,
+    saveModelOverrides,
+  };
+});
+
+import {
+  applyNestedValue,
+  handleModelOverrideClear,
+  handleModelOverrideList,
+  handleModelOverrideSet,
+  parseScopedAssignment,
+  SCOPED_FIELD_MAP,
+  validateThinkingValue,
+} from '../override-commands.js';
+
+const emptyOverrides = (): ModelOverridesFile => ({ version: 1, overrides: {} });
+
+// =============================================================================
+// Validation Tests
+// =============================================================================
+
+describe('validateThinkingValue', () => {
+  it('accepts null (hide level signal)', () => {
+    expect(validateThinkingValue(null)).toEqual({ valid: true });
+  });
+
+  it('accepts documented thinking values', () => {
+    const validValues = ['off', 'minimal', 'low', 'medium', 'high', 'max', 'xhigh'];
+
+    for (const value of validValues) {
+      expect(validateThinkingValue(value)).toEqual({ valid: true });
+    }
+  });
+
+  it('rejects empty string', () => {
+    const result = validateThinkingValue('');
+    expect(result.valid).toBe(false);
+    expect(result.error).toContain('empty');
+  });
+
+  it('rejects whitespace-only values', () => {
+    const result = validateThinkingValue('   ');
+    expect(result.valid).toBe(false);
+    expect(result.error).toContain('whitespace');
+  });
+
+  it('rejects control characters', () => {
+    // Test null byte
+    const result1 = validateThinkingValue('high\x00');
+    expect(result1.valid).toBe(false);
+    expect(result1.error).toContain('control');
+
+    // Test bell character
+    const result2 = validateThinkingValue('\x07high');
+    expect(result2.valid).toBe(false);
+    expect(result2.error).toContain('control');
+
+    // Test DEL character
+    const result3 = validateThinkingValue('high\x7F');
+    expect(result3.valid).toBe(false);
+    expect(result3.error).toContain('control');
+  });
+
+  it('rejects values not in the allowed set', () => {
+    const result = validateThinkingValue('ultra-max-plus');
+    expect(result.valid).toBe(false);
+    expect(result.error).toContain('not in the allowed set');
+    expect(result.error).toContain('model-overrides.json');
+  });
+
+  it('rejects arbitrary string values', () => {
+    const invalidValues = ['random', 'custom-value', '123', 'HIGH'];
+
+    for (const value of invalidValues) {
+      const result = validateThinkingValue(value);
+      expect(result.valid).toBe(false);
+      expect(result.error).toContain('not in the allowed set');
+    }
+  });
+});
+
+// =============================================================================
+// DSL Parsing Tests (Characterization + Validation)
+// =============================================================================
+
+describe('parseScopedAssignment', () => {
+  describe('existing documented behavior', () => {
+    it('parses thinking shorthand aliases', () => {
+      expect(parseScopedAssignment('thinking.high=high')).toEqual({
+        ok: true,
+        fullPath: 'thinkingLevelMap.high',
+        value: 'high',
+      });
+    });
+
+    it('parses exact thinkingLevelMap field names', () => {
+      expect(parseScopedAssignment('thinkingLevelMap.xhigh=max')).toEqual({
+        ok: true,
+        fullPath: 'thinkingLevelMap.xhigh',
+        value: 'max',
+      });
+    });
+
+    it('parses null string values for thinking levels', () => {
+      expect(parseScopedAssignment('thinking.off=null')).toEqual({
+        ok: true,
+        fullPath: 'thinkingLevelMap.off',
+        value: null,
+      });
+    });
+
+    it('parses numeric and boolean top-level fields', () => {
+      expect(parseScopedAssignment('contextWindow=64000')).toEqual({
+        ok: true,
+        fullPath: 'contextWindow',
+        value: 64000,
+      });
+      expect(parseScopedAssignment('maxTokens=8192')).toEqual({
+        ok: true,
+        fullPath: 'maxTokens',
+        value: 8192,
+      });
+      expect(parseScopedAssignment('reasoning=false')).toEqual({
+        ok: true,
+        fullPath: 'reasoning',
+        value: false,
+      });
+    });
+
+    it('rejects malformed or unsupported assignments', () => {
+      expect(parseScopedAssignment('thinking.high')).toEqual({
+        ok: false,
+        code: 'invalid-assignment',
+      });
+      expect(parseScopedAssignment('unknown.field=value')).toEqual({
+        ok: false,
+        code: 'invalid-assignment',
+      });
+      expect(parseScopedAssignment('contextWindow=large')).toEqual({
+        ok: false,
+        code: 'invalid-assignment',
+      });
+      expect(parseScopedAssignment('reasoning=yes')).toEqual({
+        ok: false,
+        code: 'invalid-assignment',
+      });
+    });
+  });
+
+  describe('validation enforcement (Phase 7)', () => {
+    it('rejects empty thinking values with specific error', () => {
+      const result = parseScopedAssignment('thinking.high=');
+      expect(result).toMatchObject({
+        ok: false,
+        code: 'invalid-thinking-value',
+        field: 'thinking.high',
+      });
+      if (result.ok === false && result.code === 'invalid-thinking-value') {
+        expect(result.message).toContain('empty');
+      }
+    });
+
+    it('rejects whitespace-only thinking values with specific error', () => {
+      const result = parseScopedAssignment('thinking.high=   ');
+      expect(result).toMatchObject({
+        ok: false,
+        code: 'invalid-thinking-value',
+        field: 'thinking.high',
+      });
+      if (result.ok === false && result.code === 'invalid-thinking-value') {
+        expect(result.message).toContain('whitespace');
+      }
+    });
+
+    it('rejects thinking values with control characters with specific error', () => {
+      const result1 = parseScopedAssignment('thinking.high=high\x00');
+      expect(result1).toMatchObject({
+        ok: false,
+        code: 'invalid-thinking-value',
+        field: 'thinking.high',
+      });
+      if (result1.ok === false && result1.code === 'invalid-thinking-value') {
+        expect(result1.message).toContain('control');
+      }
+
+      const result2 = parseScopedAssignment('thinking.high=\x07high');
+      expect(result2).toMatchObject({
+        ok: false,
+        code: 'invalid-thinking-value',
+        field: 'thinking.high',
+      });
+      if (result2.ok === false && result2.code === 'invalid-thinking-value') {
+        expect(result2.message).toContain('control');
+      }
+    });
+
+    it('rejects undocumented thinking values with specific error', () => {
+      const result1 = parseScopedAssignment('thinking.high=ultra');
+      expect(result1).toMatchObject({
+        ok: false,
+        code: 'invalid-thinking-value',
+        field: 'thinking.high',
+      });
+      if (result1.ok === false && result1.code === 'invalid-thinking-value') {
+        expect(result1.message).toContain('not in the allowed set');
+      }
+
+      const result2 = parseScopedAssignment('thinking.high=custom-value');
+      expect(result2).toMatchObject({
+        ok: false,
+        code: 'invalid-thinking-value',
+        field: 'thinking.high',
+      });
+      if (result2.ok === false && result2.code === 'invalid-thinking-value') {
+        expect(result2.message).toContain('not in the allowed set');
+      }
+
+      const result3 = parseScopedAssignment('thinking.high=HIGH');
+      expect(result3).toMatchObject({
+        ok: false,
+        code: 'invalid-thinking-value',
+        field: 'thinking.high',
+      });
+      if (result3.ok === false && result3.code === 'invalid-thinking-value') {
+        expect(result3.message).toContain('not in the allowed set');
+      }
+    });
+
+    it('accepts all documented thinking values', () => {
+      const validPairs: Array<[string, string]> = [
+        ['thinking.off=off', 'off'],
+        ['thinking.minimal=minimal', 'minimal'],
+        ['thinking.low=low', 'low'],
+        ['thinking.medium=medium', 'medium'],
+        ['thinking.high=high', 'high'],
+        ['thinking.xhigh=max', 'max'],
+        ['thinking.xhigh=xhigh', 'xhigh'],
+      ];
+
+      for (const [input, expectedValue] of validPairs) {
+        const result = parseScopedAssignment(input);
+        expect(result.ok).toBe(true);
+        if (result.ok) {
+          expect(result.value).toBe(expectedValue);
+        }
+      }
+    });
+
+    it('does not validate non-thinking fields', () => {
+      // contextWindow and other fields should not be affected by thinking validation
+      expect(parseScopedAssignment('contextWindow=999999')).toEqual({
+        ok: true,
+        fullPath: 'contextWindow',
+        value: 999999,
+      });
+    });
+  });
+});
+
+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' } });
+  });
+});
+
+// =============================================================================
+// Command Handler Tests (Characterization)
+// =============================================================================
+
+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('rejects invalid thinking values in assignments with specific error', async () => {
+    const result = await handleModelOverrideSet(
+      'test/model thinking.high=ultra-max',
+      emptyOverrides(),
+    );
+
+    expect(result.success).toBe(false);
+    expect(result.message).toContain('Invalid thinking value');
+    expect(result.message).toContain('thinking.high');
+    expect(result.message).toContain('not in the allowed set');
+    expect(saveModelOverrides).not.toHaveBeenCalled();
+  });
+
+  it('rejects empty thinking values in assignments with specific error', async () => {
+    const result = await handleModelOverrideSet('test/model thinking.high=', emptyOverrides());
+
+    expect(result.success).toBe(false);
+    expect(result.message).toContain('Invalid thinking value');
+    expect(result.message).toContain('thinking.high');
+    expect(result.message).toContain('empty');
+    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.success).toBe(false);
+    expect(result.message).toContain('Usage: /openrouter model-override-clear');
+    expect(saveModelOverrides).not.toHaveBeenCalled();
+  });
+
+  it('rejects model IDs without provider/model format', async () => {
+    const result = await handleModelOverrideClear('not-a-model', emptyOverrides());
+
+    expect(result).toEqual({
+      success: false,
+      message: 'Invalid model ID format: "not-a-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();
+  });
+
+  it('lists available fields', async () => {
+    loadModelOverrides.mockResolvedValue(emptyOverrides());
+
+    const result = await handleModelOverrideList('--fields');
+
+    expect(result).toContain('Available override fields');
+    expect(result).toContain('thinking.high');
+    expect(result).toContain('contextWindow');
+  });
+
+  it('shows an empty state when no overrides exist', async () => {
+    loadModelOverrides.mockResolvedValue(emptyOverrides());
+
+    const result = await handleModelOverrideList('');
+
+    expect(result).toContain('No model overrides configured');
+    expect(result).toContain('model-override-set');
+  });
+
+  it('reports a missing specific model override', async () => {
+    loadModelOverrides.mockResolvedValue(emptyOverrides());
+
+    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: { high: 'high', xhigh: 'max', off: null },
+          contextWindow: 64000,
+        },
+      },
+    });
+
+    const result = await handleModelOverrideList('test/model');
+
+    expect(result).toContain('Overrides for test/model');
+    expect(result).toContain('thinkingLevelMap:');
+    expect(result).toContain('high: high');
+    expect(result).toContain('xhigh: max');
+    expect(result).toContain('off: null');
+    expect(result).toContain('contextWindow: 64000');
+  });
+
+  it('lists all override model IDs and summarizes non-null thinking values', async () => {
+    loadModelOverrides.mockResolvedValue({
+      version: 1,
+      overrides: {
+        'test/model1': { thinkingLevelMap: { high: 'high', off: null } },
+        'test/model2': { contextWindow: 128000 },
+      },
+    });
+
+    const result = await handleModelOverrideList('');
+
+    expect(result).toContain('2 model(s) with overrides');
+    expect(result).toContain('test/model1 [high=high]');
+    expect(result).toContain('test/model2');
+    expect(result).toContain('model-override-list <model-id>');
+  });
+});
+
+// =============================================================================
+// Field Map Tests (Characterization)
+// =============================================================================
+
+describe('SCOPED_FIELD_MAP', () => {
+  it('includes all documented thinking shorthand aliases', () => {
+    const expectedShorthands = [
+      'thinking.off',
+      'thinking.minimal',
+      'thinking.low',
+      'thinking.medium',
+      'thinking.high',
+      'thinking.xhigh',
+    ];
+
+    for (const shorthand of expectedShorthands) {
+      expect(SCOPED_FIELD_MAP[shorthand]).toBeDefined();
+      expect(SCOPED_FIELD_MAP[shorthand]?.targetType).toBe('string');
+      expect(SCOPED_FIELD_MAP[shorthand]?.targetField).toContain('thinkingLevelMap');
+    }
+  });
+
+  it('includes exact thinkingLevelMap field names', () => {
+    const expectedExact = [
+      'thinkingLevelMap.off',
+      'thinkingLevelMap.minimal',
+      'thinkingLevelMap.low',
+      'thinkingLevelMap.medium',
+      'thinkingLevelMap.high',
+      'thinkingLevelMap.xhigh',
+    ];
+
+    for (const exact of expectedExact) {
+      expect(SCOPED_FIELD_MAP[exact]).toBeDefined();
+      expect(SCOPED_FIELD_MAP[exact]?.targetType).toBe('string');
+      expect(SCOPED_FIELD_MAP[exact]?.targetField).toBe(exact);
+    }
+  });
+
+  it('includes top-level extensibility fields', () => {
+    expect(SCOPED_FIELD_MAP['contextWindow']).toEqual({
+      targetField: 'contextWindow',
+      targetType: 'number',
+    });
+    expect(SCOPED_FIELD_MAP['maxTokens']).toEqual({
+      targetField: 'maxTokens',
+      targetType: 'number',
+    });
+    expect(SCOPED_FIELD_MAP['reasoning']).toEqual({
+      targetField: 'reasoning',
+      targetType: 'boolean',
+    });
+  });
+});