Update llm/llm_openai.py

llm/llm_openai.py

@@ -1,104 +1,104 @@
-"""
-OpenAI GPT Implementation
-"""
-import os
-import openai
-from typing import Dict, List, Any
-from llm_interface import LLMInterface
-from utils.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)
+"""
+OpenAI GPT Implementation
+"""
+import os
+import openai
+from typing import Dict, List, Any
+from .llm_interface import LLMInterface
+from utils.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)
         }