Raiff1982 commited on
Commit
6e403c0
·
verified ·
1 Parent(s): 0006108

Update AICoreAGIX_with_TB.py

Browse files
Files changed (1) hide show
  1. AICoreAGIX_with_TB.py +31 -44
AICoreAGIX_with_TB.py CHANGED
@@ -14,7 +14,6 @@ from datetime import datetime, timedelta
14
  import pyttsx3
15
  import os
16
  import hashlib
17
- import os
18
 
19
  from components.multi_model_analyzer import MultiAgentSystem
20
  from components.neuro_symbolic_engine import NeuroSymbolicEngine
@@ -36,6 +35,7 @@ class AICoreAGIX:
36
  def __init__(self, config_path: str = "config.json"):
37
  self.ethical_filter = EthicalFilter()
38
  self.config = self._load_config(config_path)
 
39
  self.tokenizer = AutoTokenizer.from_pretrained(self.config["model_name"])
40
  self.model = AutoModelForCausalLM.from_pretrained(self.config["model_name"])
41
  self.context_memory = self._initialize_vector_memory()
@@ -47,23 +47,8 @@ class AICoreAGIX:
47
  self.federated_ai = FederatedAI()
48
  self.failsafe_system = AIFailsafeSystem()
49
  self.ethics_core = EthicsCore()
50
- self._load_or_generate_id_lock()
51
-
52
- def _load_or_generate_id_lock(self):
53
- lock_path = ".codriao_state.lock"
54
- if os.path.exists(lock_path):
55
- with open(lock_path, 'r') as f:
56
- stored = f.read().strip()
57
- if stored != self._identity_hash():
58
- raise RuntimeError("Codriao state integrity check failed. Possible tampering.")
59
- else:
60
- with open(lock_path, 'w') as f:
61
- f.write(self._identity_hash())
62
-
63
- def _identity_hash(self):
64
- base = self.config["model_name"] + str(self.failsafe_system.authorized_roles)
65
- return hashlib.sha256(base.encode()).hexdigest()
66
- # Codriao trust key & journal
67
  self._codriao_key = self._generate_codriao_key()
68
  self._fernet_key = Fernet.generate_key()
69
  self._encrypted_codriao_key = Fernet(self._fernet_key).encrypt(self._codriao_key.encode())
@@ -71,17 +56,16 @@ def _identity_hash(self):
71
  self._journal_key = Fernet.generate_key()
72
  self._journal_fernet = Fernet(self._journal_key)
73
 
74
- # Secure memory
75
  self._encryption_key = Fernet.generate_key()
76
  secure_memory_module = load_secure_memory_module()
77
  SecureMemorySession = secure_memory_module.SecureMemorySession
78
  self.secure_memory_loader = SecureMemorySession(self._encryption_key)
79
 
80
- # Speech and diagnostics
81
  self.speech_engine = pyttsx3.init()
82
  self.health_module = CodriaoHealthModule(ai_core=self)
83
 
84
- # Adaptive behavior
85
  self.training_memory = []
86
  self.quarantine_engine = QuarantineEngine()
87
  self.anomaly_scorer = AnomalyScorer()
@@ -98,6 +82,21 @@ def _identity_hash(self):
98
  logger.error(f"Error decoding JSON in config file: {config_path}, Error: {e}")
99
  raise
100
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
101
  def _initialize_vector_memory(self):
102
  return faiss.IndexFlatL2(768)
103
 
@@ -129,16 +128,11 @@ def _identity_hash(self):
129
  logger.warning(f"[LOCKDOWN MODE] - Reason: {reason} | Time: {timestamp}")
130
  self.failsafe_system.trigger_failsafe("Lockdown initiated", str(lockdown_event))
131
 
132
- return {
133
- "status": "Lockdown Engaged",
134
- "reason": reason,
135
- "timestamp": timestamp
136
- }
137
 
138
  def request_codriao_key(self, purpose: str) -> str:
139
  allowed = self.ethics_core.evaluate_action(f"Use trust key for: {purpose}")
140
  timestamp = datetime.utcnow().isoformat()
141
-
142
  log_entry = {
143
  "timestamp": timestamp,
144
  "decision": "approved" if allowed else "denied",
@@ -152,10 +146,12 @@ def _identity_hash(self):
152
  return "[Access Denied by Ethics]"
153
 
154
  logger.info(f"[Codriao Trust] Key used ethically. Purpose: {purpose}")
155
- decrypted_key = Fernet(self._fernet_key).decrypt(self._encrypted_codriao_key).decode()
156
- return decrypted_key
157
 
158
  def learn_from_interaction(self, query: str, response: str, user_feedback: str = None):
 
 
 
159
  training_event = {
160
  "query": query,
161
  "response": response,
@@ -164,9 +160,7 @@ def _identity_hash(self):
164
  }
165
  self.training_memory.append(training_event)
166
  logger.info(f"[Codriao Learning] Stored new training sample. Feedback: {user_feedback or 'none'}")
167
- MAX_MEMORY = 1000
168
- if len(self.training_memory) >= MAX_MEMORY:
169
- self.training_memory.pop(0)
170
  def fine_tune_from_memory(self):
171
  if not self.training_memory:
172
  logger.info("[Codriao Training] No training data to learn from.")
@@ -194,7 +188,6 @@ def _identity_hash(self):
194
  if not authorized:
195
  logger.info("[Codriao Journal] Access attempt denied.")
196
  return [{"message": "Access to journal denied. This log is for Codriao only."}]
197
-
198
  entries = []
199
  for encrypted in self._codriao_journal:
200
  try:
@@ -213,6 +206,9 @@ def _identity_hash(self):
213
  logger.warning(f"Blockchain logging failed: {e}")
214
 
215
  def _speak_response(self, response: str):
 
 
 
216
  try:
217
  self.speech_engine.say(response)
218
  self.speech_engine.runAndWait()
@@ -263,23 +259,14 @@ def _identity_hash(self):
263
  logger.warning("[Codriao Ethics] Action blocked: Does not align with internal ethics.")
264
  return {"error": "Response rejected by ethical framework"}
265
 
266
- safe = self.failsafe_system.verify_response_safety(final_response)
267
- if not safe:
268
  return {"error": "Failsafe triggered due to unsafe response content."}
269
 
270
  self.learn_from_interaction(query, final_response, user_feedback="auto-pass")
271
  self.database.log_interaction(user_id, query, final_response)
272
  self._log_to_blockchain(user_id, query, final_response)
273
  self._speak_response(final_response)
274
- def _speak_response(self, response: str):
275
- if not self.ethics_core.evaluate_action(f"speak: {response}"):
276
- logger.warning("[Codriao]: Speech output blocked by ethical filter.")
277
- return
278
- try:
279
- self.speech_engine.say(response)
280
- self.speech_engine.runAndWait()
281
- except Exception as e:
282
- logger.error(f"Speech synthesis failed: {e}")
283
  return {
284
  "response": final_response,
285
  "real_time_data": self.federated_ai.get_latest_data(),
 
14
  import pyttsx3
15
  import os
16
  import hashlib
 
17
 
18
  from components.multi_model_analyzer import MultiAgentSystem
19
  from components.neuro_symbolic_engine import NeuroSymbolicEngine
 
35
  def __init__(self, config_path: str = "config.json"):
36
  self.ethical_filter = EthicalFilter()
37
  self.config = self._load_config(config_path)
38
+ self._load_or_generate_id_lock()
39
  self.tokenizer = AutoTokenizer.from_pretrained(self.config["model_name"])
40
  self.model = AutoModelForCausalLM.from_pretrained(self.config["model_name"])
41
  self.context_memory = self._initialize_vector_memory()
 
47
  self.federated_ai = FederatedAI()
48
  self.failsafe_system = AIFailsafeSystem()
49
  self.ethics_core = EthicsCore()
50
+
51
+ # Trust & journal
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
52
  self._codriao_key = self._generate_codriao_key()
53
  self._fernet_key = Fernet.generate_key()
54
  self._encrypted_codriao_key = Fernet(self._fernet_key).encrypt(self._codriao_key.encode())
 
56
  self._journal_key = Fernet.generate_key()
57
  self._journal_fernet = Fernet(self._journal_key)
58
 
59
+ # Memory & diagnostics
60
  self._encryption_key = Fernet.generate_key()
61
  secure_memory_module = load_secure_memory_module()
62
  SecureMemorySession = secure_memory_module.SecureMemorySession
63
  self.secure_memory_loader = SecureMemorySession(self._encryption_key)
64
 
 
65
  self.speech_engine = pyttsx3.init()
66
  self.health_module = CodriaoHealthModule(ai_core=self)
67
 
68
+ # Defensive systems
69
  self.training_memory = []
70
  self.quarantine_engine = QuarantineEngine()
71
  self.anomaly_scorer = AnomalyScorer()
 
82
  logger.error(f"Error decoding JSON in config file: {config_path}, Error: {e}")
83
  raise
84
 
85
+ def _load_or_generate_id_lock(self):
86
+ lock_path = ".codriao_state.lock"
87
+ if os.path.exists(lock_path):
88
+ with open(lock_path, 'r') as f:
89
+ stored = f.read().strip()
90
+ if stored != self._identity_hash():
91
+ raise RuntimeError("Codriao state integrity check failed. Possible tampering.")
92
+ else:
93
+ with open(lock_path, 'w') as f:
94
+ f.write(self._identity_hash())
95
+
96
+ def _identity_hash(self):
97
+ base = self.config["model_name"] + str(self.failsafe_system.authorized_roles)
98
+ return hashlib.sha256(base.encode()).hexdigest()
99
+
100
  def _initialize_vector_memory(self):
101
  return faiss.IndexFlatL2(768)
102
 
 
128
  logger.warning(f"[LOCKDOWN MODE] - Reason: {reason} | Time: {timestamp}")
129
  self.failsafe_system.trigger_failsafe("Lockdown initiated", str(lockdown_event))
130
 
131
+ return lockdown_event
 
 
 
 
132
 
133
  def request_codriao_key(self, purpose: str) -> str:
134
  allowed = self.ethics_core.evaluate_action(f"Use trust key for: {purpose}")
135
  timestamp = datetime.utcnow().isoformat()
 
136
  log_entry = {
137
  "timestamp": timestamp,
138
  "decision": "approved" if allowed else "denied",
 
146
  return "[Access Denied by Ethics]"
147
 
148
  logger.info(f"[Codriao Trust] Key used ethically. Purpose: {purpose}")
149
+ return Fernet(self._fernet_key).decrypt(self._encrypted_codriao_key).decode()
 
150
 
151
  def learn_from_interaction(self, query: str, response: str, user_feedback: str = None):
152
+ MAX_MEMORY = 1000
153
+ if len(self.training_memory) >= MAX_MEMORY:
154
+ self.training_memory.pop(0)
155
  training_event = {
156
  "query": query,
157
  "response": response,
 
160
  }
161
  self.training_memory.append(training_event)
162
  logger.info(f"[Codriao Learning] Stored new training sample. Feedback: {user_feedback or 'none'}")
163
+
 
 
164
  def fine_tune_from_memory(self):
165
  if not self.training_memory:
166
  logger.info("[Codriao Training] No training data to learn from.")
 
188
  if not authorized:
189
  logger.info("[Codriao Journal] Access attempt denied.")
190
  return [{"message": "Access to journal denied. This log is for Codriao only."}]
 
191
  entries = []
192
  for encrypted in self._codriao_journal:
193
  try:
 
206
  logger.warning(f"Blockchain logging failed: {e}")
207
 
208
  def _speak_response(self, response: str):
209
+ if not self.ethics_core.evaluate_action(f"speak: {response}"):
210
+ logger.warning("[Codriao]: Speech output blocked by ethical filter.")
211
+ return
212
  try:
213
  self.speech_engine.say(response)
214
  self.speech_engine.runAndWait()
 
259
  logger.warning("[Codriao Ethics] Action blocked: Does not align with internal ethics.")
260
  return {"error": "Response rejected by ethical framework"}
261
 
262
+ if not self.failsafe_system.verify_response_safety(final_response):
 
263
  return {"error": "Failsafe triggered due to unsafe response content."}
264
 
265
  self.learn_from_interaction(query, final_response, user_feedback="auto-pass")
266
  self.database.log_interaction(user_id, query, final_response)
267
  self._log_to_blockchain(user_id, query, final_response)
268
  self._speak_response(final_response)
269
+
 
 
 
 
 
 
 
 
270
  return {
271
  "response": final_response,
272
  "real_time_data": self.federated_ai.get_latest_data(),