major(feat): per-agent logging system with AgentLogger class

- Introduced AgentLogger to manage logging for different agents.
- Created log files for ensemble monitoring, weight optimization, system health, context intelligence, and forensic anomaly detection.
- Updated EnsembleMonitorAgent, WeightOptimizationAgent, SystemHealthAgent, ContextualIntelligenceAgent, and ForensicAnomalyDetectionAgent to use AgentLogger for logging.
- Modified app.py to integrate agent logs into the Gradio interface.
- Added log reading functionality to display agent logs in the UI.
- Removed old logging setup and streamlined logging across agents for consistency.

.gitattributes

@@ -38,4 +38,5 @@ preview/127.0.0.1_7860__.png filter=lfs diff=lfs merge=lfs -text
 preview/2.png filter=lfs diff=lfs merge=lfs -text
 preview/3.png filter=lfs diff=lfs merge=lfs -text
 preview/4.png filter=lfs diff=lfs merge=lfs -text
+temp_gradio_input.png filter=lfs diff=lfs merge=lfs -text
 *.png filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -13,4 +13,4 @@ models/*
 hf_inference_logs/*.json
 hf_inference_logs/*
 .gradio/flagged/*
-.venv
+.venv

.python-version

@@ -1 +0,0 @@
-3.11

agent_logs/context_intelligence.log

@@ -0,0 +1,5 @@
+2025-07-26 11:06:45,553 - INFO - Detected context tags: ['potentially_ai_generated'] (agent_logger.py:37)
+2025-07-26 11:29:16,042 - INFO - Initializing ContextualIntelligenceAgent. (agent_logger.py:37)
+2025-07-26 11:32:02,894 - INFO - Initializing ContextualIntelligenceAgent. (agent_logger.py:37)
+2025-07-26 11:35:25,364 - INFO - Initializing ContextualIntelligenceAgent. (agent_logger.py:37)
+2025-07-26 11:52:12,710 - INFO - Initializing ContextualIntelligenceAgent. (agent_logger.py:37)

agent_logs/ensemble_monitor.log

@@ -0,0 +1,46 @@
+2025-07-26 11:08:13,463 - INFO - Cleaned forensic images types: [<class 'PIL.Image.Image'>, <class 'PIL.Image.Image'>, <class 'PIL.Image.Image'>, <class 'PIL.Image.Image'>, <class 'PIL.Image.Image'>, <class 'PIL.Image.Image'>, <class 'PIL.Image.Image'>, <class 'PIL.Image.Image'>] (agent_logger.py:37)
+2025-07-26 11:29:16,039 - INFO - Initializing EnsembleMonitorAgent. (agent_logger.py:37)
+2025-07-26 11:32:02,885 - INFO - Initializing EnsembleMonitorAgent. (agent_logger.py:37)
+2025-07-26 11:32:10,166 - INFO - Monitoring prediction for model 'model_1'. Label: REAL, Confidence: 0.96, Time: 6.0362s (agent_logger.py:37)
+2025-07-26 11:32:10,166 - WARNING - ALERT: Model 'model_1' inference time exceeded 5.0s: 6.0362s (agent_logger.py:37)
+2025-07-26 11:32:10,167 - INFO - Updated metrics for 'model_1': {'total_predictions': 1, 'correct_predictions': 0, 'total_confidence': 0.9558695554733276, 'total_inference_time': 6.036171197891235} (agent_logger.py:37)
+2025-07-26 11:35:25,360 - INFO - Initializing EnsembleMonitorAgent. (agent_logger.py:37)
+2025-07-26 11:35:29,213 - INFO - Monitoring prediction for model 'model_1'. Label: REAL, Confidence: 0.99, Time: 2.4478s (agent_logger.py:37)
+2025-07-26 11:35:29,214 - INFO - Updated metrics for 'model_1': {'total_predictions': 1, 'correct_predictions': 0, 'total_confidence': 0.9877696633338928, 'total_inference_time': 2.447831630706787} (agent_logger.py:37)
+2025-07-26 11:35:32,846 - INFO - Monitoring prediction for model 'model_2'. Label: UNCERTAIN, Confidence: 0.56, Time: 3.4874s (agent_logger.py:37)
+2025-07-26 11:35:32,846 - INFO - Updated metrics for 'model_2': {'total_predictions': 1, 'correct_predictions': 0, 'total_confidence': 0.5572928190231323, 'total_inference_time': 3.4874162673950195} (agent_logger.py:37)
+2025-07-26 11:35:37,782 - INFO - Monitoring prediction for model 'model_3'. Label: AI, Confidence: 1.00, Time: 4.7423s (agent_logger.py:37)
+2025-07-26 11:35:37,783 - INFO - Updated metrics for 'model_3': {'total_predictions': 1, 'correct_predictions': 0, 'total_confidence': 0.9999939203262329, 'total_inference_time': 4.74231481552124} (agent_logger.py:37)
+2025-07-26 11:35:38,753 - INFO - Monitoring prediction for model 'model_4'. Label: REAL, Confidence: 1.00, Time: 0.7961s (agent_logger.py:37)
+2025-07-26 11:35:38,753 - INFO - Updated metrics for 'model_4': {'total_predictions': 1, 'correct_predictions': 0, 'total_confidence': 0.9999666213989258, 'total_inference_time': 0.7960679531097412} (agent_logger.py:37)
+2025-07-26 11:35:42,145 - INFO - Monitoring prediction for model 'model_5'. Label: REAL, Confidence: 0.80, Time: 3.2266s (agent_logger.py:37)
+2025-07-26 11:35:42,146 - INFO - Updated metrics for 'model_5': {'total_predictions': 1, 'correct_predictions': 0, 'total_confidence': 0.7969127297401428, 'total_inference_time': 3.2265756130218506} (agent_logger.py:37)
+2025-07-26 11:35:48,001 - INFO - Monitoring prediction for model 'model_6'. Label: AI, Confidence: 1.00, Time: 5.6884s (agent_logger.py:37)
+2025-07-26 11:35:48,002 - WARNING - ALERT: Model 'model_6' inference time exceeded 5.0s: 5.6884s (agent_logger.py:37)
+2025-07-26 11:35:48,002 - INFO - Updated metrics for 'model_6': {'total_predictions': 1, 'correct_predictions': 0, 'total_confidence': 0.9999886751174927, 'total_inference_time': 5.688395023345947} (agent_logger.py:37)
+2025-07-26 11:35:51,060 - INFO - Monitoring prediction for model 'model_7'. Label: AI, Confidence: 0.88, Time: 2.9033s (agent_logger.py:37)
+2025-07-26 11:35:51,060 - INFO - Updated metrics for 'model_7': {'total_predictions': 1, 'correct_predictions': 0, 'total_confidence': 0.8818904161453247, 'total_inference_time': 2.9033284187316895} (agent_logger.py:37)
+2025-07-26 11:36:00,757 - INFO - Monitoring prediction for model 'model_8'. Label: REAL, Confidence: 0.97, Time: 9.5506s (agent_logger.py:37)
+2025-07-26 11:36:00,757 - WARNING - ALERT: Model 'model_8' inference time exceeded 5.0s: 9.5506s (agent_logger.py:37)
+2025-07-26 11:36:00,757 - INFO - Updated metrics for 'model_8': {'total_predictions': 1, 'correct_predictions': 0, 'total_confidence': 0.9748013019561768, 'total_inference_time': 9.550556182861328} (agent_logger.py:37)
+2025-07-26 11:52:12,706 - INFO - Initializing EnsembleMonitorAgent. (agent_logger.py:37)
+2025-07-26 11:52:20,481 - INFO - Monitoring prediction for model 'model_1'. Label: REAL, Confidence: 0.99, Time: 6.3035s (agent_logger.py:37)
+2025-07-26 11:52:20,482 - WARNING - ALERT: Model 'model_1' inference time exceeded 5.0s: 6.3035s (agent_logger.py:37)
+2025-07-26 11:52:20,483 - INFO - Updated metrics for 'model_1': {'total_predictions': 1, 'correct_predictions': 0, 'total_confidence': 0.9877696633338928, 'total_inference_time': 6.303498029708862} (agent_logger.py:37)
+2025-07-26 11:52:23,521 - INFO - Monitoring prediction for model 'model_2'. Label: UNCERTAIN, Confidence: 0.56, Time: 2.8905s (agent_logger.py:37)
+2025-07-26 11:52:23,521 - INFO - Updated metrics for 'model_2': {'total_predictions': 1, 'correct_predictions': 0, 'total_confidence': 0.5572928190231323, 'total_inference_time': 2.8904731273651123} (agent_logger.py:37)
+2025-07-26 11:52:28,959 - INFO - Monitoring prediction for model 'model_3'. Label: AI, Confidence: 1.00, Time: 5.2830s (agent_logger.py:37)
+2025-07-26 11:52:28,960 - WARNING - ALERT: Model 'model_3' inference time exceeded 5.0s: 5.2830s (agent_logger.py:37)
+2025-07-26 11:52:28,960 - INFO - Updated metrics for 'model_3': {'total_predictions': 1, 'correct_predictions': 0, 'total_confidence': 0.9999939203262329, 'total_inference_time': 5.283019542694092} (agent_logger.py:37)
+2025-07-26 11:52:30,000 - INFO - Monitoring prediction for model 'model_4'. Label: REAL, Confidence: 1.00, Time: 0.8660s (agent_logger.py:37)
+2025-07-26 11:52:30,000 - INFO - Updated metrics for 'model_4': {'total_predictions': 1, 'correct_predictions': 0, 'total_confidence': 0.9999666213989258, 'total_inference_time': 0.8659720420837402} (agent_logger.py:37)
+2025-07-26 11:52:33,719 - INFO - Monitoring prediction for model 'model_5'. Label: REAL, Confidence: 0.80, Time: 3.1757s (agent_logger.py:37)
+2025-07-26 11:52:33,720 - INFO - Updated metrics for 'model_5': {'total_predictions': 1, 'correct_predictions': 0, 'total_confidence': 0.7969127297401428, 'total_inference_time': 3.175741195678711} (agent_logger.py:37)
+2025-07-26 11:52:39,124 - INFO - Monitoring prediction for model 'model_6'. Label: AI, Confidence: 1.00, Time: 5.2289s (agent_logger.py:37)
+2025-07-26 11:52:39,124 - WARNING - ALERT: Model 'model_6' inference time exceeded 5.0s: 5.2289s (agent_logger.py:37)
+2025-07-26 11:52:39,124 - INFO - Updated metrics for 'model_6': {'total_predictions': 1, 'correct_predictions': 0, 'total_confidence': 0.9999886751174927, 'total_inference_time': 5.228850841522217} (agent_logger.py:37)
+2025-07-26 11:52:42,460 - INFO - Monitoring prediction for model 'model_7'. Label: AI, Confidence: 0.88, Time: 3.1972s (agent_logger.py:37)
+2025-07-26 11:52:42,461 - INFO - Updated metrics for 'model_7': {'total_predictions': 1, 'correct_predictions': 0, 'total_confidence': 0.8818904161453247, 'total_inference_time': 3.197218418121338} (agent_logger.py:37)
+2025-07-26 11:52:51,110 - INFO - Monitoring prediction for model 'model_8'. Label: REAL, Confidence: 0.97, Time: 8.5060s (agent_logger.py:37)
+2025-07-26 11:52:51,110 - WARNING - ALERT: Model 'model_8' inference time exceeded 5.0s: 8.5060s (agent_logger.py:37)
+2025-07-26 11:52:51,110 - INFO - Updated metrics for 'model_8': {'total_predictions': 1, 'correct_predictions': 0, 'total_confidence': 0.9748013019561768, 'total_inference_time': 8.50600266456604} (agent_logger.py:37)

agent_logs/forensic_anomaly_detection.log

@@ -0,0 +1,5 @@
+2025-07-26 11:06:45,557 - INFO - Forensic anomaly detection: Potential anomalies detected: Gradient analysis shows unusual edge patterns.; MinMax processing reveals subtle pixel deviations. (agent_logger.py:37)
+2025-07-26 11:29:16,042 - INFO - Initializing ForensicAnomalyDetectionAgent. (agent_logger.py:37)
+2025-07-26 11:32:02,896 - INFO - Initializing ForensicAnomalyDetectionAgent. (agent_logger.py:37)
+2025-07-26 11:35:25,364 - INFO - Initializing ForensicAnomalyDetectionAgent. (agent_logger.py:37)
+2025-07-26 11:52:12,710 - INFO - Initializing ForensicAnomalyDetectionAgent. (agent_logger.py:37)

agent_logs/gradio_log.txt

@@ -0,0 +1,7 @@
+2025-07-26 10:34:11,730 - INFO - The logs will be displayed in here. (app.py:94)
+2025-07-26 10:36:40,701 - INFO - The logs will be displayed in here. (app.py:94)
+2025-07-26 10:40:19,369 - INFO - The logs will be displayed in here. (app.py:94)
+2025-07-26 10:40:24,440 - INFO - The logs will be displayed in here. (app.py:94)
+2025-07-26 10:41:58,076 - INFO - Detected context tags: ['potentially_ai_generated'] (app.py:368)
+2025-07-26 10:41:58,089 - INFO - Forensic anomaly detection: Potential anomalies detected: Gradient analysis shows unusual edge patterns.; MinMax processing reveals subtle pixel deviations. (app.py:405)
+2025-07-26 10:42:02,958 - INFO - Cleaned forensic images types: [<class 'PIL.Image.Image'>, <class 'PIL.Image.Image'>, <class 'PIL.Image.Image'>, <class 'PIL.Image.Image'>, <class 'PIL.Image.Image'>, <class 'PIL.Image.Image'>, <class 'PIL.Image.Image'>, <class 'PIL.Image.Image'>] (app.py:446)

agent_logs/system_health.log

@@ -0,0 +1,12 @@
+2025-07-26 11:29:16,042 - INFO - Initializing SystemHealthAgent. (agent_logger.py:37)
+2025-07-26 11:29:16,043 - INFO - Monitoring system health... (agent_logger.py:37)
+2025-07-26 11:29:17,146 - INFO - System health metrics: CPU: 17.8%, Memory: 64.0%, GPU: [{'id': 0, 'name': 'NVIDIA GeForce RTX 3060 Ti', 'load': 0.08, 'memoryUtil': 0.232666015625, 'memoryTotal': 8192.0, 'memoryUsed': 1906.0}] (agent_logger.py:37)
+2025-07-26 11:32:02,894 - INFO - Initializing SystemHealthAgent. (agent_logger.py:37)
+2025-07-26 11:32:02,896 - INFO - Monitoring system health... (agent_logger.py:37)
+2025-07-26 11:32:04,010 - INFO - System health metrics: CPU: 19.3%, Memory: 64.3%, GPU: [{'id': 0, 'name': 'NVIDIA GeForce RTX 3060 Ti', 'load': 0.02, 'memoryUtil': 0.2371826171875, 'memoryTotal': 8192.0, 'memoryUsed': 1943.0}] (agent_logger.py:37)
+2025-07-26 11:35:25,363 - INFO - Initializing SystemHealthAgent. (agent_logger.py:37)
+2025-07-26 11:35:25,364 - INFO - Monitoring system health... (agent_logger.py:37)
+2025-07-26 11:35:26,464 - INFO - System health metrics: CPU: 18.6%, Memory: 76.0%, GPU: [{'id': 0, 'name': 'NVIDIA GeForce RTX 3060 Ti', 'load': 0.09, 'memoryUtil': 0.2296142578125, 'memoryTotal': 8192.0, 'memoryUsed': 1881.0}] (agent_logger.py:37)
+2025-07-26 11:52:12,709 - INFO - Initializing SystemHealthAgent. (agent_logger.py:37)
+2025-07-26 11:52:12,711 - INFO - Monitoring system health... (agent_logger.py:37)
+2025-07-26 11:52:13,837 - INFO - System health metrics: CPU: 18.5%, Memory: 66.2%, GPU: [{'id': 0, 'name': 'NVIDIA GeForce RTX 3060 Ti', 'load': 0.07, 'memoryUtil': 0.2266845703125, 'memoryTotal': 8192.0, 'memoryUsed': 1857.0}] (agent_logger.py:37)

agent_logs/weight_optimization.log

@@ -0,0 +1,8 @@
+2025-07-26 11:29:16,041 - INFO - Initializing ModelWeightManager. Strongest model: simple_prediction (agent_logger.py:37)
+2025-07-26 11:29:16,042 - INFO - Initializing WeightOptimizationAgent. (agent_logger.py:37)
+2025-07-26 11:32:02,890 - INFO - Initializing ModelWeightManager. Strongest model: simple_prediction (agent_logger.py:37)
+2025-07-26 11:32:02,893 - INFO - Initializing WeightOptimizationAgent. (agent_logger.py:37)
+2025-07-26 11:35:25,363 - INFO - Initializing ModelWeightManager. Strongest model: simple_prediction (agent_logger.py:37)
+2025-07-26 11:35:25,363 - INFO - Initializing WeightOptimizationAgent. (agent_logger.py:37)
+2025-07-26 11:52:12,709 - INFO - Initializing ModelWeightManager. Strongest model: simple_prediction (agent_logger.py:37)
+2025-07-26 11:52:12,709 - INFO - Initializing WeightOptimizationAgent. (agent_logger.py:37)

agents/ensemble_team.py

@@ -1,4 +1,4 @@
-import logging
+from utils.agent_logger import AgentLogger
 import time
 import torch
 import psutil # Ensure psutil is imported here as well
@@ -6,16 +6,16 @@ import GPUtil
 from datetime import datetime, timedelta
 import gc # Import garbage collector
 
-logger = logging.getLogger(__name__)
+agent_logger = AgentLogger()
 
 class EnsembleMonitorAgent:
     def __init__(self):
-        logger.info("Initializing EnsembleMonitorAgent.")
+        agent_logger.log("ensemble_monitor", "info", "Initializing EnsembleMonitorAgent.")
         self.performance_metrics = {}
         self.alerts = []
     
     def monitor_prediction(self, model_id, prediction_label, confidence_score, inference_time):
-        logger.info(f"Monitoring prediction for model '{model_id}'. Label: {prediction_label}, Confidence: {confidence_score:.2f}, Time: {inference_time:.4f}s")
+        agent_logger.log("ensemble_monitor", "info", f"Monitoring prediction for model '{model_id}'. Label: {prediction_label}, Confidence: {confidence_score:.2f}, Time: {inference_time:.4f}s")
         if model_id not in self.performance_metrics:
             self.performance_metrics[model_id] = {
                 "total_predictions": 0,
@@ -23,28 +23,24 @@ class EnsembleMonitorAgent:
                 "total_confidence": 0.0,
                 "total_inference_time": 0.0
             }
-        
         metrics = self.performance_metrics[model_id]
         metrics["total_predictions"] += 1
         metrics["total_confidence"] += confidence_score
         metrics["total_inference_time"] += inference_time
-        
         # Example alert: model taking too long
         if inference_time > 5.0: # Threshold for slow inference
             alert_msg = f"ALERT: Model '{model_id}' inference time exceeded 5.0s: {inference_time:.4f}s"
             self.alerts.append(alert_msg)
-            logger.warning(alert_msg)
-        
+            agent_logger.log("ensemble_monitor", "warning", alert_msg)
         # Example alert: low confidence
         if confidence_score < 0.5: # Threshold for low confidence
             alert_msg = f"ALERT: Model '{model_id}' returned low confidence: {confidence_score:.2f}"
             self.alerts.append(alert_msg)
-            logger.warning(alert_msg)
-            
-        logger.info(f"Updated metrics for '{model_id}': {metrics}")
+            agent_logger.log("ensemble_monitor", "warning", alert_msg)
+        agent_logger.log("ensemble_monitor", "info", f"Updated metrics for '{model_id}': {metrics}")
     
     def get_performance_summary(self):
-        logger.info("Generating performance summary for all models.")
+        agent_logger.log("ensemble_monitor", "info", "Generating performance summary for all models.")
         summary = {}
         for model_id, metrics in self.performance_metrics.items():
             avg_confidence = metrics["total_confidence"] / metrics["total_predictions"] if metrics["total_predictions"] > 0 else 0
@@ -54,35 +50,33 @@ class EnsembleMonitorAgent:
                 "avg_inference_time": avg_inference_time,
                 "total_predictions": metrics["total_predictions"]
             }
-        logger.info(f"Performance summary: {summary}")
+        agent_logger.log("ensemble_monitor", "info", f"Performance summary: {summary}")
         return summary
 
 class WeightOptimizationAgent:
     def __init__(self, weight_manager):
-        logger.info("Initializing WeightOptimizationAgent.")
+        agent_logger.log("weight_optimization", "info", "Initializing WeightOptimizationAgent.")
         self.weight_manager = weight_manager
         self.prediction_history = []
         self.performance_window = timedelta(hours=24) # Evaluate performance over last 24 hours
     
     def analyze_performance(self, final_prediction, ground_truth=None):
-        logger.info(f"Analyzing performance. Final prediction: {final_prediction}, Ground truth: {ground_truth}")
+        agent_logger.log("weight_optimization", "info", f"Analyzing performance. Final prediction: {final_prediction}, Ground truth: {ground_truth}")
         timestamp = datetime.now()
         self.prediction_history.append({
             "timestamp": timestamp,
             "final_prediction": final_prediction,
             "ground_truth": ground_truth # Ground truth is often not available in real-time
         })
-        
         # Keep history windowed
         self.prediction_history = [p for p in self.prediction_history if timestamp - p["timestamp"] < self.performance_window]
-        logger.info(f"Prediction history length: {len(self.prediction_history)}")
-
+        agent_logger.log("weight_optimization", "info", f"Prediction history length: {len(self.prediction_history)}")
         # In a real scenario, this would involve a more complex optimization logic
         # For now, it just logs the history length.
 
 class SystemHealthAgent:
     def __init__(self):
-        logger.info("Initializing SystemHealthAgent.")
+        agent_logger.log("system_health", "info", "Initializing SystemHealthAgent.")
         self.health_metrics = {
             "cpu_percent": 0,
             "memory_usage": {"total": 0, "available": 0, "percent": 0},
@@ -90,7 +84,7 @@ class SystemHealthAgent:
         }
     
     def monitor_system_health(self):
-        logger.info("Monitoring system health...")
+        agent_logger.log("system_health", "info", "Monitoring system health...")
         self.health_metrics["cpu_percent"] = psutil.cpu_percent(interval=1)
         mem = psutil.virtual_memory()
         self.health_metrics["memory_usage"] = {
@@ -98,20 +92,18 @@ class SystemHealthAgent:
             "available": mem.available,
             "percent": mem.percent
         }
-
         # Holy moly, been at 99% for hours whoops
         if mem.percent > 90: 
-            logger.warning(f"CRITICAL: System memory usage is at {mem.percent}%. Attempting to clear memory cache...")
+            agent_logger.log("system_health", "warning", f"CRITICAL: System memory usage is at {mem.percent}%. Attempting to clear memory cache...")
             gc.collect() 
-            logger.info("Garbage collection triggered. Re-checking memory usage...")
+            agent_logger.log("system_health", "info", "Garbage collection triggered. Re-checking memory usage...")
             mem_after_gc = psutil.virtual_memory()
             self.health_metrics["memory_usage_after_gc"] = {
                 "total": mem_after_gc.total,
                 "available": mem_after_gc.available,
                 "percent": mem_after_gc.percent
             }
-            logger.info(f"Memory usage after GC: {mem_after_gc.percent}%")
-
+            agent_logger.log("system_health", "info", f"Memory usage after GC: {mem_after_gc.percent}%")
         gpu_info = []
         try:
             gpus = GPUtil.getGPUs()
@@ -125,7 +117,7 @@ class SystemHealthAgent:
                     "memoryUsed": gpu.memoryUsed
                 })
         except Exception as e:
-            logger.warning(f"Could not retrieve GPU information: {e}")
+            agent_logger.log("system_health", "warning", f"Could not retrieve GPU information: {e}")
             gpu_info.append({"error": str(e)})
         self.health_metrics["gpu_utilization"] = gpu_info
-        logger.info(f"System health metrics: CPU: {self.health_metrics['cpu_percent']}%, Memory: {self.health_metrics['memory_usage']['percent']}%, GPU: {gpu_info}") 
+        agent_logger.log("system_health", "info", f"System health metrics: CPU: {self.health_metrics['cpu_percent']}%, Memory: {self.health_metrics['memory_usage']['percent']}%, GPU: {gpu_info}")

agents/ensemble_weights.py

@@ -1,6 +1,7 @@
 import logging
 import torch
 from utils.registry import MODEL_REGISTRY # Import MODEL_REGISTRY
+from utils.agent_logger import AgentLogger
 
 logger = logging.getLogger(__name__)
 
@@ -39,7 +40,8 @@ class ContextualWeightOverrideAgent:
 
 class ModelWeightManager:
     def __init__(self, strongest_model_id: str = None):
-        logger.info(f"Initializing ModelWeightManager with strongest_model_id: {strongest_model_id}")
+        agent_logger = AgentLogger()
+        agent_logger.log("weight_optimization", "info", f"Initializing ModelWeightManager. Strongest model: {strongest_model_id}")
         # Dynamically initialize base_weights from MODEL_REGISTRY
         num_models = len(MODEL_REGISTRY)
         if num_models > 0:
@@ -74,9 +76,9 @@ class ModelWeightManager:
     
     def adjust_weights(self, predictions, confidence_scores, context_tags: list[str] = None):
         """Dynamically adjust weights based on prediction patterns and optional context."""
-        logger.info("Adjusting model weights.")
+        agent_logger.log("weight_optimization", "info", "Adjusting model weights.")
         adjusted_weights = self.base_weights.copy()
-        logger.info(f"Initial adjusted weights (copy of base): {adjusted_weights}")
+        agent_logger.log("weight_optimization", "info", f"Initial adjusted weights (copy of base): {adjusted_weights}")
 
         # 1. Apply contextual overrides first
         if context_tags:
@@ -84,34 +86,34 @@ class ModelWeightManager:
             overrides = self.context_override_agent.get_overrides(context_tags)
             for model_id, multiplier in overrides.items():
                 adjusted_weights[model_id] = adjusted_weights.get(model_id, 0.0) * multiplier
-            logger.info(f"Adjusted weights after context overrides: {adjusted_weights}")
+            agent_logger.log("weight_optimization", "info", f"Adjusted weights after context overrides: {adjusted_weights}")
         
         # 2. Apply situation-based adjustments (consensus, conflict, confidence)
         # Check for consensus
         has_consensus = self._has_consensus(predictions)
         if has_consensus:
-            logger.info("Consensus detected. Boosting weights for consensus.")
+            agent_logger.log("weight_optimization", "info", "Consensus detected. Boosting weights for consensus.")
             for model in adjusted_weights:
                 adjusted_weights[model] *= self.situation_weights["consensus"]
-            logger.info(f"Adjusted weights after consensus boost: {adjusted_weights}")
+            agent_logger.log("weight_optimization", "info", f"Adjusted weights after consensus boost: {adjusted_weights}")
         
         # Check for conflicts
         has_conflicts = self._has_conflicts(predictions)
         if has_conflicts:
-            logger.info("Conflicts detected. Reducing weights for conflict.")
+            agent_logger.log("weight_optimization", "info", "Conflicts detected. Reducing weights for conflict.")
             for model in adjusted_weights:
                 adjusted_weights[model] *= self.situation_weights["conflict"]
-            logger.info(f"Adjusted weights after conflict reduction: {adjusted_weights}")
+            agent_logger.log("weight_optimization", "info", f"Adjusted weights after conflict reduction: {adjusted_weights}")
         
         # Adjust based on confidence
         logger.info("Adjusting weights based on model confidence scores.")
         for model, confidence in confidence_scores.items():
             if confidence > 0.8:
                 adjusted_weights[model] *= self.situation_weights["high_confidence"]
-                logger.info(f"Model '{model}' has high confidence ({confidence:.2f}). Weight boosted.")
+                agent_logger.log("weight_optimization", "info", f"Model '{model}' has high confidence ({confidence:.2f}). Weight boosted.")
             elif confidence < 0.5:
                 adjusted_weights[model] *= self.situation_weights["low_confidence"]
-                logger.info(f"Model '{model}' has low confidence ({confidence:.2f}). Weight reduced.")
+                agent_logger.log("weight_optimization", "info", f"Model '{model}' has low confidence ({confidence:.2f}). Weight reduced.")
         logger.info(f"Adjusted weights before normalization: {adjusted_weights}")
         
         normalized_weights = self._normalize_weights(adjusted_weights)
@@ -120,7 +122,7 @@ class ModelWeightManager:
     
     def _has_consensus(self, predictions):
         """Check if models agree on prediction"""
-        logger.info("Checking for consensus among model predictions.")
+        agent_logger.log("weight_optimization", "info", "Checking for consensus among model predictions.")
         non_none_predictions = [p.get("Label") for p in predictions.values() if p is not None and isinstance(p, dict) and p.get("Label") is not None and p.get("Label") != "Error"]
         logger.debug(f"Non-none predictions for consensus check: {non_none_predictions}")
         result = len(non_none_predictions) > 0 and len(set(non_none_predictions)) == 1
@@ -129,7 +131,7 @@ class ModelWeightManager:
     
     def _has_conflicts(self, predictions):
         """Check if models have conflicting predictions"""
-        logger.info("Checking for conflicts among model predictions.")
+        agent_logger.log("weight_optimization", "info", "Checking for conflicts among model predictions.")
         non_none_predictions = [p.get("Label") for p in predictions.values() if p is not None and isinstance(p, dict) and p.get("Label") is not None and p.get("Label") != "Error"]
         logger.debug(f"Non-none predictions for conflict check: {non_none_predictions}")
         result = len(non_none_predictions) > 1 and len(set(non_none_predictions)) > 1
@@ -138,10 +140,10 @@ class ModelWeightManager:
     
     def _normalize_weights(self, weights):
         """Normalize weights to sum to 1"""
-        logger.info("Normalizing weights.")
+        agent_logger.log("weight_optimization", "info", "Normalizing weights.")
         total = sum(weights.values())
         if total == 0:
-            logger.warning("All weights became zero after adjustments. Reverting to equal base weights for registered models.")
+            agent_logger.log("weight_optimization", "warning", "All weights became zero after adjustments. Reverting to equal base weights for registered models.")
             # Revert to equal weights for all *registered* models if total becomes zero
             num_registered_models = len(MODEL_REGISTRY)
             if num_registered_models > 0:
@@ -149,5 +151,5 @@ class ModelWeightManager:
             else:
                 return {} # No models registered
         normalized = {k: v/total for k, v in weights.items()}
-        logger.info(f"Weights normalized. Total sum: {sum(normalized.values()):.2f}")
+        agent_logger.log("weight_optimization", "info", f"Weights normalized. Total sum: {sum(normalized.values()):.2f}")
         return normalized 

agents/smart_agents.py

@@ -1,14 +1,14 @@
-import logging
+from utils.agent_logger import AgentLogger
 import torch
 import numpy as np
 from PIL import Image # For image processing context
 # import smolagents # Removed unused import
 
-logger = logging.getLogger(__name__)
+agent_logger = AgentLogger()
 
 class ContextualIntelligenceAgent:
     def __init__(self):
-        logger.info("Initializing ContextualIntelligenceAgent.")
+        agent_logger.log("context_intelligence", "info", "Initializing ContextualIntelligenceAgent.")
         # This would be a more sophisticated model in a real scenario
         self.context_rules = {
             "high_resolution": {"min_width": 1920, "min_height": 1080, "tag": "high_resolution_image"},
@@ -23,48 +23,40 @@ class ContextualIntelligenceAgent:
         }
 
     def infer_context_tags(self, image_metadata: dict, model_predictions: dict) -> list[str]:
-        logger.info("Inferring context tags from image metadata and model predictions.")
+        agent_logger.log("context_intelligence", "info", "Inferring context tags from image metadata and model predictions.")
         detected_tags = []
-
         # Analyze image metadata
         width = image_metadata.get("width", 0)
         height = image_metadata.get("height", 0)
         mode = image_metadata.get("mode", "RGB")
-
         if width >= self.context_rules["high_resolution"]["min_width"] and \
            height >= self.context_rules["high_resolution"]["min_height"]:
             detected_tags.append(self.context_rules["high_resolution"]["tag"])
-            logger.debug(f"Detected tag: {self.context_rules['high_resolution']['tag']}")
-
+            agent_logger.log("context_intelligence", "debug", f"Detected tag: {self.context_rules['high_resolution']['tag']}")
         if width <= self.context_rules["low_resolution"]["max_width"] and \
            height <= self.context_rules["low_resolution"]["max_height"]:
             detected_tags.append(self.context_rules["low_resolution"]["tag"])
-            logger.debug(f"Detected tag: {self.context_rules['low_resolution']['tag']}")
-
+            agent_logger.log("context_intelligence", "debug", f"Detected tag: {self.context_rules['low_resolution']['tag']}")
         if mode == self.context_rules["grayscale"]["mode"]:
             detected_tags.append(self.context_rules["grayscale"]["tag"])
-            logger.debug(f"Detected tag: {self.context_rules['grayscale']['tag']}")
-
+            agent_logger.log("context_intelligence", "debug", f"Detected tag: {self.context_rules['grayscale']['tag']}")
         # Analyze model predictions for general context
         for model_id, prediction in model_predictions.items():
             label = prediction.get("Label")
             ai_score = prediction.get("AI Score", 0.0)
             real_score = prediction.get("Real Score", 0.0)
-
             if label and "potentially_natural_scene" not in detected_tags:
                 for keyword in self.context_rules["potentially_natural_scene"]["keywords"]:
                     if keyword in label and real_score >= self.context_rules["potentially_natural_scene"]["threshold"]:
                         detected_tags.append(self.context_rules["potentially_natural_scene"]["tag"])
-                        logger.debug(f"Detected tag: {self.context_rules['potentially_natural_scene']['tag']}")
+                        agent_logger.log("context_intelligence", "debug", f"Detected tag: {self.context_rules['potentially_natural_scene']['tag']}")
                         break # Only add once
-            
             if label and "potentially_ai_generated" not in detected_tags:
                 for keyword in self.context_rules["potentially_ai_generated"]["keywords"]:
                     if keyword in label and ai_score >= self.context_rules["potentially_ai_generated"]["threshold"]:
                         detected_tags.append(self.context_rules["potentially_ai_generated"]["tag"])
-                        logger.debug(f"Detected tag: {self.context_rules['potentially_ai_generated']['tag']}")
+                        agent_logger.log("context_intelligence", "debug", f"Detected tag: {self.context_rules['potentially_ai_generated']['tag']}")
                         break # Only add once
-        
         # Simulate simple scene detection based on general consensus if available
         # This is a very basic simulation; a real system would use a separate scene classification model
         if "potentially_natural_scene" in detected_tags and "potentially_ai_generated" not in detected_tags:
@@ -73,15 +65,14 @@ class ContextualIntelligenceAgent:
             if real_score > 0.8: # Placeholder for actual image feature analysis
                 detected_tags.append(self.context_rules["outdoor"]["tag"])
                 detected_tags.append(self.context_rules["sunny"]["tag"])
-                logger.debug(f"Simulated tags: {self.context_rules['outdoor']['tag']},{self.context_rules['sunny']['tag']}")
-        
-        logger.info(f"Inferred context tags: {detected_tags}")
+                agent_logger.log("context_intelligence", "debug", f"Simulated tags: {self.context_rules['outdoor']['tag']},{self.context_rules['sunny']['tag']}")
+        agent_logger.log("context_intelligence", "info", f"Inferred context tags: {detected_tags}")
         return detected_tags
 
 
 class ForensicAnomalyDetectionAgent:
     def __init__(self):
-        logger.info("Initializing ForensicAnomalyDetectionAgent.")
+        agent_logger.log("forensic_anomaly_detection", "info", "Initializing ForensicAnomalyDetectionAgent.")
         self.anomaly_thresholds = {
             "ELA": {"min_anomalies": 3, "max_error_std": 20}, # Example thresholds
             "gradient": {"min_sharp_edges": 500},
@@ -89,38 +80,32 @@ class ForensicAnomalyDetectionAgent:
         }
 
     def analyze_forensic_outputs(self, forensic_output_descriptions: list[str]) -> dict:
-        logger.info("Analyzing forensic outputs for anomalies.")
+        agent_logger.log("forensic_anomaly_detection", "info", "Analyzing forensic outputs for anomalies.")
         anomalies_detected = []
         summary_message = "No significant anomalies detected."
-
         # Example: Check for ELA anomalies (simplified)
         ela_anomalies = [desc for desc in forensic_output_descriptions if "ELA analysis" in desc and "enhanced contrast" in desc]
         if len(ela_anomalies) > self.anomaly_thresholds["ELA"]["min_anomalies"]:
             anomalies_detected.append("Multiple ELA passes indicate potential inconsistencies.")
-            logger.warning("Detected multiple ELA passes indicating potential inconsistencies.")
-
+            agent_logger.log("forensic_anomaly_detection", "warning", "Detected multiple ELA passes indicating potential inconsistencies.")
         # Example: Check for gradient anomalies (simplified)
         gradient_anomalies = [desc for desc in forensic_output_descriptions if "Gradient processing" in desc]
         if len(gradient_anomalies) > 1 and "Highlights edges and transitions" in gradient_anomalies[0]:
             # This is a placeholder for actual image analysis, e.g., checking standard deviation of gradients
             anomalies_detected.append("Gradient analysis shows unusual edge patterns.")
-            logger.warning("Detected unusual edge patterns from gradient analysis.")
-
+            agent_logger.log("forensic_anomaly_detection", "warning", "Detected unusual edge patterns from gradient analysis.")
         # Example: Check for MinMax anomalies (simplified)
         minmax_anomalies = [desc for desc in forensic_output_descriptions if "MinMax processing" in desc]
         if len(minmax_anomalies) > 1 and "Deviations in local pixel values" in minmax_anomalies[0]:
             # Placeholder for actual analysis of minmax output, e.g., deviation variance
             anomalies_detected.append("MinMax processing reveals subtle pixel deviations.")
-            logger.warning("Detected subtle pixel deviations from MinMax processing.")
-            
+            agent_logger.log("forensic_anomaly_detection", "warning", "Detected subtle pixel deviations from MinMax processing.")
         if "Bit Plane extractor" in str(forensic_output_descriptions):
             anomalies_detected.append("Bit Plane extraction performed.")
-            logger.info("Bit Plane extraction performed.")
-
+            agent_logger.log("forensic_anomaly_detection", "info", "Bit Plane extraction performed.")
         if anomalies_detected:
             summary_message = "Potential anomalies detected: " + "; ".join(anomalies_detected)
-            logger.warning(f"Forensic anomaly detection summary: {summary_message}")
+            agent_logger.log("forensic_anomaly_detection", "warning", f"Forensic anomaly detection summary: {summary_message}")
         else:
-            logger.info(f"Forensic anomaly detection summary: {summary_message}")
-
+            agent_logger.log("forensic_anomaly_detection", "info", f"Forensic anomaly detection summary: {summary_message}")
         return {"anomalies": anomalies_detected, "summary": summary_message}

app.py

@@ -41,9 +41,11 @@ os.environ['HF_HUB_CACHE'] = './models'
 
 
 # --- Gradio Log Handler ---
-from utils.logging_setup import setup_gradio_logging
-log_queue, gradio_handler = setup_gradio_logging()
-# --- End Gradio Log Handler ---
+
+# --- Per-Agent Logging Setup ---
+from utils.agent_logger import AgentLogger, AGENT_LOG_FILES
+agent_logger = AgentLogger()
+# --- End Per-Agent Logging Setup ---
 
 LOCAL_LOG_DIR = "./hf_inference_logs"
 HF_DATASET_NAME="aiwithoutborders-xyz/degentic_rd0"
@@ -73,32 +75,6 @@ class CustomFormatter(logging.Formatter):
         return formatter.format(record)
 
 
-formatter = CustomFormatter()
-
-log_file = "/tmp/gradio_log.txt"
-Path(log_file).touch()
-
-ch = logging.FileHandler(log_file)
-ch.setLevel(logging.DEBUG)
-ch.setFormatter(formatter)
-
-logger = logging.getLogger("gradio_log")
-logger.setLevel(logging.DEBUG)
-for handler in logger.handlers:
-    logger.removeHandler(handler)
-logger.addHandler(ch)
-
-
-logger.info("The logs will be displayed in here.")
-
-
-def create_log_handler(level):
-    def l(text):
-        getattr(logger, level)(text)
-
-    return l
-
-
 
 # Custom JSON Encoder to handle numpy types
 class NumpyEncoder(json.JSONEncoder):
@@ -270,7 +246,7 @@ def full_prediction(img, confidence_threshold, rotate_degrees, noise_level, shar
             logger.warning(f"Could not convert original numpy image to PIL for gallery: {e}")
     
     # Yield initial state with augmented image and empty model predictions
-    yield img_pil, cleaned_forensics_images, table_rows, "[]", "<div style='font-size: 2.2em; font-weight: bold;padding: 10px;'>Consensus: <span style='color:orange'>UNCERTAIN</span></div>"
+    yield img_pil, cleaned_forensics_images, table_rows, "[]", "<div style='font-size: 2.2em; font-weight: bold;padding: 10px;'>Consensus: <span style='color:orange'>UNCERTAIN</span></div>", None, None, None, None, None
 
 
     # Stream results as each model finishes
@@ -305,7 +281,7 @@ def full_prediction(img, confidence_threshold, rotate_degrees, noise_level, shar
             result.get("Label", "Error")
         ])
         # Yield partial results: only update the table, others are None
-        yield None, cleaned_forensics_images, table_rows, None, None # Keep cleaned_forensics_images as is (only augmented image for now)
+        yield None, cleaned_forensics_images, table_rows, None, None, None, None, None, None, None # Keep cleaned_forensics_images as is (only augmented image for now)
 
     # Multi-threaded forensic processing
     def _run_forensic_task(task_func, img_input, description, **kwargs):
@@ -343,7 +319,7 @@ def full_prediction(img, confidence_threshold, rotate_degrees, noise_level, shar
                 forensic_output_descriptions.append(description) # Keep track of descriptions for anomaly agent
                 
                 # Yield partial results: update gallery
-                yield None, cleaned_forensics_images, table_rows, None, None
+                yield None, cleaned_forensics_images, table_rows, None, None, None, None, None, None, None
 
     # After all models, compute the rest as before
     image_data_for_context = {
@@ -363,7 +339,7 @@ def full_prediction(img, confidence_threshold, rotate_degrees, noise_level, shar
         # "Bit Plane extractor: Visualization of individual bit planes from different color channels."
     ]
     detected_context_tags = context_agent.infer_context_tags(image_data_for_context, model_predictions_raw)
-    logger.info(f"Detected context tags: {detected_context_tags}")
+    agent_logger.log("context_intelligence", "info", f"Detected context tags: {detected_context_tags}")
     adjusted_weights = weight_manager.adjust_weights(model_predictions_raw, confidence_scores, context_tags=detected_context_tags)
     weighted_predictions = {"AI": 0.0, "REAL": 0.0, "UNCERTAIN": 0.0}
     for model_id, prediction in model_predictions_raw.items():
@@ -398,8 +374,9 @@ def full_prediction(img, confidence_threshold, rotate_degrees, noise_level, shar
     #     "MinMax processing (Radius=6): Deviations in local pixel values.",
     #     # "Bit Plane extractor: Visualization of individual bit planes from different color channels."
     # ]
+
     anomaly_detection_results = anomaly_agent.analyze_forensic_outputs(forensic_output_descriptions)
-    logger.info(f"Forensic anomaly detection: {anomaly_detection_results['summary']}")
+    agent_logger.log("forensic_anomaly_detection", "info", f"Forensic anomaly detection: {anomaly_detection_results['summary']}")
     consensus_html = f"<div style='font-size: 2.2em; font-weight: bold;padding: 10px;'>Consensus: <span style='color:{'red' if final_prediction_label == 'AI' else ('green' if final_prediction_label == 'REAL' else 'orange')}'>{final_prediction_label}</span></div>"
     inference_params = {
         "confidence_threshold": confidence_threshold,
@@ -440,41 +417,82 @@ def full_prediction(img, confidence_threshold, rotate_degrees, noise_level, shar
         human_feedback=None
     )
 
-    logger.info(f"Cleaned forensic images types: {[type(img) for img in cleaned_forensics_images]}")
+    agent_logger.log("ensemble_monitor", "info", f"Cleaned forensic images types: {[type(img) for img in cleaned_forensics_images]}")
     for i, res_dict in enumerate(results):
         for key in ["AI Score", "Real Score"]:
             value = res_dict.get(key)
             if isinstance(value, np.float32):
                 res_dict[key] = float(value)
-                logger.info(f"Converted {key} for result {i} from numpy.float32 to float.")
+                agent_logger.log("ensemble_monitor", "info", f"Converted {key} for result {i} from numpy.float32 to float.")
     json_results = json.dumps(results, cls=NumpyEncoder)
-    yield img_pil, cleaned_forensics_images, table_rows, json_results, consensus_html
+    # Read log file contents for each agent
+    def read_log_file(path):
+        try:
+            with open(path, "r") as f:
+                return f.read()
+        except Exception:
+            return ""
+
+    yield (
+        img_pil,
+        cleaned_forensics_images,
+        table_rows,
+        json_results,
+        consensus_html,
+        read_log_file(AGENT_LOG_FILES["context_intelligence"]),
+        read_log_file(AGENT_LOG_FILES["ensemble_monitor"]),
+        read_log_file(AGENT_LOG_FILES["weight_optimization"]),
+        read_log_file(AGENT_LOG_FILES["system_health"]),
+        read_log_file(AGENT_LOG_FILES["forensic_anomaly_detection"])
+    )
 
-detection_model_eval_playground = gr.Interface(
-    fn=full_prediction,
-    inputs=[
-        gr.Image(label="Upload Image to Analyze", sources=['upload', 'webcam'], type='filepath'),
-        gr.Slider(0.0, 1.0, value=0.7, step=0.05, label="Confidence Threshold"),
-        gr.Slider(0, 45, value=0, step=1, label="Rotate Degrees", visible=False),
-        gr.Slider(0, 50, value=0, step=1, label="Noise Level", visible=False),
-        gr.Slider(0, 50, value=0, step=1, label="Sharpen Strength", visible=False)
-    ],
-    outputs=[
-        gr.Image(label="Processed Image", visible=False),
-        gr.Gallery(label="Post Processed Images", visible=True, columns=[4], rows=[2], container=False, height="auto", object_fit="contain", elem_id="post-gallery"),
-        gr.Dataframe(
-            label="Model Predictions",
-            headers=["Arch / Dataset", "By", "AI", "Real", "Label"],
-            datatype=["str", "str", "number", "number", "str"]
-        ),
-        gr.JSON(label="Raw Model Results", visible=False),
-        gr.Markdown(label="Consensus", value="")
-    ],
-    title="Multi-Model Ensemble + Agentic Coordinated Deepfake Detection (Paper in Progress)",
-    description="The detection of AI-generated images has entered a critical inflection point. While existing solutions struggle with outdated datasets and inflated claims, our approach prioritizes agility, community collaboration, and an offensive approach to deepfake detection.",
-    api_name="predict",
-    live=True  # Enable streaming
-)
+with gr.Blocks() as detection_model_eval_playground:
+    gr.Markdown("# Multi-Model Ensemble + Agentic Coordinated Deepfake Detection (Paper in Progress)")
+    gr.Markdown("The detection of AI-generated images has entered a critical inflection point. While existing solutions struggle with outdated datasets and inflated claims, our approach prioritizes agility, community collaboration, and an offensive approach to deepfake detection.")
+    with gr.Row():
+        with gr.Column():
+            img_input = gr.Image(label="Upload Image to Analyze", sources=['upload', 'webcam'], type='filepath')
+            confidence_slider = gr.Slider(0.0, 1.0, value=0.7, step=0.05, label="Confidence Threshold")
+            rotate_slider = gr.Slider(0, 45, value=0, step=1, label="Rotate Degrees", visible=False)
+            noise_slider = gr.Slider(0, 50, value=0, step=1, label="Noise Level", visible=False)
+            sharpen_slider = gr.Slider(0, 50, value=0, step=1, label="Sharpen Strength", visible=False)
+            predict_btn = gr.Button("Run Prediction")
+        with gr.Column():
+            processed_img = gr.Image(label="Processed Image", visible=False)
+            gallery = gr.Gallery(label="Post Processed Images", visible=True, columns=[4], rows=[2], container=False, height="auto", object_fit="contain", elem_id="post-gallery")
+            predictions_df = gr.Dataframe(
+                label="Model Predictions",
+                headers=["Arch / Dataset", "By", "AI", "Real", "Label"],
+                datatype=["str", "str", "number", "number", "str"]
+            )
+            raw_json = gr.JSON(label="Raw Model Results", visible=False)
+            consensus_md = gr.Markdown(label="Consensus", value="")
+    with gr.Accordion("Agent Logs", open=False, elem_id="agent-logs-accordion"):
+        with gr.Row():
+            with gr.Column(scale=1):
+                context_intelligence_log = Log(label="Context Log", dark=True, xterm_font_size=12, log_file=AGENT_LOG_FILES["context_intelligence"])
+                ensemble_monitor_log = Log(label="Ensemble Monitor Log", dark=True, xterm_font_size=12, log_file=AGENT_LOG_FILES["ensemble_monitor"])
+            with gr.Column(scale=1):
+                weight_optimization_log = Log(label="Weight Optimization Log", dark=True, xterm_font_size=12, log_file=AGENT_LOG_FILES["weight_optimization"])
+                forensic_log = Log(label="Forensic Anomaly Log", dark=True, xterm_font_size=12, log_file=AGENT_LOG_FILES["forensic_anomaly_detection"])
+                system_health_log = Log(label="System Health Log", dark=True, xterm_font_size=12, log_file=AGENT_LOG_FILES["system_health"], visible=False)
+
+    predict_btn.click(
+        full_prediction,
+        inputs=[img_input, confidence_slider, rotate_slider, noise_slider, sharpen_slider],
+        outputs=[
+            processed_img,
+            gallery,
+            predictions_df,
+            raw_json,
+            consensus_md,
+            context_intelligence_log,
+            ensemble_monitor_log,
+            weight_optimization_log,
+            system_health_log,
+            forensic_log
+        ]
+    )
 # def echo_headers(x, request: gr.Request):
 #     print(dict(request.headers))
 #     return str(dict(request.headers))
@@ -520,6 +538,7 @@ community_forensics_preview = gr.Interface(
 #     title="Leaderboard",
 #     api_name="leaderboard"
 # )
+
 def simple_prediction(img):
     """
     Quick and simple deepfake or real image prediction by the strongest open-source model on the hub.
@@ -633,32 +652,35 @@ minmax_processing_interface = gr.Interface(
 #     log_queue.clear() # Clear the queue after retrieving
 #     return "\n".join(logs)
 
+demo = detection_model_eval_playground
+
+# demo = gr.TabbedInterface(
+#     [
+#         detection_model_eval_playground,
+#         community_forensics_preview,
+#         noise_estimation_interface,
+#         bit_plane_interface,
+#         ela_interface,
+#         gradient_processing_interface,
+#         minmax_processing_interface,
+#         # gr.Textbox(label="Agent Logs", interactive=False, lines=5, max_lines=20, autoscroll=True) # New textbox for logs
+#     ],
+#     [
+#         "Run Ensemble Prediction",
+#         "Open-Source SOTA Model",
+#         "Wavelet Blocking Noise Estimation",
+#         "Bit Plane Values",
+#         "Error Level Analysis (ELA)",
+#         "Gradient Processing",
+#         "MinMax Processing",
+#         # "Agent Logs" # New tab title
+#     ],
+#     title="Deepfake Detection & Forensics Tools",
+#     theme=None,
 
-demo = gr.TabbedInterface(
-    [
-        detection_model_eval_playground,
-        community_forensics_preview,
-        noise_estimation_interface,
-        bit_plane_interface,
-        ela_interface,
-        gradient_processing_interface,
-        minmax_processing_interface,
-        # gr.Textbox(label="Agent Logs", interactive=False, lines=5, max_lines=20, autoscroll=True) # New textbox for logs
-    ],
-    [
-        "Run Ensemble Prediction",
-        "Open-Source SOTA Model",
-        "Wavelet Blocking Noise Estimation",
-        "Bit Plane Values",
-        "Error Level Analysis (ELA)",
-        "Gradient Processing",
-        "MinMax Processing",
-        # "Agent Logs" # New tab title
-    ],
-    title="Deepfake Detection & Forensics Tools",
-    theme=None,
+# )
 
-)
+    
 footerMD = """
 ## ⚠️ ENSEMBLE TEAM IN TRAINING ⚠️ \n\n
 
@@ -673,13 +695,8 @@ footer = gr.Markdown(footerMD, elem_classes="footer")
 
 with gr.Blocks() as app:
     demo.render()
-    with gr.Row():
-        ltext = gr.Textbox(label="Enter text to write to log file")
-        for l in ["debug", "info", "warning", "error", "critical"]:
-            button = gr.Button(f"log as {l}")
-            button.click(fn=create_log_handler(l), inputs=ltext)
-        Log(log_file, dark=True).render()
+    
     footer.render()
     
 
-app.queue(max_size=10, default_concurrency_limit=2).launch(mcp_server=True) 
+app.queue(max_size=10, default_concurrency_limit=2).launch(mcp_server=True)

utils/agent_logger.py

@@ -0,0 +1,47 @@
+import logging
+from pathlib import Path
+
+AGENT_LOG_FILES = {
+    "ensemble_monitor": "./agent_logs/ensemble_monitor.log",
+    "weight_optimization": "./agent_logs/weight_optimization.log",
+    "system_health": "./agent_logs/system_health.log",
+    "context_intelligence": "./agent_logs/context_intelligence.log",
+    "forensic_anomaly_detection": "./agent_logs/forensic_anomaly_detection.log",
+}
+
+class AgentLogger:
+    def __init__(self, agent_log_files=None):
+        self.agent_log_files = agent_log_files or AGENT_LOG_FILES
+        self.loggers = {}
+        self._setup_loggers()
+
+    def _setup_loggers(self):
+        for agent, log_file in self.agent_log_files.items():
+            Path(log_file).parent.mkdir(parents=True, exist_ok=True)
+            Path(log_file).touch(exist_ok=True)
+            logger = logging.getLogger(f"agent_log.{agent}")
+            logger.setLevel(logging.DEBUG)
+            # Remove existing handlers to avoid duplicate logs
+            for handler in logger.handlers:
+                logger.removeHandler(handler)
+            handler = logging.FileHandler(log_file)
+            handler.setLevel(logging.DEBUG)
+            formatter = logging.Formatter("%(asctime)s - %(levelname)s - %(message)s (%(filename)s:%(lineno)d)")
+            handler.setFormatter(formatter)
+            logger.addHandler(handler)
+            self.loggers[agent] = logger
+
+    def log(self, agent, level, message):
+        logger = self.loggers.get(agent)
+        if logger:
+            getattr(logger, level)(message)
+        else:
+            raise ValueError(f"No logger found for agent: {agent}")
+
+    def get_log_file(self, agent):
+        return self.agent_log_files.get(agent)
+
+# Usage Example:
+# agent_logger = AgentLogger()
+# agent_logger.log("ensemble_monitor", "info", "Ensemble monitoring started.")
+# log_file_path = agent_logger.get_log_file("ensemble_monitor")