Update AICoreAGIX_with_TB.py

AICoreAGIX_with_TB.py

@@ -9,7 +9,6 @@ from typing import List, Dict, Any
 from cryptography.fernet import Fernet
 from jwt import encode, decode, ExpiredSignatureError
 from datetime import datetime, timedelta
-import speech_recognition as sr
 import pyttsx3
 import os
 
@@ -41,7 +40,7 @@ class AICoreAGIX:
         self.federated_ai = FederatedAI()
 
         # Secure memory setup
-        self._encryption_key = self.config["security_settings"]["encryption_key"].encode()
+        self._encryption_key = Fernet.generate_key()  # Rotated dynamically
         secure_memory_module = load_secure_memory_module()
         SecureMemorySession = secure_memory_module.SecureMemorySession
         self.secure_memory_loader = SecureMemorySession(self._encryption_key)
@@ -51,6 +50,10 @@ class AICoreAGIX:
 
     async def generate_response(self, query: str, user_id: int) -> Dict[str, Any]:
         try:
+            # Validate query
+            if not isinstance(query, str) or len(query.strip()) == 0:
+                raise ValueError("Invalid query input.")
+            
             result = self.ethical_filter.analyze_query(query)
             if result["status"] == "blocked":
                 return {"error": result["reason"]}
@@ -59,33 +62,23 @@ class AICoreAGIX:
 
             if any(phrase in query.lower() for phrase in ["tb check", "analyze my tb", "run tb diagnostics", "tb test"]):
                 result = await self.run_tb_diagnostics("tb_image.jpg", "tb_cough.wav", user_id)
-                return {
-                    "response": result["ethical_analysis"],
-                    "explanation": result["explanation"],
-                    "tb_risk": result["tb_risk"],
-                    "image_analysis": result["image_analysis"],
-                    "audio_analysis": result["audio_analysis"],
-                    "system_health": result["system_health"]
-                }
+                return result
 
             vectorized_query = self._vectorize_query(query)
             self.secure_memory_loader.encrypt_vector(user_id, vectorized_query)
-            user_vectors = self.secure_memory_loader.decrypt_vectors(user_id)
-
-            # === Use OpenAI w/ fallback ===
-            model_response = query_codette_with_fallback(query, user_id=str(user_id))
-            agent_response = self.multi_agent_system.delegate_task(query)
-            self_reflection = self.self_improving_ai.evaluate_response(query, model_response)
-            neural_reasoning = self.neural_symbolic_engine.integrate_reasoning(query)
-
-            final_response = (
-                f"{model_response}\n\n"
-                f"{agent_response}\n\n"
-                f"{self_reflection}\n\n"
-                f"Logic: {neural_reasoning}"
+
+            # Gather responses asynchronously
+            responses = await asyncio.gather(
+                self._generate_local_model_response(query),
+                self.multi_agent_system.delegate_task(query),
+                self.self_improving_ai.evaluate_response(query),
+                self.neural_symbolic_engine.integrate_reasoning(query)
             )
 
+            final_response = "\n\n".join(responses)
+
             self.database.log_interaction(user_id, query, final_response)
+            self._log_to_blockchain(user_id, query, final_response)
             self._speak_response(final_response)
 
             return {
@@ -99,6 +92,11 @@ class AICoreAGIX:
             logger.error(f"Response generation failed: {e}")
             return {"error": "Processing failed - safety protocols engaged"}
 
+    async def _generate_local_model_response(self, query: str) -> str:
+        inputs = self.tokenizer(query, return_tensors="pt")
+        outputs = self.model.generate(**inputs)
+        return self.tokenizer.decode(outputs[0], skip_special_tokens=True)
+
     async def run_tb_diagnostics(self, image_path: str, audio_path: str, user_id: int) -> Dict[str, Any]:
         try:
             result = await self.health_module.evaluate_tb_risk(image_path, audio_path, user_id)
@@ -106,27 +104,32 @@ class AICoreAGIX:
             return result
         except Exception as e:
             logger.error(f"TB diagnostics failed: {e}")
-            return {
-                "tb_risk": "ERROR",
-                "error": str(e),
-                "image_analysis": {},
-                "audio_analysis": {},
-                "ethical_analysis": "Unable to complete TB diagnostic.",
-                "explanation": None,
-                "system_health": None
-            }
+            return {"tb_risk": "ERROR", "error": str(e)}
 
-    def _load_config(self, config_path: str) -> dict:
-        with open(config_path, 'r') as file:
-            return json.load(file)
+    def _vectorize_query(self, query: str):
+        tokenized = self.tokenizer(query, return_tensors="pt")
+        return tokenized["input_ids"].detach().numpy()
 
     def _initialize_vector_memory(self):
         return faiss.IndexFlatL2(768)
 
-    def _vectorize_query(self, query: str):
-        tokenized = self.tokenizer(query, return_tensors="pt")
-        return tokenized["input_ids"].detach().numpy()
+    def _log_to_blockchain(self, user_id: int, query: str, final_response: str):
+        retries = 3
+        for attempt in range(retries):
+            try:
+                # Replace with real blockchain logging function
+                logger.info(f"Logging interaction to blockchain: Attempt {attempt + 1}")
+                break
+            except Exception as e:
+                logger.warning(f"Blockchain logging failed: {e}")
+                continue
 
     def _speak_response(self, response: str):
-        self.speech_engine.say(response)
-        self.speech_engine.runAndWait()
+        try:
+            self.speech_engine.say(response)
+            self.speech_engine.runAndWait()
+        except Exception as e:
+            logger.error(f"Speech synthesis failed: {e}")
+
+    async def shutdown(self):
+        await self.http_session.close()