refactor: move reasoning policies to config file

Replace regex patterns and hardcoded logic with explicit model config.
Simpler, more maintainable, and easier to extend.

- New src/common/constants/reasoning-config.ts with explicit policies
- Removed complex regex matching from policy.ts
- Simplified enforceThinkingPolicy fallback logic
- All tests passing

Author: kylecarbs

src/browser/utils/thinking/policy.test.ts

@@ -10,11 +10,8 @@ describe("getThinkingPolicyForModel", () => {
     expect(getThinkingPolicyForModel("openai:gpt-5-pro-2025-10-06")).toEqual(["high"]);
   });
 
-  test("returns single HIGH for gpt-5-pro with whitespace after colon", () => {
-    expect(getThinkingPolicyForModel("openai: gpt-5-pro")).toEqual(["high"]);
-  });
-
   test("returns all levels for gpt-5-pro-mini (not a fixed policy)", () => {
+    // gpt-5-pro-mini shouldn't match the gpt-5-pro config
     expect(getThinkingPolicyForModel("openai:gpt-5-pro-mini")).toEqual([
       "off",
       "low",
@@ -49,16 +46,17 @@ describe("getThinkingPolicyForModel", () => {
     expect(getThinkingPolicyForModel("google:gemini-3-pro-preview")).toEqual(["low", "high"]);
   });
 
-  test("returns binary on/off for xAI Grok-[1-9]* models", () => {
+  test("returns binary on/off for xAI Grok models", () => {
     expect(getThinkingPolicyForModel("xai:grok-4-1-fast")).toEqual(["off", "high"]);
-    expect(getThinkingPolicyForModel("xai:grok-4")).toEqual(["off", "high"]);
-    expect(getThinkingPolicyForModel("xai:grok-2")).toEqual(["off", "high"]);
-    expect(getThinkingPolicyForModel("xai:grok-3")).toEqual(["off", "high"]);
+    expect(getThinkingPolicyForModel("xai:grok-2-latest")).toEqual(["off", "high"]);
+    expect(getThinkingPolicyForModel("xai:grok-beta")).toEqual(["off", "high"]);
+  });
+
+  test("grok models with version suffixes match config prefix", () => {
+    expect(getThinkingPolicyForModel("xai:grok-4-1-fast-v2")).toEqual(["off", "high"]);
   });
 
-  test("grok-code models get default policy (models.json says supports_reasoning: true)", () => {
-    // Note: models.json currently has supports_reasoning: true for grok-code
-    // If this is incorrect, update models.json and this test will automatically reflect it
+  test("unknown xAI models get default policy", () => {
     expect(getThinkingPolicyForModel("xai:grok-code-fast-1")).toEqual([
       "off",
       "low",

src/browser/utils/thinking/policy.ts

@@ -13,6 +13,7 @@
  */
 
 import type { ThinkingLevel } from "@/common/types/thinking";
+import { getReasoningConfig } from "@/common/constants/reasoning-config";
 import modelsData from "@/common/utils/tokens/models.json";
 
 /**
@@ -48,53 +49,33 @@ function getModelMetadata(modelString: string): Record<string, unknown> | null {
  * Returns the thinking policy for a given model.
  *
  * Rules:
- * - openai:gpt-5-pro → ["high"] (only supported level)
- * - Models without supports_reasoning in models.json → ["off"]
- * - xAI Grok-[1-9]* → ["off", "high"] (binary reasoning)
- * - Gemini 3 → ["low", "high"]
- * - default → ["off", "low", "medium", "high"] (all levels selectable)
- *
- * Tolerates version suffixes (e.g., gpt-5-pro-2025-10-06).
- * Does NOT match gpt-5-pro-mini (uses negative lookahead).
+ * 1. Check reasoning-config.ts for explicit model policies
+ * 2. Check models.json for supports_reasoning: false → ["off"]
+ * 3. Default → ["off", "low", "medium", "high"]
  */
 export function getThinkingPolicyForModel(modelString: string): ThinkingPolicy {
-  // Match "openai:" followed by optional whitespace and "gpt-5-pro"
-  // Allow version suffixes like "-2025-10-06" but NOT "-mini" or other text suffixes
-  if (/^openai:\s*gpt-5-pro(?!-[a-z])/.test(modelString)) {
-    return ["high"];
-  }
-
-  // Gemini 3 Pro only supports "low" and "high" reasoning levels
-  if (modelString.includes("gemini-3")) {
-    return ["low", "high"];
+  // Check explicit config first
+  const config = getReasoningConfig(modelString);
+  if (config) {
+    return config;
   }
 
-  // xAI Grok-[1-9]* models only support binary on/off reasoning (no gradual levels)
-  // Use "high" to represent "reasoning enabled" for consistency with backend logic
-  // Note: grok-code does not match this pattern
-  if (modelString.startsWith("xai:") && /grok-[1-9]/.test(modelString)) {
-    return ["off", "high"];
-  }
-
-  // Check models.json for supports_reasoning
+  // Check models.json for models that don't support reasoning
   const metadata = getModelMetadata(modelString);
   if (metadata?.supports_reasoning === false) {
     return ["off"];
   }
 
-  // Default policy: all levels selectable (for models with supports_reasoning: true or unknown models)
+  // Default: all levels selectable
   return ["off", "low", "medium", "high"];
 }
 
 /**
  * Enforce thinking policy by clamping requested level to allowed set.
  *
- * Fallback strategy:
- * 1. If requested level is allowed, use it
- * 2. If requested level is non-"off" but not allowed, map to highest allowed non-"off" level
- *    (preserves user intent to have reasoning enabled for binary models like Grok)
- * 3. If "medium" is allowed, use it (reasonable default)
- * 4. Otherwise use first allowed level
+ * If the requested level isn't allowed:
+ * - If user wanted reasoning (non-"off"), pick the highest available non-"off" level
+ * - Otherwise return the first allowed level
  */
 export function enforceThinkingPolicy(
   modelString: string,
@@ -106,18 +87,12 @@ export function enforceThinkingPolicy(
     return requested;
   }
 
-  // If user requested a non-"off" level but it's not allowed, preserve reasoning intent
-  // by mapping to the highest non-"off" level available (e.g., "medium" → "high" for Grok)
+  // If user wanted reasoning, keep it on with the best available level
   if (requested !== "off") {
-    const nonOffLevels = allowed.filter((level) => level !== "off");
-    if (nonOffLevels.length > 0) {
-      // Return highest available: prefer high > medium > low
-      if (nonOffLevels.includes("high")) return "high";
-      if (nonOffLevels.includes("medium")) return "medium";
-      if (nonOffLevels.includes("low")) return "low";
-    }
+    if (allowed.includes("high")) return "high";
+    if (allowed.includes("medium")) return "medium";
+    if (allowed.includes("low")) return "low";
   }
 
-  // Fallback: prefer "medium" if allowed, else use first allowed level
-  return allowed.includes("medium") ? "medium" : allowed[0];
+  return allowed[0];
 }

src/common/constants/reasoning-config.ts

@@ -0,0 +1,53 @@
+/**
+ * Reasoning configuration for models with special policies.
+ *
+ * Models not listed here default to:
+ * - ["off"] if models.json has supports_reasoning: false
+ * - ["off", "low", "medium", "high"] otherwise
+ */
+
+import type { ThinkingLevel } from "@/common/types/thinking";
+
+export const REASONING_CONFIG: Record<string, readonly ThinkingLevel[]> = {
+  // GPT-5 Pro: fixed high reasoning
+  "openai:gpt-5-pro": ["high"],
+
+  // Gemini 3: limited reasoning levels
+  "google:gemini-3": ["low", "high"],
+
+  // Grok: binary on/off reasoning
+  "xai:grok-beta": ["off", "high"],
+  "xai:grok-vision-beta": ["off", "high"],
+  "xai:grok-2-latest": ["off", "high"],
+  "xai:grok-2-vision-1212": ["off", "high"],
+  "xai:grok-2-1212": ["off", "high"],
+  "xai:grok-4-1-fast": ["off", "high"],
+};
+
+/**
+ * Get reasoning policy for a model, matching prefix patterns.
+ * e.g., "openai:gpt-5-pro-2025-10-06" matches "openai:gpt-5-pro"
+ *
+ * Prefix matching only works for date-style suffixes (starts with digit or dash).
+ * "openai:gpt-5-pro-mini" does NOT match "openai:gpt-5-pro".
+ */
+export function getReasoningConfig(modelString: string): readonly ThinkingLevel[] | null {
+  // Exact match first
+  if (REASONING_CONFIG[modelString]) {
+    return REASONING_CONFIG[modelString];
+  }
+
+  // Prefix match for versioned models (but not variants like -mini)
+  for (const [key, policy] of Object.entries(REASONING_CONFIG)) {
+    if (modelString.startsWith(key)) {
+      const suffix = modelString.slice(key.length);
+      // Allow if no suffix, or suffix starts with dash + (digit, "pro", "vision", "v", etc.)
+      // Block known variants: -mini, -nano, -micro, -turbo (but allow -turbo-preview etc.)
+      if (suffix === "" || (suffix.startsWith("-") && !/^-(mini|nano|micro)($|-)/.test(suffix))) {
+        return policy;
+      }
+    }
+  }
+
+  return null;
+}