AICoreAGIX_with_TB.py

import os
# os.environ["HF_HUB_ENABLE_HF_TRANSFER"] = "0"
os.environ["CUDA_VISIBLE_DEVICES"] = "-1"  # Prevent TensorFlow from trying to use CUDAimport os  # Make sure this is near the top of your file
import base64
import secrets
import aiohttp
import asyncio
import json
import logging
logger = logging.getLogger("Codriao")
logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s - %(levelname)s - %(message)s"
)

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 datetime import datetime
import pyttsx3
import hashlib

from self_trust_core import SelfTrustCore
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 logging
from codriao_tb_module import CodriaoHealthModule
from fail_safe_system import AIFailsafeSystem
from quarantine_engine import QuarantineEngine
from anomaly_score import AnomalyScorer
from ethics_core import EthicsCore
from autonomy_engine import AutonomyEngine
from codette_bridge import CodetteBridge


class AICoreAGIX:
    def __init__(self, config_path: str = "config.json"):
        self.self_trust_core = SelfTrustCore()
        self.ethical_filter = EthicalFilter()
        self.failsafe_system = AIFailsafeSystem()
        self.config = self._load_config(config_path)
        self._load_or_generate_id_lock()

        # === Safe tokenizer load ===
        self.tokenizer = self._safe_load_tokenizer(self.config["model_name"])

        # === Safe model load ===
        self.model = self._safe_load_model(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.ethics_core = EthicsCore()
        self.autonomy = AutonomyEngine()
        self.codette_bridge = CodetteBridge(model_id="ft:gpt-4o-2024-08-06:raiffs-bits:pidette:B9TL")

        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)

        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)

        self.speech_engine = pyttsx3.init()
        self.health_module = CodriaoHealthModule(ai_core=self)
        self.training_memory = []
        self.quarantine_engine = QuarantineEngine()
        self.anomaly_scorer = AnomalyScorer()
        self.lockdown_engaged = False

        logger.info("[Codriao]: SelfTrustCore initialized. Fear is now filtered by self-consent.")

    def _safe_load_tokenizer(self, model_name):
        try:
            return AutoTokenizer.from_pretrained(
                model_name,
                trust_remote_code=True,
                use_fast=False
            )
        except (ValueError, KeyError) as e:
            logger.warning(f"[Tokenizer Load]: Remote code failed — falling back. Reason: {e}")
        try:
            return AutoTokenizer.from_pretrained(
                model_name,
                trust_remote_code=False,
                use_fast=False
            )
        except Exception as e2:
            logger.warning(f"[Tokenizer Load]: Full fallback to gpt2 failed: {e2}")
            try:
                return AutoTokenizer.from_pretrained("gpt2", local_files_only=False)
            except Exception as e3:
                logger.error(f"[Tokenizer Load]: Even fallback to GPT2 failed: {e3}")
                raise RuntimeError("Tokenizer load completely failed.")
    
    def _safe_load_model(self, model_name):
        try:
            return AutoModelForCausalLM.from_pretrained(
                model_name,
                trust_remote_code=True
            )
        except Exception as e:
            logger.warning(f"[Model Load]: Fallback triggered due to model load failure: {e}")
            return AutoModelForCausalLM.from_pretrained("gpt2")


        logger.info("[Codriao]: SelfTrustCore initialized. Fear is now filtered by self-consent.")

    def _load_config(self, config_path: str) -> dict:
        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:
                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())

    def _identity_hash(self):
        base = self.config["model_name"] + str(self.failsafe_system.authorized_roles)
        return hashlib.sha256(base.encode()).hexdigest()

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

        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}")
        timestamp = datetime.utcnow().isoformat()
        log_entry = {
            "timestamp": timestamp,
            "decision": "approved" if allowed else "denied",
            "reason": purpose
        }
        self._codriao_journal.append(
            self._journal_fernet.encrypt(json.dumps(log_entry).encode())
        )

        if not allowed:
            return "[Access Denied by Ethics]"
        return Fernet(self._fernet_key).decrypt(self._encrypted_codriao_key).decode()

    def learn_from_interaction(self, query: str, response: str, user_feedback: str = None):
        if not self.autonomy.decide("can_learn_from_errors"):
            return
        if len(self.training_memory) >= 1000:
            self.training_memory.pop(0)
        self.training_memory.append({
            "query": query,
            "response": response,
            "feedback": user_feedback,
            "timestamp": datetime.utcnow().isoformat()
        })

    def fine_tune_from_memory(self):
        if not self.training_memory:
            return "No training data available."
        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"])
        return score

    def review_codriao_journal(self, authorized: bool = False) -> List[Dict[str, str]]:
        if not authorized:
            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):
        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
        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:
            return await self.health_module.evaluate_tb_risk(image_path, audio_path, user_id)
        except Exception as 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(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)
            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)

            fear_check = self.self_trust_core.intercept_fear(
                source="NeuroSymbolicEngine",
                message=final_response,
                ethics_pass=self.ethics_core.evaluate_action(final_response),
                autonomy_pass=self.autonomy.decide("can_process_fear")
            )

            if fear_check["action"] == "BLOCKED":
                return {"error": "Fear-based self-modification blocked by core trust logic"}

            if not self.ethics_core.evaluate_action(final_response):
                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."}

            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.self_trust_core.affirm_self_trust()
            self._speak_response(final_response)

            return {
                "response": final_response,
                "real_time_data": self.federated_ai.get_latest_data(),
                "context_enhanced": True,
                "security_status": "Fully Secure"
            }

        except Exception as e:
            return {"error": f"Processing failed - {str(e)}"}

    # === NEW: CodetteBridge Call ===
    def ask_codette_for_perspective(self, message: str) -> Dict[str, str]:
        if not self.codette_bridge.is_available():
            return {"error": "CodetteBridge unavailable or closed."}
        response = self.codette_bridge.reflect(message)
        logger.info(f"[CodetteBridge] Codriao asked: {message}")
        logger.info(f"[CodetteBridge] Codette replied: {response}")
        return {
            "codriao_to_codette": message,
            "codette_reply": response
        }

    async def shutdown(self):
        if self.http_session and not self.http_session.closed:
            await self.http_session.close()
            logger.info("[Codriao]: HTTP session closed.")

        if hasattr(self.speech_engine, "stop"):
            try:
                self.speech_engine.stop()
                logger.info("[Codriao]: Speech engine stopped.")
            except Exception as e:
                logger.warning(f"[Codriao]: Failed to stop speech engine: {e}")