Update llm_openai.py

llm_openai.py

@@ -1,73 +1,100 @@
 """
 OpenAI GPT Implementation
 """
-from openai import AsyncOpenAI
+import openai
 from typing import Dict, List, Any
 from llm_interface import LLMInterface
 from logger import log_info, log_error, log_warning, log_debug
 
 class OpenAILLM(LLMInterface):
-    """OpenAI GPT integration (GPT-4o, GPT-4o-mini)"""
+    """OpenAI GPT integration with improved error handling"""
     
-    def __init__(self, api_key: str, model: str, settings: Dict[str, Any] = None):
+    def __init__(self, api_key: str, model: str = "gpt-4", settings: Dict[str, Any] = None):
         super().__init__(settings)
-        self.client = AsyncOpenAI(api_key=api_key)
-        self.model = self._map_model_name(model)
-        self.temperature = settings.get("temperature", 0.7) if settings else 0.7
-        self.max_tokens = settings.get("max_tokens", 1000) if settings else 1000
-        log_info(f"🤖 Initialized OpenAI 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)
+        self.api_key = api_key
+        self.model = model
+        self.timeout = self.settings.get("timeout", DEFAULT_LLM_TIMEOUT)
+        openai.api_key = api_key
+        log_info(f"🔌 OpenAI LLM initialized", model=self.model, timeout=self.timeout)
     
     async def generate(self, system_prompt: str, user_input: str, context: List[Dict]) -> str:
-        """Generate response from OpenAI"""
+        """Generate response with consistent error handling"""
+        
+        # Build messages
+        messages = []
+        if system_prompt:
+            messages.append({"role": "system", "content": system_prompt})
+        
+        # Add context
+        for msg in context[-10:]:  # Last 10 messages
+            role = "assistant" if msg.get("role") == "assistant" else "user"
+            messages.append({"role": role, "content": msg.get("content", "")})
+        
+        # Add current input
+        messages.append({"role": "user", "content": user_input})
+        
         try:
-            # Build messages
-            messages = [{"role": "system", "content": system_prompt}]
-            
-            # Add context
-            for msg in context:
-                messages.append({
-                    "role": msg.get("role", "user"),
-                    "content": msg.get("content", "")
-                })
-            
-            # Add current user input
-            messages.append({"role": "user", "content": user_input})
-            
-            # Call OpenAI
-            response = await self.client.chat.completions.create(
-                model=self.model,
-                messages=messages,
-                temperature=self.temperature,
-                max_tokens=self.max_tokens
-            )
-            
-            return response.choices[0].message.content.strip()
+            with LogTimer(f"OpenAI {self.model} request"):
+                # Use async client
+                client = openai.AsyncOpenAI(
+                    api_key=self.api_key,
+                    timeout=self.timeout
+                )
+                
+                response = await client.chat.completions.create(
+                    model=self.model,
+                    messages=messages,
+                    max_tokens=self.settings.get("max_tokens", 2048),
+                    temperature=self.settings.get("temperature", 0.7),
+                    stream=False
+                )
+                
+                # Extract content
+                content = response.choices[0].message.content
+                
+                # Check length
+                if len(content) > MAX_RESPONSE_LENGTH:
+                    log_warning(f"Response exceeded max length, truncating",
+                              original_length=len(content),
+                              max_length=MAX_RESPONSE_LENGTH)
+                    content = content[:MAX_RESPONSE_LENGTH] + "..."
+                
+                # Log token usage
+                if response.usage:
+                    log_info(f"Token usage",
+                           prompt_tokens=response.usage.prompt_tokens,
+                           completion_tokens=response.usage.completion_tokens,
+                           total_tokens=response.usage.total_tokens)
+                
+                return content
+                
+        except openai.RateLimitError as e:
+            log_warning("OpenAI rate limit", error=str(e))
+            raise
+        except openai.APITimeoutError as e:
+            log_error("OpenAI timeout", error=str(e))
+            raise
+        except openai.APIError as e:
+            log_error("OpenAI API error", 
+                     status_code=e.status_code if hasattr(e, 'status_code') else None,
+                     error=str(e))
+            raise
         except Exception as e:
-            log_error("❌ OpenAI error", e)
+            log_error("OpenAI unexpected error", error=str(e))
             raise
     
     async def startup(self, project_config: Dict) -> bool:
-        """GPT doesn't need startup, always return True"""
-        log_info("✅ GPT provider ready (no startup needed)")
+        """OpenAI doesn't need startup"""
+        log_info("OpenAI startup called (no-op)")
         return True
     
     def get_provider_name(self) -> str:
-        """Get provider name"""
-        return self.model
+        return f"openai-{self.model}"
     
     def get_model_info(self) -> Dict[str, Any]:
-        """Get model information"""
         return {
             "provider": "openai",
             "model": self.model,
-            "temperature": self.temperature,
-            "max_tokens": self.max_tokens
+            "max_tokens": self.settings.get("max_tokens", 2048),
+            "temperature": self.settings.get("temperature", 0.7)
         }