Delete llm_openai.py

llm_openai.py

@@ -1,104 +0,0 @@
-"""
-OpenAI GPT Implementation
-"""
-import os
-import openai
-from typing import Dict, List, Any
-from llm_interface import LLMInterface
-from logger import log_info, log_error, log_warning, log_debug, LogTimer
-
-DEFAULT_LLM_TIMEOUT = int(os.getenv("LLM_TIMEOUT_SECONDS", "60"))
-MAX_RESPONSE_LENGTH = 4096  # Max response length
-
-class OpenAILLM(LLMInterface):
-    """OpenAI GPT integration with improved error handling"""
-    
-    def __init__(self, api_key: str, model: str = "gpt-4", settings: Dict[str, Any] = None):
-        super().__init__(settings)
-        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 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:
-            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 unexpected error", error=str(e))
-            raise
-    
-    async def startup(self, project_config: Dict) -> bool:
-        """OpenAI doesn't need startup"""
-        log_info("OpenAI startup called (no-op)")
-        return True
-    
-    def get_provider_name(self) -> str:
-        return f"openai-{self.model}"
-    
-    def get_model_info(self) -> Dict[str, Any]:
-        return {
-            "provider": "openai",
-            "model": self.model,
-            "max_tokens": self.settings.get("max_tokens", 2048),
-            "temperature": self.settings.get("temperature", 0.7)
-        }