feat: add pickle serialization support to core engine classes

Add __getstate__ and __setstate__ methods to AgentManager, SpacesApp, CachedReasoningEngine, OptimizedPlanningEngine, and other core classes to handle non-serializable objects like loggers during distributed processing. This enables proper object serialization for parallel/distributed execution environments by excluding logger objects from pickling and restoring them on unpickling.

app.py

@@ -211,20 +211,30 @@ class AgentManager:
         self.config = config
         self.agents = {}
         self.agent_stats = {}
-        self._request_queue = None
         self._performance_metrics = {
-            "total_requests": 0,
-            "successful_requests": 0,
-            "failed_requests": 0,
-            "average_response_time": 0.0,
-            "memory_usage": [],
-            "cpu_usage": [],
-            "timestamps": []
+        "total_requests": 0,
+        "successful_requests": 0,
+        "failed_requests": 0,
+        "average_response_time": 0.0,
+        "memory_usage": [],
+        "cpu_usage": [],
+        "timestamps": []
         }
 
         # Don't initialize agents during construction to avoid pickling issues
         # Agents will be created lazily when first requested
         logger.info("Agent manager initialized (agents will be created lazily)")
+        
+        def __getstate__(self):
+            """Custom pickling to handle non-serializable objects."""
+            state = self.__dict__.copy()
+            # Remove any non-serializable objects if they exist
+            return state
+        
+        def __setstate__(self, state):
+            """Custom unpickling to restore object state."""
+            self.__dict__.update(state)
+            # Reinitialize any necessary components
     
     def _initialize_default_agents(self):
         """Initialize default agent instances lazily."""
@@ -417,9 +427,22 @@ class SpacesApp:
 
         # Setup logging level
         logging.getLogger().setLevel(getattr(logging, self.config.config["log_level"]))
-
+        
         logger.info("Spaces application initialized successfully")
         
+        def __getstate__(self):
+            """Custom pickling to handle non-serializable objects."""
+            state = self.__dict__.copy()
+            # Remove any non-serializable objects
+            state['_validator'] = None  # Will be reinitialized on unpickling
+            return state
+        
+        def __setstate__(self, state):
+            """Custom unpickling to restore object state."""
+            self.__dict__.update(state)
+            # Reinitialize validator on demand
+            self._validator = None
+        
     @property
     def validator(self):
         """Lazy initialization of RequestValidator."""

autonomous_engine.py

@@ -273,7 +273,23 @@ class CachedReasoningEngine:
         self.agent_name = agent_name
         self.logger = logging.getLogger(f"{__name__}.{agent_name}")
         self.knowledge_base = {}
-        self.decision_history = deque(maxlen=1000)  # Keep last 1000 decisions
+        self.decision_history = deque(maxlen=1000) # Keep last 1000 decisions
+        
+        def __getstate__(self):
+            """Custom pickling to handle non-serializable objects."""
+            state = self.__dict__.copy()
+            # Remove logger as it's not serializable
+            state['logger'] = None
+            return state
+        
+        def __setstate__(self, state):
+            """Custom unpickling to restore object state."""
+            self.__dict__.update(state)
+            # Restore logger
+            if hasattr(self, 'agent_name'):
+                self.logger = logging.getLogger(f"{__name__}.{self.agent_name}")
+            else:
+                self.logger = logging.getLogger(__name__)
 
     @lru_cache(maxsize=1000)
     def _analyze_input_hash(self, user_input_hash: str) -> Dict[str, Any]:
@@ -633,6 +649,22 @@ class OptimizedPlanningEngine:
         self.logger = logging.getLogger(f"{__name__}.{agent_name}")
         self.plans = {}
         self.execution_history = []
+        
+        def __getstate__(self):
+            """Custom pickling to handle non-serializable objects."""
+            state = self.__dict__.copy()
+            # Remove logger as it's not serializable
+            state['logger'] = None
+            return state
+        
+        def __setstate__(self, state):
+            """Custom unpickling to restore object state."""
+            self.__dict__.update(state)
+            # Restore logger
+            if hasattr(self, 'agent_name'):
+                self.logger = logging.getLogger(f"{__name__}.{self.agent_name}")
+            else:
+                self.logger = logging.getLogger(__name__)
 
     def create_plan(self, analysis: Dict[str, Any], user_input: str) -> Plan:
         """Create a comprehensive execution plan with validation."""
@@ -828,7 +860,23 @@ class OptimizedExecutionEngine:
         self.active_executions = {}
         self.execution_metrics = {}
         self.max_retries = 3
-        self.retry_delay = 1.0  # seconds
+        self.retry_delay = 1.0 # seconds
+        
+        def __getstate__(self):
+            """Custom pickling to handle non-serializable objects."""
+            state = self.__dict__.copy()
+            # Remove logger as it's not serializable
+            state['logger'] = None
+            return state
+        
+        def __setstate__(self, state):
+            """Custom unpickling to restore object state."""
+            self.__dict__.update(state)
+            # Restore logger
+            if hasattr(self, 'agent_name'):
+                self.logger = logging.getLogger(f"{__name__}.{self.agent_name}")
+            else:
+                self.logger = logging.getLogger(__name__)
 
     @asynccontextmanager
     async def execution_context(self, plan: Plan):
@@ -1230,8 +1278,24 @@ class RefactoredAutonomousAgent:
             "failed_executions": 0,
             "average_response_time": 0.0
         }
-
+        
         self.logger.info(f"Autonomous agent {agent_name} initialized")
+        
+        def __getstate__(self):
+            """Custom pickling to handle non-serializable objects."""
+            state = self.__dict__.copy()
+            # Remove logger as it's not serializable
+            state['logger'] = None
+            return state
+        
+        def __setstate__(self, state):
+            """Custom unpickling to restore object state."""
+            self.__dict__.update(state)
+            # Restore logger
+            if hasattr(self, 'agent_name'):
+                self.logger = logging.getLogger(f"{__name__}.{self.agent_name}")
+            else:
+                self.logger = logging.getLogger(__name__)
 
     @rate_limit(calls_per_minute=100)  # Rate limit: 100 requests per minute
     @validate_input  # Validate and sanitize input