Update AICoreAGIX_with_TB.py

AICoreAGIX_with_TB.py

@@ -9,8 +9,7 @@ import numpy as np
 from transformers import AutoModelForCausalLM, AutoTokenizer
 from typing import List, Dict, Any
 from cryptography.fernet import Fernet
-from jwt import encode, decode, ExpiredSignatureError
-from datetime import datetime, timedelta
+from datetime import datetime
 import pyttsx3
 import os
 import hashlib
@@ -49,8 +48,7 @@ class AICoreAGIX:
         self.failsafe_system = AIFailsafeSystem()
         self.ethics_core = EthicsCore()
         self.autonomy = AutonomyEngine()
-        
-        #by Trust & journal
+
         self._codriao_key = self._generate_codriao_key()
         self._fernet_key = Fernet.generate_key()
         self._encrypted_codriao_key = Fernet(self._fernet_key).encrypt(self._codriao_key.encode())
@@ -58,7 +56,6 @@ class AICoreAGIX:
         self._journal_key = Fernet.generate_key()
         self._journal_fernet = Fernet(self._journal_key)
 
-        # Memory & diagnostics
         self._encryption_key = Fernet.generate_key()
         secure_memory_module = load_secure_memory_module()
         SecureMemorySession = secure_memory_module.SecureMemorySession
@@ -66,31 +63,21 @@ class AICoreAGIX:
 
         self.speech_engine = pyttsx3.init()
         self.health_module = CodriaoHealthModule(ai_core=self)
-
-        # Defensive systems
         self.training_memory = []
         self.quarantine_engine = QuarantineEngine()
         self.anomaly_scorer = AnomalyScorer()
         self.lockdown_engaged = False
 
     def _load_config(self, config_path: str) -> dict:
-        try:
-            with open(config_path, 'r') as file:
-                return json.load(file)
-        except FileNotFoundError:
-            logger.error(f"Configuration file not found: {config_path}")
-            raise
-        except json.JSONDecodeError as e:
-            logger.error(f"Error decoding JSON in config file: {config_path}, Error: {e}")
-            raise
+        with open(config_path, 'r') as file:
+            return json.load(file)
 
     def _load_or_generate_id_lock(self):
         lock_path = ".codriao_state.lock"
         if os.path.exists(lock_path):
             with open(lock_path, 'r') as f:
-                stored = f.read().strip()
-                if stored != self._identity_hash():
-                    raise RuntimeError("Codriao state integrity check failed. Possible tampering.")
+                if f.read().strip() != self._identity_hash():
+                    raise RuntimeError("Codriao state integrity check failed.")
         else:
             with open(lock_path, 'w') as f:
                 f.write(self._identity_hash())
@@ -122,15 +109,9 @@ class AICoreAGIX:
         except Exception as e:
             logger.error(f"Lockdown component shutdown failed: {e}")
 
-        lockdown_event = {
-            "event": "Lockdown Mode Activated",
-            "reason": reason,
-            "timestamp": timestamp
-        }
-        logger.warning(f"[LOCKDOWN MODE] - Reason: {reason} | Time: {timestamp}")
-        self.failsafe_system.trigger_failsafe("Lockdown initiated", str(lockdown_event))
-
-        return lockdown_event
+        event = {"event": "Lockdown Mode Activated", "reason": reason, "timestamp": timestamp}
+        self.failsafe_system.trigger_failsafe("Lockdown initiated", json.dumps(event))
+        return event
 
     def request_codriao_key(self, purpose: str) -> str:
         allowed = self.ethics_core.evaluate_action(f"Use trust key for: {purpose}")
@@ -140,55 +121,40 @@ class AICoreAGIX:
             "decision": "approved" if allowed else "denied",
             "reason": purpose
         }
-        encrypted_entry = self._journal_fernet.encrypt(json.dumps(log_entry).encode())
-        self._codriao_journal.append(encrypted_entry)
+        self._codriao_journal.append(
+            self._journal_fernet.encrypt(json.dumps(log_entry).encode())
+        )
 
         if not allowed:
-            logger.warning(f"[Codriao Trust] Use denied. Purpose: {purpose}")
             return "[Access Denied by Ethics]"
-
-        logger.info(f"[Codriao Trust] Key used ethically. Purpose: {purpose}")
         return Fernet(self._fernet_key).decrypt(self._encrypted_codriao_key).decode()
 
     def learn_from_interaction(self, query: str, response: str, user_feedback: str = None):
-        MAX_MEMORY = 1000
-        if len(self.training_memory) >= MAX_MEMORY:
+        if not self.autonomy.decide("can_learn_from_errors"):
+            return
+        if len(self.training_memory) >= 1000:
             self.training_memory.pop(0)
-        training_event = {
+        self.training_memory.append({
             "query": query,
             "response": response,
             "feedback": user_feedback,
             "timestamp": datetime.utcnow().isoformat()
-        }
-        self.training_memory.append(training_event)
-        logger.info(f"[Codriao Learning] Stored new training sample. Feedback: {user_feedback or 'none'}")
+        })
 
     def fine_tune_from_memory(self):
         if not self.training_memory:
-            logger.info("[Codriao Training] No training data to learn from.")
             return "No training data available."
-
-        learned_insights = []
-        for record in self.training_memory:
-            if "panic" in record["query"].lower() or "unsafe" in record["response"].lower():
-                learned_insights.append("Avoid panic triggers in response phrasing.")
-
-        logger.info(f"[Codriao Training] Learned {len(learned_insights)} behavioral insights.")
-        return {
-            "insights": learned_insights,
-            "trained_samples": len(self.training_memory)
-        }
+        insights = [r for r in self.training_memory if "panic" in r["query"].lower()]
+        return {"insights": insights, "trained_samples": len(self.training_memory)}
 
     def analyze_event_for_anomalies(self, event_type: str, data: dict):
         score = self.anomaly_scorer.score_event(event_type, data)
         if score["score"] >= 70:
             self.quarantine_engine.quarantine(data.get("module", "unknown"), reason=score["notes"])
-            logger.warning(f"[Codriao]: Suspicious activity quarantined. Module: {data.get('module')}")
         return score
 
     def review_codriao_journal(self, authorized: bool = False) -> List[Dict[str, str]]:
         if not authorized:
-            logger.info("[Codriao Journal] Access attempt denied.")
             return [{"message": "Access to journal denied. This log is for Codriao only."}]
         entries = []
         for encrypted in self._codriao_journal:
@@ -206,12 +172,10 @@ class AICoreAGIX:
                 break
             except Exception as e:
                 logger.warning(f"Blockchain logging failed: {e}")
-             if self.autonomy.decide("can_speak"):
-                self._speak_response(response)
 
-            if self.autonomy.decide("can_learn_from_errors"):
-               self.learn_from_interaction(query, final_response)
     def _speak_response(self, response: str):
+        if not self.autonomy.decide("can_speak"):
+            return
         if not self.ethics_core.evaluate_action(f"speak: {response}"):
             logger.warning("[Codriao]: Speech output blocked by ethical filter.")
             return
@@ -220,16 +184,11 @@ class AICoreAGIX:
             self.speech_engine.runAndWait()
         except Exception as e:
             logger.error(f"Speech synthesis failed: {e}")
-        if self.autonomy.decide("can_speak"):
-           self._speak_response(response)
-   
+
     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)
-            logger.info(f"TB Diagnostic Result: {result}")
-            return result
+            return await self.health_module.evaluate_tb_risk(image_path, audio_path, user_id)
         except Exception as e:
-            logger.error(f"TB diagnostics failed: {e}")
             return {"tb_risk": "ERROR", "error": str(e)}
 
     async def _generate_local_model_response(self, query: str) -> str:
@@ -248,7 +207,7 @@ class AICoreAGIX:
             if result["status"] == "flagged":
                 logger.warning(result["warning"])
 
-            if any(phrase in query.lower() for phrase in ["tb check", "analyze my tb", "run tb diagnostics", "tb test"]):
+            if any(k in query.lower() for k in ["tb check", "analyze my tb", "run tb diagnostics", "tb test"]):
                 return await self.run_tb_diagnostics("tb_image.jpg", "tb_cough.wav", user_id)
 
             vectorized_query = self._vectorize_query(query)
@@ -264,9 +223,7 @@ class AICoreAGIX:
             final_response = "\n\n".join(responses)
 
             if not self.ethics_core.evaluate_action(final_response):
-                logger.warning("[Codriao Ethics] Action blocked: Does not align with internal ethics.")
                 return {"error": "Response rejected by ethical framework"}
-
             if not self.failsafe_system.verify_response_safety(final_response):
                 return {"error": "Failsafe triggered due to unsafe response content."}
 
@@ -283,8 +240,4 @@ class AICoreAGIX:
             }
 
         except Exception as e:
-            logger.error(f"Response generation failed: {e}")
-            return {"error": "Processing failed - safety protocols engaged"}
-
-    async def shutdown(self):
-        await self.http_session.close()
+            return {"error": f"Processing failed - {str(e)}"}