Update llm_interface.py

llm_interface.py

@@ -12,7 +12,7 @@ class LLMInterface(ABC):
     """Abstract base class for LLM providers"""
     
     def __init__(self, settings: Dict[str, Any] = None):
-        """Initialize with settings"""
+        """Initialize with provider settings"""
         self.settings = settings or {}
         self.internal_prompt = self.settings.get("internal_prompt", "")
         self.parameter_collection_config = self.settings.get("parameter_collection_config", {})
@@ -28,9 +28,9 @@ class LLMInterface(ABC):
         pass
 
 class SparkLLM(LLMInterface):
-    """Spark integration for HuggingFace"""
+    """Spark LLM integration"""
     
-    def __init__(self, spark_endpoint: str, spark_token: str, provider_variant: str = "spark-cloud", settings: Dict[str, Any] = None):
+    def __init__(self, spark_endpoint: str, spark_token: str, provider_variant: str = "cloud", settings: Dict[str, Any] = None):
         super().__init__(settings)
         self.spark_endpoint = spark_endpoint.rstrip("/")
         self.spark_token = spark_token
@@ -38,12 +38,13 @@ class SparkLLM(LLMInterface):
         log(f"🔌 SparkLLM initialized with endpoint: {self.spark_endpoint}")
     
     async def generate(self, system_prompt: str, user_input: str, context: List[Dict]) -> str:
-        """Generate response using Spark"""
+        """Generate response from Spark LLM"""
         headers = {
             "Authorization": f"Bearer {self.spark_token}",
             "Content-Type": "application/json"
         }
         
+        # Build payload
         payload = {
             "system_prompt": system_prompt,
             "user_input": user_input,
@@ -72,8 +73,40 @@ class SparkLLM(LLMInterface):
     
     async def startup(self, project_config: Dict) -> bool:
         """Send startup request to Spark"""
-        # Implement if needed for Spark startup notification
-        return True
+        headers = {
+            "Authorization": f"Bearer {self.spark_token}",
+            "Content-Type": "application/json"
+        }
+        
+        # Extract required fields from project config
+        body = {
+            "work_mode": self.provider_variant,
+            "cloud_token": self.spark_token,
+            "project_name": project_config.get("name"),
+            "project_version": project_config.get("version_id"),
+            "repo_id": project_config.get("repo_id"),
+            "generation_config": project_config.get("generation_config", {}),
+            "use_fine_tune": project_config.get("use_fine_tune", False),
+            "fine_tune_zip": project_config.get("fine_tune_zip", "")
+        }
+        
+        try:
+            async with httpx.AsyncClient(timeout=10) as client:
+                response = await client.post(
+                    f"{self.spark_endpoint}/startup",
+                    json=body,
+                    headers=headers
+                )
+                
+                if response.status_code >= 400:
+                    log(f"❌ Spark startup failed: {response.status_code} - {response.text}")
+                    return False
+                
+                log(f"✅ Spark acknowledged startup ({response.status_code})")
+                return True
+        except Exception as e:
+            log(f"⚠️ Spark startup error: {e}")
+            return False
 
 class GPT4oLLM(LLMInterface):
     """OpenAI GPT integration"""
@@ -81,17 +114,25 @@ class GPT4oLLM(LLMInterface):
     def __init__(self, api_key: str, model: str = "gpt-4o-mini", settings: Dict[str, Any] = None):
         super().__init__(settings)
         self.api_key = api_key
-        self.model = model
+        self.model = self._map_model_name(model)
         self.client = AsyncOpenAI(api_key=api_key)
         
-        # Extract settings
+        # Extract model-specific settings
         self.temperature = settings.get("temperature", 0.7) if settings else 0.7
         self.max_tokens = settings.get("max_tokens", 4096) if settings else 4096
         
-        log(f"✅ Initialized GPT LLM with model: {model}")
+        log(f"✅ Initialized GPT LLM with model: {self.model}")
+    
+    def _map_model_name(self, model: str) -> str:
+        """Map provider name to actual model name"""
+        mappings = {
+            "gpt4o": "gpt-4",
+            "gpt4o-mini": "gpt-4o-mini"
+        }
+        return mappings.get(model, model)
     
     async def generate(self, system_prompt: str, user_input: str, context: List[Dict]) -> str:
-        """Generate response using OpenAI GPT"""
+        """Generate response from OpenAI"""
         try:
             # Build messages
             messages = [{"role": "system", "content": system_prompt}]
@@ -106,7 +147,7 @@ class GPT4oLLM(LLMInterface):
             # Add current user input
             messages.append({"role": "user", "content": user_input})
             
-            # Generate response
+            # Call OpenAI
             response = await self.client.chat.completions.create(
                 model=self.model,
                 messages=messages,
@@ -115,18 +156,11 @@ class GPT4oLLM(LLMInterface):
             )
             
             return response.choices[0].message.content.strip()
-            
         except Exception as e:
-            log(f"❌ GPT error: {e}")
+            log(f"❌ OpenAI error: {e}")
             raise
     
     async def startup(self, project_config: Dict) -> bool:
-        """Validate API key"""
-        try:
-            # Test API key with a simple request
-            response = await self.client.models.list()
-            log(f"✅ OpenAI API key validated, available models: {len(response.data)}")
-            return True
-        except Exception as e:
-            log(f"❌ Invalid OpenAI API key: {e}")
-            return False
+        """GPT doesn't need startup, always return True"""
+        log("✅ GPT provider ready (no startup needed)")
+        return True