Update llm_interface.py

llm_interface.py

@@ -24,9 +24,12 @@ class LLMInterface(ABC):
 class SparkLLM(LLMInterface):
     """Existing Spark integration"""
     
-    def __init__(self, spark_endpoint: str, spark_token: str):
+
+    def __init__(self, spark_endpoint: str, spark_token: str, work_mode: str = "cloud"):
         self.spark_endpoint = spark_endpoint.rstrip("/")
         self.spark_token = spark_token
+        self.work_mode = work_mode
+        log(f"🔌 SparkLLM initialized with endpoint: {self.spark_endpoint}")
     
     async def generate(self, system_prompt: str, user_input: str, context: List[Dict]) -> str:
         headers = {
@@ -74,49 +77,50 @@ class GPT4oLLM(LLMInterface):
         self.client = AsyncOpenAI(api_key=api_key)
         log(f"✅ Initialized GPT LLM with model: {model}")
     
-    async def generate(self, system_prompt: str, user_input: str, context: List[Dict]) -> str:
+    async def generate(self, project_name: str, user_input: str, system_prompt: str, context: List[Dict], version_config: Dict = None) -> str:
+        """Generate response from LLM with project context"""
+        headers = {
+            "Authorization": f"Bearer {self.spark_token}",
+            "Content-Type": "application/json"
+        }
+        
+        # Build payload with all required fields for Spark
+        payload = {
+            "work_mode": self.work_mode,
+            "cloud_token": self.spark_token,
+            "project_name": project_name,
+            "system_prompt": system_prompt,
+            "user_input": user_input,
+            "context": context
+        }
+        
+        # Add version-specific config if available
+        if version_config:
+            llm_config = version_config.get("llm", {})
+            payload.update({
+                "project_version": version_config.get("version_id"),
+                "repo_id": llm_config.get("repo_id"),
+                "generation_config": llm_config.get("generation_config"),
+                "use_fine_tune": llm_config.get("use_fine_tune"),
+                "fine_tune_zip": llm_config.get("fine_tune_zip")
+            })
+        
         try:
-            # Convert context to OpenAI format
-            messages = []
-            
-            # Add system prompt
-            messages.append({"role": "system", "content": system_prompt})
-            
-            # Debug log - context kontrolü
-            log(f"📝 GPT Context length: {len(context)}")
-            log(f"📝 Last 2 context messages: {context[-2:] if len(context) >= 2 else context}")
-            
-            # Add conversation history
-            for msg in context[-10:]:  # Last 10 messages
-                role = "user" if msg["role"] == "user" else "assistant"
-                messages.append({"role": role, "content": msg["content"]})
-            
-            # Add current user input
-            messages.append({"role": "user", "content": user_input})
-            
-            # Debug log - final messages
-            log(f"📝 Total messages to GPT: {len(messages)}")
-            log(f"📝 System prompt preview: {system_prompt[:100]}...")
-            
-            # Call OpenAI API
-            response = await self.client.chat.completions.create(
-                model=self.model,
-                messages=messages,
-                temperature=0.3,  # Low temperature for consistency
-                max_tokens=150   # Düşürüldü (önceden 512)
-            )
-            
-            content = response.choices[0].message.content.strip()
-            log(f"🪄 GPT response (first 120 chars): {content[:120]}")
-            
-            # Log token usage for cost tracking
-            if response.usage:
-                log(f"📊 Tokens used - Input: {response.usage.prompt_tokens}, Output: {response.usage.completion_tokens}")
-            
-            return content
-            
+            log(f"📤 Spark request payload keys: {list(payload.keys())}")
+            async with httpx.AsyncClient(timeout=60) as client:
+                response = await client.post(
+                    f"{self.spark_endpoint}/generate",
+                    json=payload,
+                    headers=headers
+                )
+                response.raise_for_status()
+                data = response.json()
+                return data.get("model_answer", data.get("assistant", data.get("text", "")))
+        except httpx.TimeoutException:
+            log("⏱️ Spark timeout")
+            raise
         except Exception as e:
-            log(f"❌ GPT error: {e}")
+            log(f"❌ Spark error: {str(e)}")
             raise
     
     async def startup(self, project_config: Dict) -> bool: