@robhowley/pi-openrouter 0.8.3 → 0.9.1

package/extensions/openrouter/models/mapper.ts

@@ -1,6 +1,9 @@
 import type { OpenRouterModel, PiModelConfig, SkipReason, MapResult } from './types.js';
 import { ROUTER_ALIASES } from './types.js';
+import { getSkipReasonHint } from './skip-hints.js';
 import type { Model as SDKModel } from '@openrouter/sdk/models/index.js';
+import { loadModelOverrides, getModelOverride } from './overrides.js';
+import { normalizeOpenRouterModel } from '../normalizers.js';
 
 // Cache for built-in OpenRouter models from pi-ai
 // Populated lazily on first access
@@ -20,7 +23,6 @@ async function loadBuiltInOpenRouterModels(): Promise<Map<string, PiModelConfig>
 
   try {
     // Import from pi-ai to get built-in model registry
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const { getModels } = (await import('@earendil-works/pi-ai')) as {
       getModels: (provider: string) => unknown[];
     };
@@ -29,7 +31,6 @@ async function loadBuiltInOpenRouterModels(): Promise<Map<string, PiModelConfig>
     if (Array.isArray(openrouterModels)) {
       for (const model of openrouterModels) {
         // Extract thinkingLevelMap from built-in model if present
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const modelWithThinking = model as { id: string; thinkingLevelMap?: unknown };
         if (modelWithThinking.id) {
           models.set(modelWithThinking.id, model as PiModelConfig);
@@ -58,68 +59,24 @@ const COST_PER_MILLION = 1_000_000;
 const DEFAULT_MAX_TOKENS = 4096;
 
 /**
- * Convert SDK Model to our OpenRouterModel type for compatibility.
- * Handles SDK's camelCase naming convention.
+ * Validation result for a model check.
  */
-export function sdkModelToOpenRouterModel(model: SDKModel): OpenRouterModel {
-  const topProvider = model.topProvider
-    ? {
-        context_length: model.topProvider.contextLength ?? 0,
-        max_completion_tokens: model.topProvider.maxCompletionTokens ?? 0,
-      }
-    : undefined;
-
-  const perRequestLimits = model.perRequestLimits
-    ? {
-        completion_tokens: model.perRequestLimits.completionTokens ?? 0,
-      }
-    : undefined;
-
-  // Build the object conditionally to avoid undefined property issues
-  const result: OpenRouterModel = {
-    id: model.id,
-    name: model.name,
-    architecture: {
-      input_modalities: model.architecture.inputModalities ?? [],
-      output_modalities: model.architecture.outputModalities ?? [],
-    },
-    context_length: model.contextLength ?? 0,
-    pricing: {
-      prompt: String(model.pricing.prompt ?? 0),
-      completion: String(model.pricing.completion ?? 0),
-      input_cache_read: String(model.pricing.inputCacheRead ?? 0),
-      input_cache_write: String(model.pricing.inputCacheWrite ?? 0),
-    },
-    supported_parameters: model.supportedParameters,
-  };
-
-  // Conditionally add optional properties to avoid explicit undefined
-  if (topProvider) {
-    result.top_provider = topProvider;
-  }
-  if (perRequestLimits) {
-    result.per_request_limits = perRequestLimits;
-  }
+type PricedOpenRouterModel = OpenRouterModel & {
+  pricing: NonNullable<OpenRouterModel['pricing']>;
+};
 
-  return result;
-}
+type ValidationResult =
+  | { valid: true; model: PricedOpenRouterModel; contextWindow: number }
+  | { valid: false; reason: string; modelId: string; hint?: string };
 
 /**
- * Normalize input model to OpenRouterModel format.
+ * Build a failed validation result with a stable machine reason and optional hint.
  */
-function normalizeModel(model: OpenRouterModel | SDKModel): OpenRouterModel {
-  return 'contextLength' in model
-    ? sdkModelToOpenRouterModel(model as SDKModel)
-    : (model as OpenRouterModel);
+function invalidModel(reason: string, modelId: string): ValidationResult {
+  const hint = getSkipReasonHint(reason);
+  return hint ? { valid: false, reason, modelId, hint } : { valid: false, reason, modelId };
 }
 
-/**
- * Validation result for a model check.
- */
-type ValidationResult =
-  | { valid: true; model: OpenRouterModel; contextWindow: number }
-  | { valid: false; reason: string; modelId: string };
-
 /**
  * Validate a model and return either a valid result with extracted context window
  * or a failure reason.
@@ -127,39 +84,42 @@ type ValidationResult =
 function validateModel(model: OpenRouterModel): ValidationResult {
   // Check: missing required id
   if (!model.id) {
-    return { valid: false, reason: 'missing id', modelId: 'unknown' };
+    return invalidModel('missing id', 'unknown');
   }
 
   // Check: missing required pricing fields
-  if (!model.pricing?.prompt) {
-    return { valid: false, reason: 'missing prompt pricing', modelId: model.id };
+  const pricing = model.pricing;
+  if (!pricing?.prompt) {
+    return invalidModel('missing prompt pricing', model.id);
   }
-  if (!model.pricing?.completion) {
-    return { valid: false, reason: 'missing completion pricing', modelId: model.id };
+  if (!pricing.completion) {
+    return invalidModel('missing completion pricing', model.id);
   }
 
   // Check: missing context window (both primary and fallback)
   const contextWindow = model.top_provider?.context_length ?? model.context_length;
   if (!contextWindow) {
-    return { valid: false, reason: 'missing context window', modelId: model.id };
+    return invalidModel('missing context window', model.id);
   }
 
   // Check: explicitly non-text output (if specified)
   const outputModalities = model.architecture?.output_modalities;
   if (outputModalities && !outputModalities.includes('text')) {
-    return { valid: false, reason: 'non-text output modalities', modelId: model.id };
+    return invalidModel('non-text output modalities', model.id);
   }
 
-  return { valid: true, model, contextWindow };
+  return { valid: true, model: { ...model, pricing }, contextWindow };
 }
 
 /**
  * Build PiModelConfig from a validated OpenRouterModel.
- * Merges thinkingLevelMap from Pi's built-in registry if available.
+ * Merges thinkingLevelMap from Pi's built-in registry and user overrides.
+ * Priority: user overrides > built-in registry > API data
  */
 async function buildPiConfig(
-  model: OpenRouterModel,
+  model: PricedOpenRouterModel,
   contextWindow: number,
+  userOverrides?: Awaited<ReturnType<typeof loadModelOverrides>>,
 ): Promise<PiModelConfig> {
   const supportedParams = model.supported_parameters ?? [];
   const hasReasoning =
@@ -168,12 +128,25 @@ async function buildPiConfig(
   const supportsImages = inputModalities?.includes('image') ?? false;
 
   // Fetch thinkingLevelMap from built-in registry if this is a reasoning model
-  const thinkingLevelMap = hasReasoning ? await getBuiltInThinkingLevelMap(model.id) : undefined;
+  const builtInThinkingLevelMap = hasReasoning
+    ? await getBuiltInThinkingLevelMap(model.id)
+    : undefined;
+
+  // Fetch user override for this model
+  const userOverride = userOverrides ? getModelOverride(userOverrides, model.id) : undefined;
+
+  const thinkingLevelMap =
+    builtInThinkingLevelMap !== undefined || userOverride?.thinkingLevelMap !== undefined
+      ? {
+          ...builtInThinkingLevelMap,
+          ...userOverride?.thinkingLevelMap,
+        }
+      : undefined;
 
   const config: PiModelConfig = {
     id: model.id,
     name: model.name ?? model.id,
-    reasoning: hasReasoning,
+    reasoning: userOverride?.reasoning ?? hasReasoning,
     input: supportsImages ? ['text', 'image'] : ['text'],
     cost: {
       input: Number(model.pricing.prompt) * COST_PER_MILLION,
@@ -181,8 +154,9 @@ async function buildPiConfig(
       cacheRead: Number(model.pricing.input_cache_read ?? 0) * COST_PER_MILLION,
       cacheWrite: Number(model.pricing.input_cache_write ?? 0) * COST_PER_MILLION,
     },
-    contextWindow,
+    contextWindow: userOverride?.contextWindow ?? contextWindow,
     maxTokens:
+      userOverride?.maxTokens ??
       model.top_provider?.max_completion_tokens ??
       model.per_request_limits?.completion_tokens ??
       DEFAULT_MAX_TOKENS,
@@ -198,20 +172,21 @@ async function buildPiConfig(
 
 /**
  * Maps multiple OpenRouter models, tracking skips.
- * Async to allow fetching thinkingLevelMap from built-in registry.
+ * Async to allow fetching thinkingLevelMap from built-in registry and user overrides.
  */
 export async function mapOpenRouterModels(
   models: OpenRouterModel[] | SDKModel[],
 ): Promise<MapResult> {
-  // Pre-load built-in models for efficient lookup during mapping
+  // Pre-load built-in models and user overrides for efficient lookup during mapping
   await loadBuiltInOpenRouterModels();
+  const userOverrides = await loadModelOverrides();
 
   const configs: PiModelConfig[] = [];
   let skipped = 0;
   const skippedDetails: SkipReason[] = [];
 
   for (const rawModel of models) {
-    const model = normalizeModel(rawModel);
+    const model = normalizeOpenRouterModel(rawModel);
 
     // Skip router aliases - they're added manually after mapping
     if (ROUTER_ALIASES.includes(model.id)) {
@@ -222,11 +197,18 @@ export async function mapOpenRouterModels(
 
     if (!validation.valid) {
       skipped++;
-      skippedDetails.push({ id: validation.modelId, reason: validation.reason });
+      const skippedDetail: SkipReason = {
+        id: validation.modelId,
+        reason: validation.reason,
+      };
+      if (validation.hint) {
+        skippedDetail.hint = validation.hint;
+      }
+      skippedDetails.push(skippedDetail);
       continue;
     }
 
-    configs.push(await buildPiConfig(model, validation.contextWindow));
+    configs.push(await buildPiConfig(validation.model, validation.contextWindow, userOverrides));
   }
 
   return { configs, skipped, skippedDetails };
@@ -241,8 +223,9 @@ export async function mapOpenRouterModel(
   model: OpenRouterModel | SDKModel,
 ): Promise<PiModelConfig | null> {
   await loadBuiltInOpenRouterModels();
+  const userOverrides = await loadModelOverrides();
 
-  const normalized = normalizeModel(model);
+  const normalized = normalizeOpenRouterModel(model);
 
   // Router aliases are handled separately, skip them here
   if (ROUTER_ALIASES.includes(normalized.id)) {
@@ -255,5 +238,5 @@ export async function mapOpenRouterModel(
     return null;
   }
 
-  return buildPiConfig(normalized, validation.contextWindow);
+  return buildPiConfig(validation.model, validation.contextWindow, userOverrides);
 }

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

@@ -0,0 +1,434 @@
+/**
+ * Model override DSL parsing, validation, and command handlers.
+ * Extracted from index.ts to keep command routing logic separate from DSL implementation.
+ */
+
+import type { ThinkingLevelMap, UserModelOverride } from './types.js';
+import type { ModelOverridesFile } from './types.js';
+import {
+  getModelOverride,
+  getOverrideModelIds,
+  hasOverrides,
+  loadModelOverrides,
+  removeModelOverride,
+  saveModelOverrides,
+  setModelOverride,
+} from './overrides.js';
+// Utility to extract error messages
+function getErrorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// =============================================================================
+// Types
+// =============================================================================
+
+export interface HandlerResult {
+  success: boolean;
+  message: string;
+  modelId?: string;
+}
+
+interface ScopedField {
+  targetField: string;
+  targetType: 'string' | 'number' | 'boolean';
+}
+
+// =============================================================================
+// Scoped Field Mapping
+// =============================================================================
+
+/**
+ * Scoped field name mapping: converts user-facing 'thinking.X' to internal 'thinkingLevelMap.X'
+ * Also supports exact PiModelConfig field names for future extensibility.
+ */
+export const SCOPED_FIELD_MAP: Record<string, ScopedField> = {
+  // thinking.* shorthand - maps to thinkingLevelMap
+  'thinking.off': { targetField: 'thinkingLevelMap.off', targetType: 'string' },
+  'thinking.minimal': { targetField: 'thinkingLevelMap.minimal', targetType: 'string' },
+  'thinking.low': { targetField: 'thinkingLevelMap.low', targetType: 'string' },
+  'thinking.medium': { targetField: 'thinkingLevelMap.medium', targetType: 'string' },
+  'thinking.high': { targetField: 'thinkingLevelMap.high', targetType: 'string' },
+  'thinking.xhigh': { targetField: 'thinkingLevelMap.xhigh', targetType: 'string' },
+
+  // exact field names (passthrough)
+  'thinkingLevelMap.off': { targetField: 'thinkingLevelMap.off', targetType: 'string' },
+  'thinkingLevelMap.minimal': { targetField: 'thinkingLevelMap.minimal', targetType: 'string' },
+  'thinkingLevelMap.low': { targetField: 'thinkingLevelMap.low', targetType: 'string' },
+  'thinkingLevelMap.medium': { targetField: 'thinkingLevelMap.medium', targetType: 'string' },
+  'thinkingLevelMap.high': { targetField: 'thinkingLevelMap.high', targetType: 'string' },
+  'thinkingLevelMap.xhigh': { targetField: 'thinkingLevelMap.xhigh', targetType: 'string' },
+
+  // top-level fields (future extensibility)
+  contextWindow: { targetField: 'contextWindow', targetType: 'number' },
+  maxTokens: { targetField: 'maxTokens', targetType: 'number' },
+  reasoning: { targetField: 'reasoning', targetType: 'boolean' },
+};
+
+// =============================================================================
+// Validation
+// =============================================================================
+
+/**
+ * Conservative allowlist of thinking level values accepted via CLI DSL.
+ * These match documented OpenRouter and Pi thinking values.
+ *
+ * The JSON file escape hatch (`~/.pi/openrouter/model-overrides.json`) can be
+ * edited manually for advanced or experimental values outside this set.
+ */
+const ALLOWED_THINKING_VALUES = new Set([
+  'off',
+  'minimal',
+  'low',
+  'medium',
+  'high',
+  'max',
+  'xhigh', // Alias for some models
+]);
+
+/**
+ * Validate a thinking level value from the CLI DSL.
+ * Rejects empty, whitespace-only, or control-character values.
+ * Allows null (explicit "hide this level in UI" signal) and documented thinking values.
+ */
+export function validateThinkingValue(value: string | null): {
+  valid: boolean;
+  error?: string;
+} {
+  if (value === null) {
+    return { valid: true }; // null is allowed (means "hide this level")
+  }
+
+  // Reject empty or whitespace-only
+  if (value.trim() === '') {
+    return {
+      valid: false,
+      error: 'Thinking value cannot be empty or whitespace-only',
+    };
+  }
+
+  // Reject control characters (0x00-0x1F except tab/newline, and 0x7F)
+  // eslint-disable-next-line no-control-regex
+  if (/[\x00-\x08\x0B-\x0C\x0E-\x1F\x7F]/.test(value)) {
+    return {
+      valid: false,
+      error: 'Thinking value cannot contain control characters',
+    };
+  }
+
+  // Check against conservative allowlist
+  if (!ALLOWED_THINKING_VALUES.has(value)) {
+    return {
+      valid: false,
+      error: `Thinking value "${value}" is not in the allowed set: ${Array.from(ALLOWED_THINKING_VALUES).join(', ')}\nFor advanced values, edit ~/.pi/openrouter/model-overrides.json directly`,
+    };
+  }
+
+  return { valid: true };
+}
+
+// =============================================================================
+// DSL Parsing
+// =============================================================================
+
+/**
+ * Result of parsing a scoped assignment.
+ */
+export type ParseResult =
+  | { ok: true; fullPath: string; value: unknown }
+  | { ok: false; code: 'invalid-assignment' }
+  | { ok: false; code: 'invalid-thinking-value'; field: string; message: string };
+
+/**
+ * Parse a scoped assignment like "thinking.high=high" or "contextWindow=128000".
+ */
+export function parseScopedAssignment(assignment: string): ParseResult {
+  const eqIdx = assignment.indexOf('=');
+  if (eqIdx === -1) return { ok: false, code: 'invalid-assignment' };
+
+  const scopedName = assignment.slice(0, eqIdx).trim();
+  const rawValue = assignment.slice(eqIdx + 1).trim();
+
+  const mapped = SCOPED_FIELD_MAP[scopedName];
+  if (!mapped) return { ok: false, code: 'invalid-assignment' };
+
+  // Parse value by type
+  let parsedValue: unknown;
+  switch (mapped.targetType) {
+    case 'string': {
+      // "null" -> null, otherwise string
+      const stringValue = rawValue === 'null' ? null : rawValue;
+
+      // Validate thinking values if this is a thinkingLevelMap field
+      if (mapped.targetField.startsWith('thinkingLevelMap.')) {
+        const validation = validateThinkingValue(stringValue);
+        if (!validation.valid) {
+          return {
+            ok: false,
+            code: 'invalid-thinking-value',
+            field: scopedName,
+            message: validation.error!,
+          };
+        }
+      }
+
+      parsedValue = stringValue;
+      break;
+    }
+    case 'number': {
+      const num = parseInt(rawValue, 10);
+      if (isNaN(num)) return { ok: false, code: 'invalid-assignment' };
+      parsedValue = num;
+      break;
+    }
+    case 'boolean':
+      if (rawValue !== 'true' && rawValue !== 'false')
+        return { ok: false, code: 'invalid-assignment' };
+      parsedValue = rawValue === 'true';
+      break;
+    default:
+      return { ok: false, code: 'invalid-assignment' };
+  }
+
+  return { ok: true, fullPath: mapped.targetField, value: parsedValue };
+}
+
+/**
+ * Apply a nested value to an object using dot notation path.
+ */
+export function applyNestedValue(obj: Record<string, unknown>, path: string, value: unknown): void {
+  const parts = path.split('.');
+  let current: unknown = obj;
+
+  for (let i = 0; i < parts.length - 1; i++) {
+    const key = parts[i]!;
+    const currentRecord = current as Record<string, unknown>;
+    if (
+      !(key in currentRecord) ||
+      typeof currentRecord[key] !== 'object' ||
+      currentRecord[key] === null
+    ) {
+      currentRecord[key] = {};
+    }
+    current = currentRecord[key];
+  }
+
+  const finalKey = parts[parts.length - 1]!;
+  (current as Record<string, unknown>)[finalKey] = value;
+}
+
+// =============================================================================
+// Command Handlers
+// =============================================================================
+
+/**
+ * Handle /openrouter model-override-set command.
+ * Format: model-override-set <model-id> <field=value>...
+ * Examples:
+ *   /openrouter model-override-set deepseek/deepseek-v4-pro thinking.high=high thinking.xhigh=max
+ *   /openrouter model-override-set deepseek/deepseek-v4-pro contextWindow=128000
+ */
+export async function handleModelOverrideSet(
+  args: string,
+  userOverrides: ModelOverridesFile,
+): Promise<HandlerResult> {
+  const parts = args.trim().split(/\s+/).filter(Boolean);
+
+  if (parts.length < 1) {
+    return {
+      success: false,
+      message:
+        'Usage: /openrouter model-override-set <model-id> <field=value>...\nExample: /openrouter model-override-set deepseek/deepseek-v4-pro thinking.high=high thinking.xhigh=max',
+    };
+  }
+
+  const modelId = parts[0];
+
+  if (!modelId) {
+    return {
+      success: false,
+      message:
+        'Usage: /openrouter model-override-set <model-id> <field=value>...\nExample: /openrouter model-override-set deepseek/deepseek-v4-pro thinking.high=high thinking.xhigh=max',
+    };
+  }
+
+  // Validate model ID format (should be provider/model)
+  if (!modelId.includes('/')) {
+    return {
+      success: false,
+      message: `Invalid model ID format: "${modelId}"\nExpected format: provider/model (e.g., "deepseek/deepseek-v4-pro")`,
+    };
+  }
+
+  // Build override incrementally from assignments
+  const override: UserModelOverride = {};
+  const assignments = parts.slice(1).filter((p) => !p.startsWith('--'));
+
+  for (const assignment of assignments) {
+    const parsed = parseScopedAssignment(assignment);
+    if (!parsed.ok) {
+      if (parsed.code === 'invalid-thinking-value') {
+        return {
+          success: false,
+          message: `Invalid thinking value for "${parsed.field}": ${parsed.message}`,
+        };
+      }
+      return {
+        success: false,
+        message: `Invalid assignment: "${assignment}"\nExpected format: field=value (e.g., thinking.high=high or contextWindow=128000)\nSee available fields with /openrouter model-override-list --fields`,
+      };
+    }
+    applyNestedValue(override as Record<string, unknown>, parsed.fullPath, parsed.value);
+  }
+
+  // If no assignments provided, error out
+  if (Object.keys(override).length === 0) {
+    return {
+      success: false,
+      message:
+        'No field assignments provided.\nUsage: /openrouter model-override-set <model-id> field=value [field=value]...\nExample: /openrouter model-override-set deepseek/deepseek-v4-pro thinking.high=high thinking.xhigh=max',
+    };
+  }
+
+  // Update overrides file
+  const updatedOverrides = setModelOverride(userOverrides, modelId, override);
+  try {
+    await saveModelOverrides(updatedOverrides);
+  } catch (error) {
+    return {
+      success: false,
+      message: `Failed to save overrides for ${modelId}: ${getErrorMessage(error)}`,
+    };
+  }
+
+  const savedOverride = updatedOverrides.overrides[modelId] as UserModelOverride;
+
+  // Format success message
+  const lines: string[] = [`Saved overrides for ${modelId}:`];
+  for (const [key, val] of Object.entries(savedOverride)) {
+    if (key === 'thinkingLevelMap' && val) {
+      lines.push('  thinkingLevelMap:');
+      for (const [level, mapped] of Object.entries(val as ThinkingLevelMap)) {
+        lines.push(`    ${level}: ${mapped === null ? 'null' : mapped}`);
+      }
+    } else {
+      lines.push(`  ${key}: ${val}`);
+    }
+  }
+
+  return {
+    success: true,
+    message: lines.join('\n'),
+    modelId,
+  };
+}
+
+/**
+ * Handle /openrouter model-override-clear command.
+ */
+export async function handleModelOverrideClear(
+  args: string,
+  userOverrides: ModelOverridesFile,
+): Promise<HandlerResult> {
+  const parts = args.trim().split(/\s+/).filter(Boolean);
+  const modelId = parts[0];
+
+  if (!modelId) {
+    return {
+      success: false,
+      message: 'Usage: /openrouter model-override-clear <model-id>',
+    };
+  }
+
+  if (!modelId.includes('/')) {
+    return {
+      success: false,
+      message: `Invalid model ID format: "${modelId}"\nExpected format: provider/model`,
+    };
+  }
+
+  const existing = getModelOverride(userOverrides, modelId);
+  if (!existing) {
+    return {
+      success: false,
+      message: `No overrides found for ${modelId}`,
+    };
+  }
+
+  const updatedOverrides = removeModelOverride(userOverrides, modelId);
+  try {
+    await saveModelOverrides(updatedOverrides);
+  } catch (error) {
+    return {
+      success: false,
+      message: `Failed to clear overrides for ${modelId}: ${getErrorMessage(error)}`,
+    };
+  }
+
+  return {
+    success: true,
+    message: `Cleared all overrides for ${modelId}`,
+    modelId,
+  };
+}
+
+/**
+ * Handle /openrouter model-override-list command.
+ */
+export async function handleModelOverrideList(args: string): Promise<string> {
+  const userOverrides = await loadModelOverrides();
+  const modelId = args.trim();
+
+  // List available fields if --fields flag
+  if (modelId === '--fields') {
+    const fields = Object.keys(SCOPED_FIELD_MAP)
+      .map(
+        (k) => `  ${k}: ${SCOPED_FIELD_MAP[k]!.targetField} (${SCOPED_FIELD_MAP[k]!.targetType})`,
+      )
+      .join('\n');
+    return `Available override fields:\n${fields}`;
+  }
+
+  if (modelId) {
+    // Show specific model
+    const override = getModelOverride(userOverrides, modelId);
+    if (!override) {
+      return `No overrides configured for ${modelId}`;
+    }
+
+    const lines: string[] = [`Overrides for ${modelId}:`];
+    for (const [key, val] of Object.entries(override)) {
+      if (key === 'thinkingLevelMap' && val) {
+        lines.push('  thinkingLevelMap:');
+        for (const [level, mapped] of Object.entries(val as ThinkingLevelMap)) {
+          lines.push(`    ${level}: ${mapped === null ? 'null' : mapped}`);
+        }
+      } else {
+        lines.push(`  ${key}: ${val}`);
+      }
+    }
+    return lines.join('\n');
+  }
+
+  if (!hasOverrides(userOverrides)) {
+    return 'No model overrides configured.\nUse /openrouter model-override-set to add overrides.';
+  }
+
+  // List all overrides
+  const modelIds = getOverrideModelIds(userOverrides);
+  const lines: string[] = [`${modelIds.length} model(s) with overrides:`];
+  for (const id of modelIds) {
+    const override = getModelOverride(userOverrides, id);
+    if (override?.thinkingLevelMap && Object.keys(override.thinkingLevelMap).length > 0) {
+      const tlm = Object.entries(override.thinkingLevelMap)
+        .filter(([, v]) => v !== null)
+        .map(([k, v]) => `${k}=${v}`)
+        .join(',');
+      lines.push(`  ${id}${tlm ? ` [${tlm}]` : ''}`);
+    } else {
+      lines.push(`  ${id}`);
+    }
+  }
+  lines.push('\nUse /openrouter model-override-list <model-id> for details');
+  return lines.join('\n');
+}