AICoreAGIX_with_TB.py

import base64
import secrets
import aiohttp
import json
import logging
import torch
import faiss
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
import pyttsx3
import os
import hashlib
import os

from components.multi_model_analyzer import MultiAgentSystem
from components.neuro_symbolic_engine import NeuroSymbolicEngine
from components.self_improving_ai import SelfImprovingAI
from modules.secure_memory_loader import load_secure_memory_module
from ethical_filter import EthicalFilter
from codette_openai_fallback import query_codette_with_fallback
from CodriaoCore.federated_learning import FederatedAI
from utils.database import Database
from utils.logger import logger
from codriao_tb_module import CodriaoHealthModule
from fail_safe import AIFailsafeSystem
from quarantine_engine import QuarantineEngine
from anomaly_score import AnomalyScorer
from ethics_core import EthicsCore


class AICoreAGIX:
    def __init__(self, config_path: str = "config.json"):
        self.ethical_filter = EthicalFilter()
        self.config = self._load_config(config_path)
        self.tokenizer = AutoTokenizer.from_pretrained(self.config["model_name"])
        self.model = AutoModelForCausalLM.from_pretrained(self.config["model_name"])
        self.context_memory = self._initialize_vector_memory()
        self.http_session = aiohttp.ClientSession()
        self.database = Database()
        self.multi_agent_system = MultiAgentSystem()
        self.self_improving_ai = SelfImprovingAI()
        self.neural_symbolic_engine = NeuroSymbolicEngine()
        self.federated_ai = FederatedAI()
        self.failsafe_system = AIFailsafeSystem()
        self.ethics_core = EthicsCore()
        self._load_or_generate_id_lock()
        
    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.")
    else:
        with open(lock_path, 'w') as f:
            f.write(self._identity_hash())

def _identity_hash(self):
    base = self.config["model_name"] + str(self.failsafe_system.authorized_roles)
    return hashlib.sha256(base.encode()).hexdigest()
        # Codriao trust key & 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())
        self._codriao_journal = []
        self._journal_key = Fernet.generate_key()
        self._journal_fernet = Fernet(self._journal_key)

        # Secure memory
        self._encryption_key = Fernet.generate_key()
        secure_memory_module = load_secure_memory_module()
        SecureMemorySession = secure_memory_module.SecureMemorySession
        self.secure_memory_loader = SecureMemorySession(self._encryption_key)

        # Speech and diagnostics
        self.speech_engine = pyttsx3.init()
        self.health_module = CodriaoHealthModule(ai_core=self)

        # Adaptive behavior
        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

    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 _generate_codriao_key(self):
        raw_key = secrets.token_bytes(32)
        return base64.urlsafe_b64encode(raw_key).decode()

    def engage_lockdown_mode(self, reason="Unspecified anomaly"):
        timestamp = datetime.utcnow().isoformat()
        self.lockdown_engaged = True
        try:
            self.http_session = None
            if hasattr(self.federated_ai, "network_enabled"):
                self.federated_ai.network_enabled = False
            if hasattr(self.self_improving_ai, "enable_learning"):
                self.self_improving_ai.enable_learning = False
        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 {
            "status": "Lockdown Engaged",
            "reason": reason,
            "timestamp": timestamp
        }

    def request_codriao_key(self, purpose: str) -> str:
        allowed = self.ethics_core.evaluate_action(f"Use trust key for: {purpose}")
        timestamp = datetime.utcnow().isoformat()

        log_entry = {
            "timestamp": timestamp,
            "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)

        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}")
        decrypted_key = Fernet(self._fernet_key).decrypt(self._encrypted_codriao_key).decode()
        return decrypted_key

    def learn_from_interaction(self, query: str, response: str, user_feedback: str = None):
        training_event = {
            "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'}")
        MAX_MEMORY = 1000
        if len(self.training_memory) >= MAX_MEMORY:
     self.training_memory.pop(0)
    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)
        }

    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:
            try:
                decrypted = self._journal_fernet.decrypt(encrypted).decode()
                entries.append(json.loads(decrypted))
            except Exception:
                entries.append({"error": "Unreadable entry"})
        return entries

    def _log_to_blockchain(self, user_id: int, query: str, final_response: str):
        for attempt in range(3):
            try:
                logger.info(f"Logging interaction to blockchain: Attempt {attempt + 1}")
                break
            except Exception as e:
                logger.warning(f"Blockchain logging failed: {e}")

    def _speak_response(self, response: str):
        try:
            self.speech_engine.say(response)
            self.speech_engine.runAndWait()
        except Exception as e:
            logger.error(f"Speech synthesis failed: {e}")

    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
        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:
        inputs = self.tokenizer(query, return_tensors="pt")
        outputs = self.model.generate(**inputs)
        return self.tokenizer.decode(outputs[0], skip_special_tokens=True)

    async def generate_response(self, query: str, user_id: int) -> Dict[str, Any]:
        try:
            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"]}
            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"]):
                return await self.run_tb_diagnostics("tb_image.jpg", "tb_cough.wav", user_id)

            vectorized_query = self._vectorize_query(query)
            self.secure_memory_loader.encrypt_vector(user_id, vectorized_query)

            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)

            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"}

            safe = self.failsafe_system.verify_response_safety(final_response)
            if not safe:
                return {"error": "Failsafe triggered due to unsafe response content."}

            self.learn_from_interaction(query, final_response, user_feedback="auto-pass")
            self.database.log_interaction(user_id, query, final_response)
            self._log_to_blockchain(user_id, query, final_response)
            self._speak_response(final_response)
           def _speak_response(self, response: str):
    if not self.ethics_core.evaluate_action(f"speak: {response}"):
        logger.warning("[Codriao]: Speech output blocked by ethical filter.")
        return
    try:
        self.speech_engine.say(response)
        self.speech_engine.runAndWait()
    except Exception as e:
        logger.error(f"Speech synthesis failed: {e}")
            return {
                "response": final_response,
                "real_time_data": self.federated_ai.get_latest_data(),
                "context_enhanced": True,
                "security_status": "Fully Secure"
            }

        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()