feat: multi-model AI analysis with auto-selection by context

Backend (src/ai.rs, src/routes/analysis.rs):
- Add Model enum: Haiku 4.5 / Sonnet 4.6 / Opus 4.6 with api_id,
  display_name, max_tokens (512 / 1024 / 2048)
- Add AnalysisContext struct + select_model() function:
  - Haiku: vitals events, info-level, < 5 frames, high-frequency (>500 events)
  - Opus: chained exceptions, > 30 frames, critical error with > 20 frames
  - Sonnet: everything else (balanced default)
- analyse_issue() accepts &Model and adjusts depth instruction per tier
- POST /api/issues/:id/analyze accepts optional JSON body { "model": "auto"|"haiku"|"sonnet"|"opus" }
- Response includes model, model_auto (bool), model_reason (why auto chose it)
- GET /api/issues/:id/analyze returns model_auto + model_reason from cache
- Migration: add model_auto + model_reason columns to ai_analyses

Frontend (IssueDetails.vue):
- Model picker toggle bar: Auto / Haiku / Sonnet / Opus (with tooltips)
- Sends chosen model in POST body; defaults to "auto"
- Result footer shows auto-selection reason (italic), model badge
  colour-coded (sky=Haiku, violet=Sonnet, amber=Opus),
  auto-selected vs manual indicator

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: 2 people

dashboard/src/views/IssueDetails.vue

@@ -528,26 +528,45 @@
 
       <!-- ── AI Analysis panel ──────────────────────────────────────────── -->
       <div class="mb-6">
-        <div class="flex items-center justify-between mb-3">
+        <div class="flex items-center justify-between mb-3 gap-3 flex-wrap">
           <h2 class="text-[11px] text-gray-500 uppercase tracking-wide font-medium flex items-center gap-1.5">
             <span>AI Analysis</span>
             <span v-if="ai?.cached" class="text-[9px] px-1.5 py-0.5 rounded bg-gray-700/60 text-gray-500 font-bold tracking-wider">cached</span>
           </h2>
-          <button
-            @click="runAnalysis"
-            :disabled="aiLoading"
-            class="flex items-center gap-1.5 text-[11px] px-3 py-1.5 rounded-lg font-medium transition-all
-                   bg-violet-600/20 text-violet-400 hover:bg-violet-600/30 disabled:opacity-50 disabled:cursor-not-allowed"
-          >
-            <svg v-if="aiLoading" class="animate-spin w-3 h-3" viewBox="0 0 24 24" fill="none">
-              <circle class="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" stroke-width="4"/>
-              <path class="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8v8H4z"/>
-            </svg>
-            <svg v-else width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
-              <path d="M12 2L2 7l10 5 10-5-10-5zM2 17l10 5 10-5M2 12l10 5 10-5"/>
-            </svg>
-            {{ aiLoading ? 'Analysing…' : ai ? 'Re-analyse' : 'Analyse with AI' }}
-          </button>
+
+          <div class="flex items-center gap-2 ml-auto">
+            <!-- Model picker -->
+            <div class="flex items-center bg-[#111119] border border-white/6 rounded-lg p-0.5 gap-0.5">
+              <button
+                v-for="m in MODEL_OPTIONS" :key="m.value"
+                @click="selectedModel = m.value"
+                :class="selectedModel === m.value
+                  ? 'bg-[#1e1e30] text-white'
+                  : 'text-gray-500 hover:text-gray-300'"
+                class="px-2.5 py-1 rounded-md text-[10px] font-medium transition-all whitespace-nowrap"
+                :title="m.description"
+              >
+                {{ m.label }}
+              </button>
+            </div>
+
+            <!-- Analyse button -->
+            <button
+              @click="runAnalysis"
+              :disabled="aiLoading"
+              class="flex items-center gap-1.5 text-[11px] px-3 py-1.5 rounded-lg font-medium transition-all
+                     bg-violet-600/20 text-violet-400 hover:bg-violet-600/30 disabled:opacity-50 disabled:cursor-not-allowed"
+            >
+              <svg v-if="aiLoading" class="animate-spin w-3 h-3" viewBox="0 0 24 24" fill="none">
+                <circle class="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" stroke-width="4"/>
+                <path class="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8v8H4z"/>
+              </svg>
+              <svg v-else width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                <path d="M12 2L2 7l10 5 10-5-10-5zM2 17l10 5 10-5M2 12l10 5 10-5"/>
+              </svg>
+              {{ aiLoading ? 'Analysing…' : ai ? 'Re-analyse' : 'Analyse with AI' }}
+            </button>
+          </div>
         </div>
 
         <div v-if="aiError" class="bg-red-500/10 border border-red-500/20 rounded-xl px-4 py-3 text-sm text-red-400">
@@ -580,13 +599,32 @@
             <p class="text-[10px] text-gray-600 uppercase tracking-wide font-medium mb-1.5">Prevention</p>
             <p class="text-[13px] text-gray-400 leading-relaxed">{{ ai.prevention }}</p>
           </div>
-          <p class="text-[10px] text-gray-700 text-right">
-            Powered by {{ ai.model }} · {{ ai.cached ? 'cached result' : 'fresh analysis' }}
-          </p>
+
+          <!-- Model footer -->
+          <div class="flex items-center justify-between flex-wrap gap-2">
+            <div v-if="ai.model_auto && ai.model_reason"
+              class="flex items-center gap-1.5 text-[10px] text-gray-600">
+              <svg width="10" height="10" viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="1.8">
+                <circle cx="8" cy="8" r="6"/><line x1="8" y1="5" x2="8" y2="8"/><circle cx="8" cy="11" r="0.5" fill="currentColor"/>
+              </svg>
+              <span class="italic">{{ ai.model_reason }}</span>
+            </div>
+            <p class="text-[10px] text-gray-700 ml-auto">
+              <span :class="modelBadgeColor(ai.model)" class="font-semibold">{{ ai.model }}</span>
+              · {{ ai.model_auto ? 'auto-selected' : 'manual' }}
+              · {{ ai.cached ? 'cached' : 'fresh' }}
+            </p>
+          </div>
         </div>
 
         <div v-else class="bg-[#111119] border border-white/6 rounded-xl px-4 py-6 text-center">
-          <p class="text-[13px] text-gray-500">Click <span class="text-violet-400 font-medium">Analyse with AI</span> to get root cause, fix suggestions, and prevention tips powered by Claude.</p>
+          <p class="text-[13px] text-gray-500">
+            Click <span class="text-violet-400 font-medium">Analyse with AI</span> to get root cause,
+            fix suggestions, and prevention tips.
+          </p>
+          <p class="text-[11px] text-gray-700 mt-1">
+            Model: <span class="text-gray-500">{{ selectedModel === 'auto' ? 'auto-selected based on issue complexity' : selectedModelLabel }}</span>
+          </p>
         </div>
       </div>
 
@@ -608,7 +646,7 @@
 </template>
 
 <script setup>
-import { ref, onMounted } from 'vue'
+import { computed, ref, onMounted } from 'vue'
 import { useRoute, useRouter } from 'vue-router'
 import axios from 'axios'
 
@@ -619,6 +657,27 @@ const loading              = ref(true)
 const ai                   = ref(null)
 const aiLoading            = ref(false)
 const aiError              = ref(null)
+
+// ── AI model selection ────────────────────────────────────────────────────────
+const MODEL_OPTIONS = [
+  { value: 'auto',   label: 'Auto',   description: 'Automatically pick the best model based on issue complexity' },
+  { value: 'haiku',  label: 'Haiku',  description: 'Claude Haiku 4.5 — fast, great for simple/high-frequency errors' },
+  { value: 'sonnet', label: 'Sonnet', description: 'Claude Sonnet 4.6 — balanced accuracy and speed (recommended)' },
+  { value: 'opus',   label: 'Opus',   description: 'Claude Opus 4.6 — most capable, best for deep/complex issues' },
+]
+const selectedModel      = ref('auto')
+const selectedModelLabel = computed(() =>
+  MODEL_OPTIONS.find(m => m.value === selectedModel.value)?.description ?? ''
+)
+
+const modelBadgeColor = (model) => {
+  if (!model) return 'text-gray-500'
+  const m = model.toLowerCase()
+  if (m.includes('haiku'))  return 'text-sky-400'
+  if (m.includes('sonnet')) return 'text-violet-400'
+  if (m.includes('opus'))   return 'text-amber-400'
+  return 'text-gray-400'
+}
 const showAssignee         = ref(false)
 const assigneeInput        = ref('')
 const expandedPlugins      = ref(new Set())
@@ -763,7 +822,10 @@ async function runAnalysis() {
   aiLoading.value = true
   aiError.value   = null
   try {
-    const { data } = await axios.post(`/api/issues/${route.params.id}/analyze`)
+    const { data } = await axios.post(
+      `/api/issues/${route.params.id}/analyze`,
+      { model: selectedModel.value },
+    )
     ai.value = data
   } catch (err) {
     if (err.response?.status === 429) {

migrations/20260329000000_ai_multi_model.sql

@@ -0,0 +1,4 @@
+-- Add model selection metadata to ai_analyses
+ALTER TABLE ai_analyses
+    ADD COLUMN IF NOT EXISTS model_auto   BOOLEAN DEFAULT TRUE  NOT NULL,
+    ADD COLUMN IF NOT EXISTS model_reason TEXT    DEFAULT NULL;

src/ai.rs

@@ -4,36 +4,133 @@ use serde::{Deserialize, Serialize};
 use serde_json::{json, Value};
 
 const ANTHROPIC_API: &str = "https://api.anthropic.com/v1/messages";
-const MODEL: &str = "claude-sonnet-4-6";
+
+// ── Model registry ────────────────────────────────────────────────────────────
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum Model {
+    Haiku,   // Fast, cheap — simple/common errors, vitals, high-frequency issues
+    Sonnet,  // Balanced — standard production errors (default)
+    Opus,    // Most capable — deep stacks, exception chains, critical issues
+}
+
+impl Model {
+    pub fn from_str(s: &str) -> Option<Self> {
+        match s.to_lowercase().as_str() {
+            "haiku"  | "claude-haiku-4-5"            => Some(Self::Haiku),
+            "sonnet" | "claude-sonnet-4-6"            => Some(Self::Sonnet),
+            "opus"   | "claude-opus-4-6"              => Some(Self::Opus),
+            _ => None,
+        }
+    }
+
+    pub fn api_id(&self) -> &'static str {
+        match self {
+            Self::Haiku  => "claude-haiku-4-5-20251001",
+            Self::Sonnet => "claude-sonnet-4-6",
+            Self::Opus   => "claude-opus-4-6",
+        }
+    }
+
+    pub fn display_name(&self) -> &'static str {
+        match self {
+            Self::Haiku  => "Claude Haiku 4.5",
+            Self::Sonnet => "Claude Sonnet 4.6",
+            Self::Opus   => "Claude Opus 4.6",
+        }
+    }
+
+    pub fn max_tokens(&self) -> u32 {
+        match self {
+            Self::Haiku  => 512,
+            Self::Sonnet => 1024,
+            Self::Opus   => 2048,
+        }
+    }
+}
+
+// ── Auto-selection logic ──────────────────────────────────────────────────────
+
+pub struct AnalysisContext {
+    pub stacktrace_frames:   usize,
+    pub level:               String,
+    pub event_count:         i64,
+    pub has_exception_chain: bool,
+    pub is_vitals:           bool,
+}
+
+/// Pick the most appropriate model based on issue complexity signals.
+/// Returns (Model, reason_string).
+pub fn select_model(ctx: &AnalysisContext) -> (Model, &'static str) {
+    // Vitals events are pure metrics — arithmetic, not reasoning
+    if ctx.is_vitals {
+        return (Model::Haiku, "Performance vitals — metrics interpretation doesn't need deep reasoning");
+    }
+
+    // Deep complexity signals → Opus
+    if ctx.has_exception_chain {
+        return (Model::Opus, "Chained exception detected — multi-layer cause analysis requires the most capable model");
+    }
+    if ctx.stacktrace_frames > 30 {
+        return (Model::Opus, "Large stack trace — deep call-graph analysis benefits from extended reasoning");
+    }
+    if ctx.level == "error" && ctx.stacktrace_frames > 20 {
+        return (Model::Opus, "Critical error with complex stack — thorough root-cause reasoning selected");
+    }
+
+    // Simple signals → Haiku
+    if ctx.is_vitals || ctx.level == "info" {
+        return (Model::Haiku, "Info-level event — lightweight analysis is sufficient");
+    }
+    if ctx.stacktrace_frames < 5 {
+        return (Model::Haiku, "Short stack trace — fast model is sufficient for simple errors");
+    }
+    if ctx.event_count > 500 {
+        return (Model::Haiku, "High-frequency issue — well-known error pattern, fast analysis appropriate");
+    }
+
+    // Default: balanced Sonnet for standard production errors
+    (Model::Sonnet, "Standard production error — balanced model selected for accuracy and speed")
+}
+
+// ── Analysis result ───────────────────────────────────────────────────────────
 
 #[derive(Debug, Serialize, Deserialize)]
 pub struct AiAnalysis {
-    pub root_cause:     String,
-    pub explanation:    String,
-    pub fix_suggestion: String,
-    pub code_example:   Option<String>,
-    pub severity:       String,
-    pub prevention:     Option<String>,
-    pub model:          String,
+    pub root_cause:      String,
+    pub explanation:     String,
+    pub fix_suggestion:  String,
+    pub code_example:    Option<String>,
+    pub severity:        String,
+    pub prevention:      Option<String>,
+    pub model:           String,
+    pub model_auto:      bool,
+    pub model_reason:    Option<String>,
 }
 
-/// Analyse an error issue using Claude.
-/// `title`      — issue title / exception type
-/// `stacktrace` — formatted stack trace string
-/// `platform`   — e.g. "php", "javascript", "rust"
-/// `context`    — optional extra context JSON
+// ── API call ──────────────────────────────────────────────────────────────────
+
 pub async fn analyse_issue(
-    client: &Client,
-    api_key: &str,
-    title: &str,
+    client:     &Client,
+    api_key:    &str,
+    title:      &str,
     stacktrace: &str,
-    platform: &str,
-    context: Option<&str>,
+    platform:   &str,
+    context:    Option<&str>,
+    model:      &Model,
+    model_auto: bool,
+    model_reason: Option<&str>,
 ) -> Result<AiAnalysis, String> {
     let context_block = context
         .map(|c| format!("\n\n**Extra context:**\n```json\n{}\n```", c))
         .unwrap_or_default();
 
+    let depth_instruction = match model {
+        Model::Haiku  => "Be concise. One-sentence answers where possible.",
+        Model::Sonnet => "Be thorough but focused. 2–4 sentences per field.",
+        Model::Opus   => "Be comprehensive. Trace the full call path, explain all contributing factors, and provide production-ready fix code.",
+    };
+
     let prompt = format!(
         r#"You are a senior software engineer specializing in debugging production errors.
 
@@ -46,23 +143,25 @@ Analyze this error and respond with a JSON object (no markdown fences, raw JSON
 {stacktrace}
 ```{context_block}
 
+{depth_instruction}
+
 Respond with exactly this JSON structure:
 {{
   "root_cause": "one-sentence root cause",
-  "explanation": "2-4 sentences explaining what went wrong and why",
+  "explanation": "explanation of what went wrong and why",
   "fix_suggestion": "concise actionable fix instructions",
-  "code_example": "optional code snippet showing the fix, or null",
+  "code_example": "code snippet showing the fix, or null",
   "severity": "critical | high | medium | low",
-  "prevention": "optional tip to prevent this class of error in future, or null"
+  "prevention": "tip to prevent this class of error in future, or null"
 }}
 
 Be specific to the actual stack trace. Do not hallucinate file names or functions not present in the trace."#
     );
 
     let body = json!({
-        "model": MODEL,
-        "max_tokens": 1024,
-        "messages": [{ "role": "user", "content": prompt }]
+        "model":      model.api_id(),
+        "max_tokens": model.max_tokens(),
+        "messages":   [{ "role": "user", "content": prompt }]
     });
 
     let resp = client
@@ -89,7 +188,6 @@ Be specific to the actual stack trace. Do not hallucinate file names or function
         .and_then(|c| c["text"].as_str())
         .ok_or("empty response from Claude")?;
 
-    // Strip any accidental markdown code fences
     let clean = text
         .trim()
         .trim_start_matches("```json")
@@ -107,6 +205,8 @@ Be specific to the actual stack trace. Do not hallucinate file names or function
         code_example:   parsed["code_example"].as_str().map(String::from),
         severity:       parsed["severity"].as_str().unwrap_or("medium").to_string(),
         prevention:     parsed["prevention"].as_str().map(String::from),
-        model:          MODEL.to_string(),
+        model:          model.display_name().to_string(),
+        model_auto,
+        model_reason:   model_reason.map(String::from),
     })
 }