Update teacher.py

teacher.py

@@ -1,125 +1,140 @@
-"""Teacher Model - Calls OpenRouter API for knowledge distillation"""
-
 import requests
-import json
-from typing import Optional, Dict, Any, List
+from typing import List, Dict, Optional
+
 from config import (
     OPENROUTER_API_KEY,
     OPENROUTER_BASE_URL,
     TEACHER_MODEL,
+    TEACHER_FALLBACK_MODELS,
     TEACHER_TEMPERATURE,
     TEACHER_MAX_TOKENS,
 )
 
-
 class TeacherModel:
-    """Wrapper for the OpenRouter teacher model (Dolphin Mistral)"""
+    """
+    OpenRouter teacher client with:
+    - Primary model
+    - Fallback models
+    - Detailed error logging
+    """
 
     def __init__(self):
         self.api_key = OPENROUTER_API_KEY
         self.base_url = OPENROUTER_BASE_URL
-        self.model = TEACHER_MODEL
-        self.headers = {
+        self.session = requests.Session()
+
+        self.last_status_code: Optional[int] = None
+        self.last_error: str = ""
+        self.last_model_tried: str = ""
+        self.last_response_text: str = ""
+
+    def is_available(self) -> bool:
+        return bool(self.api_key)
+
+    def _call_model(
+        self,
+        model_id: str,
+        messages: List[Dict],
+        temperature: float,
+        max_tokens: int
+    ) -> Optional[str]:
+
+        headers = {
             "Content-Type": "application/json",
             "Authorization": f"Bearer {self.api_key}",
+            "Accept": "application/json",
+            # recommended by OpenRouter
             "HTTP-Referer": "https://huggingface.co/spaces/vedaco/veda-programming",
             "X-Title": "Veda Programming Assistant",
         }
 
+        payload = {
+            "model": model_id,
+            "messages": messages,
+            "temperature": float(temperature),
+            "max_tokens": int(max_tokens),
+            "stream": False
+        }
+
+        r = self.session.post(self.base_url, headers=headers, json=payload, timeout=60)
+
+        self.last_status_code = r.status_code
+        self.last_response_text = r.text[:2000]
+
+        if r.status_code != 200:
+            try:
+                err = r.json()
+            except Exception:
+                err = {"raw": r.text}
+
+            self.last_error = f"HTTP {r.status_code}: {err}"
+            return None
+
+        data = r.json()
+        if "error" in data:
+            self.last_error = f"OpenRouter error field: {data['error']}"
+            return None
+
+        choices = data.get("choices") or []
+        if not choices:
+            self.last_error = f"No choices in response: {data}"
+            return None
+
+        msg = choices[0].get("message") or {}
+        content = msg.get("content", "")
+
+        if not content:
+            self.last_error = f"Empty content: {data}"
+            return None
+
+        self.last_error = ""
+        return content
+
     def ask(
         self,
         user_message: str,
-        conversation_history: List[Dict[str, str]] = None,
+        conversation_history: Optional[List[Dict[str, str]]] = None,
         temperature: float = None,
-        max_tokens: int = None,
+        max_tokens: int = None
     ) -> Optional[str]:
-        """
-        Ask the teacher model a question.
-        
-        Args:
-            user_message: The user's question
-            conversation_history: Previous messages [{"role": "user/assistant", "content": "..."}]
-            temperature: Sampling temperature
-            max_tokens: Maximum tokens to generate
-            
-        Returns:
-            Teacher's response as string, or None if error
-        """
-        if not self.api_key or self.api_key == "":
-            print("Warning: No OpenRouter API key configured")
+
+        if not self.is_available():
+            self.last_error = "OPENROUTER_API_KEY missing"
+            print("[Teacher] Missing OPENROUTER_API_KEY")
             return None
 
-        temperature = temperature or TEACHER_TEMPERATURE
-        max_tokens = max_tokens or TEACHER_MAX_TOKENS
-
-        # Build messages
-        messages = []
-        
-        # System prompt to make teacher respond like a programming assistant
-        messages.append({
-            "role": "system",
-            "content": """You are a helpful programming assistant. You help users with:
-- Writing Python code
-- Explaining programming concepts
-- Debugging code
-- Answering questions about algorithms and data structures
-
-Be clear, concise, and provide code examples when helpful.
-Format code blocks with ```python and ```.
-"""
-        })
-
-        # Add conversation history
+        temperature = TEACHER_TEMPERATURE if temperature is None else float(temperature)
+        max_tokens = TEACHER_MAX_TOKENS if max_tokens is None else int(max_tokens)
+
+        messages = [
+            {
+                "role": "system",
+                "content": (
+                    "You are a helpful programming assistant. "
+                    "Answer clearly. When asked to write code, output correct Python code. "
+                    "Use markdown code blocks like ```python ... ```."
+                )
+            }
+        ]
+
         if conversation_history:
-            for msg in conversation_history[-6:]:  # Last 6 messages for context
-                messages.append({
-                    "role": msg.get("role", "user"),
-                    "content": msg.get("content", "")
-                })
-
-        # Add current user message
-        messages.append({
-            "role": "user",
-            "content": user_message
-        })
+            for m in conversation_history[-10:]:
+                role = m.get("role", "user")
+                content = m.get("content", "")
+                if content:
+                    messages.append({"role": role, "content": content})
 
-        payload = {
-            "model": self.model,
-            "messages": messages,
-            "temperature": temperature,
-            "max_tokens": max_tokens,
-        }
+        messages.append({"role": "user", "content": user_message})
 
-        try:
-            response = requests.post(
-                self.base_url,
-                headers=self.headers,
-                json=payload,
-                timeout=60
-            )
-
-            if response.status_code == 200:
-                data = response.json()
-                if "choices" in data and len(data["choices"]) > 0:
-                    return data["choices"][0]["message"]["content"]
-                else:
-                    print(f"Teacher API unexpected response: {data}")
-                    return None
-            else:
-                print(f"Teacher API error: {response.status_code} - {response.text}")
-                return None
-
-        except requests.exceptions.Timeout:
-            print("Teacher API timeout")
-            return None
-        except Exception as e:
-            print(f"Teacher API exception: {e}")
-            return None
+        candidates = [TEACHER_MODEL] + list(TEACHER_FALLBACK_MODELS)
 
-    def is_available(self) -> bool:
-        """Check if teacher API is available"""
-        return bool(self.api_key and self.api_key != "")
+        for model_id in candidates:
+            self.last_model_tried = model_id
+            out = self._call_model(model_id, messages, temperature, max_tokens)
+            if out:
+                return out
+            print(f"[Teacher] Failed model {model_id}: {self.last_error}")
 
+        return None
 
-# Global teacher instance
 teacher = TeacherModel()