Update agents/agents.py

agents/agents.py

@@ -11,12 +11,12 @@ load_dotenv()
 openai_client = OpenAI(api_key=os.getenv("OPENAI_API_KEY")) if os.getenv("OPENAI_API_KEY") else None
 ELEVENLABS_API_KEY = os.getenv("ELEVENLABS_API_KEY")
 
+
 class TopicAgent:
     def generate_outline(self, topic, duration, difficulty):
         if not openai_client:
-            print("OpenAI API not set - using enhanced mock data for outline.")
             return self._mock_outline(topic, duration, difficulty)
-            
+
         try:
             response = openai_client.chat.completions.create(
                 model="gpt-4-turbo",
@@ -45,10 +45,9 @@ class TopicAgent:
                 response_format={"type": "json_object"}
             )
             return json.loads(response.choices[0].message.content)
-        except Exception as e:
-            print(f"Error generating outline with OpenAI: {e}. Using mock data.")
+        except Exception:
             return self._mock_outline(topic, duration, difficulty)
-    
+
     def _mock_outline(self, topic, duration, difficulty):
         return {
             "title": f"Mastering {topic} for Business Impact",
@@ -92,12 +91,12 @@ class TopicAgent:
             ]
         }
 
+
 class ContentAgent:
     def generate_content(self, outline):
         if not openai_client:
-            print("OpenAI API not set - using enhanced mock data for content.")
             return self._mock_content(outline)
-            
+
         try:
             response = openai_client.chat.completions.create(
                 model="gpt-4-turbo",
@@ -125,14 +124,13 @@ class ContentAgent:
                     }
                 ],
                 temperature=0.4,
-                max_tokens=4000,
+                max_tokens=3000,
                 response_format={"type": "json_object"}
             )
             return json.loads(response.choices[0].message.content)
-        except Exception as e:
-            print(f"Error generating content with OpenAI: {e}. Using mock data.")
+        except Exception:
             return self._mock_content(outline)
-    
+
     def _mock_content(self, outline):
         return {
             "workshop_title": outline.get("title", "Premium AI Workshop"),
@@ -174,12 +172,12 @@ class ContentAgent:
             ]
         }
 
+
 class SlideAgent:
     def generate_slides(self, content):
         if not openai_client:
-            print("OpenAI API not set - using enhanced mock data for slides.")
             return self._professional_slides(content)
-            
+
         try:
             response = openai_client.chat.completions.create(
                 model="gpt-4-turbo",
@@ -206,10 +204,9 @@ class SlideAgent:
                 max_tokens=2500
             )
             return response.choices[0].message.content
-        except Exception as e:
-            print(f"Error generating slides with OpenAI: {e}. Using mock data.")
+        except Exception:
             return self._professional_slides(content)
-    
+
     def _professional_slides(self, content):
         return f"""---
 marp: true
@@ -251,170 +248,160 @@ graph TD
     A[Current Costs] --> B[Potential Savings]
     C[Implementation Costs] --> D[Net ROI]
     B --> D
-Use code with caution.
-Python
 Document current process costs
+
 Estimate efficiency gains
+
 Calculate net ROI
-Q&A: Let's discuss your specific challenges
-"""
+
+Q&A
+Let's discuss your specific challenges
+```"""
+
+
 class CodeAgent:
-def generate_code(self, content):
-if not openai_client:
-print("OpenAI API not set - using enhanced mock data for code.")
-return self._professional_code(content)
-Generated code
-try:
-        response = openai_client.chat.completions.create(
-            model="gpt-4-turbo",
-            messages=[
-                {
-                    "role": "system",
-                    "content": (
-                        "You are an enterprise solutions architect. Create professional-grade code labs with: "
-                        "1) Production-ready patterns 2) Comprehensive documentation "
-                        "3) Enterprise security practices 4) Scalable architectures. "
-                        "Use Python with the latest best practices."
-                    )
-                },
-                {
-                    "role": "user",
-                    "content": (
-                        f"Create a professional code lab for: {json.dumps(content)}. "
-                        "Include: Setup instructions, business solution patterns, "
-                        "enterprise integration examples, and security best practices."
-                    )
-                }
-            ],
-            temperature=0.3,
-            max_tokens=2500
-        )
-        return response.choices[0].message.content
-    except Exception as e:
-        print(f"Error generating code with OpenAI: {e}. Using mock data.")
-        return self._professional_code(content)
-
-def _professional_code(self, content):
-    return """
-Use code with caution.
---- Enterprise-Grade Prompt Engineering Lab ---
---- Business Solution Framework ---
+    def generate_code(self, content):
+        if not openai_client:
+            return self._professional_code(content)
+
+        try:
+            response = openai_client.chat.completions.create(
+                model="gpt-4-turbo",
+                messages=[
+                    {
+                        "role": "system",
+                        "content": (
+                            "You are an enterprise solutions architect. Create professional-grade code labs with: "
+                            "1) Production-ready patterns 2) Comprehensive documentation "
+                            "3) Enterprise security practices 4) Scalable architectures. "
+                            "Use Python with the latest best practices."
+                        )
+                    },
+                    {
+                        "role": "user",
+                        "content": (
+                            f"Create a professional code lab for: {json.dumps(content)}. "
+                            "Include: Setup instructions, business solution patterns, "
+                            "enterprise integration examples, and security best practices."
+                        )
+                    }
+                ],
+                temperature=0.3,
+                max_tokens=2500
+            )
+            return response.choices[0].message.content
+        except Exception:
+            return self._professional_code(content)
+
+    def _professional_code(self, content):
+        return f"""# Enterprise-Grade Prompt Engineering Lab
+Business Solution Framework
+python
 class PromptOptimizer:
-"""A class to optimize prompts and calculate ROI."""
-def init(self, model="gpt-4-turbo"):
-self.model = model
-self.pattern_library = {
-"financial_analysis": "Extract key metrics from financial reports",
-"customer_service": "Resolve tier-2 support tickets"
-}
-Generated code
-def optimize_prompt(self, business_case):
-    \"\"\"Implement enterprise optimization logic.\"\"\"
-    return f"Business-optimized prompt for {business_case}"
-
-def calculate_roi(self, current_cost, expected_efficiency):
-    \"\"\"Calculate ROI based on cost and efficiency gain.\"\"\"
-    return current_cost * expected_efficiency
-Use code with caution.
---- Security Best Practices ---
-def _sanitize_input(user_input):
-"""Placeholder for input sanitization logic."""
-# In a real implementation, use a library like bleach to prevent XSS
-return user_input
-def _validate_business_context(sanitized_input):
-"""Placeholder for validating input against business rules."""
-return True
-def _apply_enterprise_guardrails(sanitized_input):
-"""Placeholder for applying enterprise-level safety guardrails."""
-return sanitized_input
+    def __init__(self, model="gpt-4-turbo"):
+        self.model = model
+        self.pattern_library = {{
+            "financial_analysis": "Extract key metrics from financial reports",
+            "customer_service": "Resolve tier-2 support tickets"
+        }}
+    
+    def optimize_prompt(self, business_case):
+        # Implement enterprise optimization logic
+        return f"Business-optimized prompt for {{business_case}}"
+    
+    def calculate_roi(self, current_cost, expected_efficiency):
+        return current_cost * expected_efficiency
+
+# Example usage
+optimizer = PromptOptimizer()
+print(optimizer.calculate_roi(500000, 0.35))  # $175,000 savings
+
+Security Best Practices
+python
 def secure_prompt_handling(user_input):
-"""Implement OWASP security standards for prompt handling."""
-sanitized = _sanitize_input(user_input)
-if _validate_business_context(sanitized):
-return _apply_enterprise_guardrails(sanitized)
-raise ValueError("Input failed business context validation.")
---- Integration Pattern: CRM System ---
-def _call_ai_api(enriched_prompt):
-"""Placeholder for the actual AI API call."""
-return f"AI Response for: {enriched_prompt}"
+    # Implement OWASP security standards
+    sanitized = sanitize_input(user_input)
+    validate_business_context(sanitized)
+    return apply_enterprise_guardrails(sanitized)
+
+Integration Pattern: CRM System
+python
 def integrate_with_salesforce(prompt, salesforce_data):
-"""Enterprise integration example with a CRM."""
-enriched_prompt = f"{prompt} using data: {salesforce_data}"
-return _call_ai_api(enriched_prompt)
+    # Enterprise integration example
+    enriched_prompt = f"{{prompt}} using {{salesforce_data}}"
+    return call_ai_api(enriched_prompt)
 """
+
+
 class DesignAgent:
-def generate_design(self, slide_content):
-if not openai_client:
-print("OpenAI API not set - skipping design generation.")
-return None
-Generated code
-try:
-        response = openai_client.images.generate(
-            model="dall-e-3",
-            prompt=(
-                f"Professional corporate slide background for '{slide_content[:200]}' workshop. "
-                "Modern business style, clean lines, premium gradient, boardroom appropriate. "
-                "Include abstract technology elements in corporate colors."
-            ),
-            n=1,
-            size="1024x1024"
-        )
-        return response.data[0].url
-    except Exception as e:
-        print(f"Error generating design with OpenAI: {e}. Skipping design generation.")
-        return None
-Use code with caution.
+    def generate_design(self, slide_content):
+        if not openai_client:
+            return None
+
+        try:
+            response = openai_client.images.generate(
+                model="dall-e-3",
+                prompt=(
+                    f"Professional corporate slide background for '{slide_content[:200]}' workshop. "
+                    "Modern business style, clean lines, premium gradient, boardroom appropriate. "
+                    "Include abstract technology elements in corporate colors."
+                ),
+                n=1,
+                size="1024x1024"
+            )
+            return response.data[0].url
+        except Exception:
+            return None
+
+
 class VoiceoverAgent:
-def init(self):
-self.api_key = ELEVENLABS_API_KEY
-self.voice_id = "21m00Tcm4TlvDq8ikWAM" # Default voice ID for "Rachel"
-self.model = "eleven_monolingual_v1"
-Generated code
-def generate_voiceover(self, text, voice_id=None):
-    if not self.api_key:
-        print("ElevenLabs API key not set - skipping voiceover generation.")
-        return None
-        
-    try:
-        voice = voice_id if voice_id else self.voice_id
-        
-        url = f"https://api.elevenlabs.io/v1/text-to-speech/{voice}"
-        headers = {
-            "Accept": "audio/mpeg",
-            "Content-Type": "application/json",
-            "xi-api-key": self.api_key
-        }
-        data = {
-            "text": text,
-            "model_id": self.model,
-            "voice_settings": {
-                "stability": 0.7,
-                "similarity_boost": 0.8,
-                "style": 0.5,
-                "use_speaker_boost": True
+    def __init__(self):
+        self.api_key = ELEVENLABS_API_KEY
+        self.voice_id = "21m00Tcm4TlvDq8ikWAM"  # Default voice ID
+        self.model = "eleven_monolingual_v1"
+
+    def generate_voiceover(self, text, voice_id=None):
+        if not self.api_key:
+            return None
+
+        try:
+            voice = voice_id if voice_id else self.voice_id
+
+            url = f"https://api.elevenlabs.io/v1/text-to-speech/{voice}"
+            headers = {
+                "Accept": "audio/mpeg",
+                "Content-Type": "application/json",
+                "xi-api-key": self.api_key
             }
-        }
-        response = requests.post(url, json=data, headers=headers)
-        response.raise_for_status()  # Raise an exception for bad status codes
-        return response.content
-
-    except requests.exceptions.RequestException as e:
-        print(f"Error generating voiceover with ElevenLabs: {e}")
-        return None
-
-def get_voices(self):
-    if not self.api_key:
-        print("ElevenLabs API key not set - cannot fetch voices.")
-        return []
-        
-    try:
-        url = "https://api.elevenlabs.io/v1/voices"
-        headers = {"xi-api-key": self.api_key}
-        response = requests.get(url, headers=headers)
-        response.raise_for_status()
-        return response.json().get("voices", [])
-    
-    except requests.exceptions.RequestException as e:
-        print(f"Error fetching voices from ElevenLabs: {e}")
-        return []
-        
+            data = {
+                "text": text,
+                "model_id": self.model,
+                "voice_settings": {
+                    "stability": 0.7,
+                    "similarity_boost": 0.8,
+                    "style": 0.5,
+                    "use_speaker_boost": True
+                }
+            }
+            response = requests.post(url, json=data, headers=headers)
+
+            if response.status_code == 200:
+                return response.content
+            return None
+        except Exception:
+            return None
+
+    def get_voices(self):
+        if not self.api_key:
+            return []
+
+        try:
+            url = "https://api.elevenlabs.io/v1/voices"
+            headers = {"xi-api-key": self.api_key}
+            response = requests.get(url, headers=headers)
+
+            if response.status_code == 200:
+                return response.json().get("voices", [])
+            return []
+        except Exception:
+            return []