Update app.py

app.py

@@ -16,6 +16,9 @@ from botbuilder.schema import Activity, ActivityTypes
 from bot import MyBot
 from config import DefaultConfig
 from ai_core import AICore
+from aegis_integration import AegisBridge
+from aegis_integration.config import AEGIS_CONFIG
+from aegis_integration.routes import register_aegis_endpoints
 import numpy as np
 import logging
 from typing import Dict, Any, Tuple
@@ -26,42 +29,85 @@ logger = logging.getLogger(__name__)
 
 CONFIG = DefaultConfig()
 
-# Initialize AI Core
+# Initialize AI Core and AEGIS
 ai_core = AICore()
+aegis_bridge = AegisBridge(ai_core, AEGIS_CONFIG)
+ai_core.set_aegis_bridge(aegis_bridge)
+
+# Force fallback to gpt2 for text generation
+ai_core.model_id = 'gpt2'
 
 # Bot Framework Setup
 SETTINGS = BotFrameworkAdapterSettings(CONFIG.APP_ID, CONFIG.APP_PASSWORD)
 ADAPTER = BotFrameworkAdapter(SETTINGS)
 
+# Create Gradio interface with AEGIS integration
+app = gr.Interface(
+    fn=lambda x: ai_core.generate_text(x),
+    inputs="text",
+    outputs=[
+        gr.Textbox(label="Response"),
+        gr.JSON(label="AEGIS Analysis", visible=True)
+    ],
+    title="Codette with AEGIS",
+    description="An ethical AI assistant enhanced with AEGIS analysis"
+)
+
 class CodetteGradioApp:
     def __init__(self, ai_core: AICore):
         self.ai_core = ai_core
         self.chat_history = []
     
-    def process_message(self, message: str, history: list) -> Tuple[str, list]:
-        """Process a message and update chat history"""
+    def process_message(self, message: str, history: list, cocoon_mode: bool = False) -> Tuple[str, list]:
+        """Process a message and update chat history, with optional cocoon-powered creativity"""
         try:
-            # Generate response
-            response = self.ai_core.generate_text(message)
-            
-            # Analyze sentiment
-            sentiment = self.ai_core.analyze_sentiment(message)
-            sentiment_info = f"\n[Sentiment: {sentiment['label']} ({sentiment['score']:.2f})]"
-            
-            # Update history
-            history.append((message, response + sentiment_info))
+            # Generate response (cocoon-powered if enabled)
+            if cocoon_mode:
+                # Ensure cocoons are loaded
+                if not hasattr(self.ai_core, 'cocoon_data') or not self.ai_core.cocoon_data:
+                    self.ai_core.load_cocoon_data()
+                response = self.ai_core.remix_and_randomize_response(message, cocoon_mode=True)
+            else:
+                response = self.ai_core.generate_text(message)
+            try:
+                # Analyze sentiment
+                sentiment = self.ai_core.analyze_sentiment(message)
+                label = sentiment.get('label', '').upper()
+                score = sentiment.get('score', 0.0)
+                # Use transformers to generate a unique, sentiment-aware reply
+                if label == 'POS':
+                    prompt = f"The user said something positive: '{message}'. Respond in a cheerful, encouraging, and unique way."
+                elif label == 'NEG':
+                    prompt = f"The user said something negative: '{message}'. Respond with empathy, support, and a unique comforting message."
+                elif label == 'NEU':
+                    prompt = f"The user said something neutral: '{message}'. Respond in a thoughtful, neutral, and unique way."
+                else:
+                    prompt = f"The user's sentiment is unclear: '{message}'. Respond in a curious, open-minded, and unique way."
+                char_response = self.ai_core.generate_text(prompt, max_length=60)
+                sentiment_info = f"\n[Sentiment: {label} ({score:.2f})] {char_response}"
+            except Exception as sent_e:
+                logger.error(f"Sentiment analysis error: {sent_e}")
+                sentiment_info = "\n[Sentiment: error (0.00)] 🤖 Sorry, I couldn't analyze the sentiment."
+            # Update history in Gradio 'messages' format
+            history = history + [
+                {"role": "user", "content": message},
+                {"role": "assistant", "content": response + sentiment_info}
+            ]
             return "", history
-            
         except Exception as e:
             logger.error(f"Error processing message: {e}")
-            return "", history + [(message, f"Error: {str(e)}")]
+            # Add error as assistant message
+            history = history + [
+                {"role": "user", "content": message},
+                {"role": "assistant", "content": f"Error: {str(e)}"}
+            ]
+            return "", history
     
-    def analyze_text(self, text: str) -> Dict[str, Any]:
+    def analyze_text(self, text: str):
         """Perform comprehensive text analysis"""
         try:
             # Get sentiment
             sentiment = self.ai_core.analyze_sentiment(text)
-            
             # Get embeddings
             embeddings = self.ai_core.get_embeddings(text)
             if embeddings:
@@ -69,25 +115,23 @@ class CodetteGradioApp:
                 embedding_viz = self._visualize_embeddings(embeddings)
             else:
                 embedding_viz = None
-            
             # Generate creative expansion
             expansion = self.ai_core.generate_text(
                 f"Creative expansion of the concept: {text}",
                 max_length=150
             )
-            
-            return {
-                "sentiment": f"Sentiment: {sentiment['label']} (confidence: {sentiment['score']:.2f})",
-                "embedding_viz": embedding_viz,
-                "creative_expansion": expansion
-            }
+            return (
+                f"Sentiment: {sentiment['label']} (confidence: {sentiment['score']:.2f})",
+                embedding_viz,
+                expansion
+            )
         except Exception as e:
             logger.error(f"Error in text analysis: {e}")
-            return {
-                "sentiment": "Error analyzing sentiment",
-                "embedding_viz": None,
-                "creative_expansion": str(e)
-            }
+            return (
+                "Error analyzing sentiment",
+                None,
+                str(e)
+            )
     
     def _visualize_embeddings(self, embeddings: list) -> np.ndarray:
         """Create a simple 2D visualization of embeddings"""
@@ -127,7 +171,7 @@ async def messages(req: Request) -> Response:
 
 # Create Gradio interface
 def create_gradio_interface():
-    with gr.Blocks(title="Codette AI Assistant", theme="dark") as interface:
+    with gr.Blocks(title="Codette AI Assistant", theme="default") as interface:
         gr.Markdown("""
         # 🤖 Codette AI Assistant
         A sophisticated AI assistant powered by Hugging Face models.
@@ -145,23 +189,22 @@ def create_gradio_interface():
                 chatbot = gr.Chatbot(
                     [],
                     elem_id="chatbot",
-                    height=400
+                    height=400,
+                    type="messages"
                 )
-                
                 with gr.Row():
                     txt = gr.Textbox(
                         show_label=False,
                         placeholder="Type your message here...",
                         container=False
                     )
-                    txt.style(container=False)
-                
+                with gr.Row():
+                    cocoon_toggle = gr.Checkbox(label="Enable Cocoon-Powered Creativity", value=False)
                 txt.submit(
                     gradio_app.process_message,
-                    [txt, chatbot],
+                    [txt, chatbot, cocoon_toggle],
                     [txt, chatbot]
                 )
-                
                 clear = gr.Button("Clear")
                 clear.click(lambda: [], None, chatbot)