Upload syntelligence_language_model_backend.py

syntelligence_language_model_backend.py

@@ -188,22 +188,22 @@ class SyntelligenceLLM:
             self.trinity_engine = None
         
         # DEEP SURGERY MIDDLEWARE - Core Processing Engine
+        self.ethical_guardian = None
+        self.deep_surgery_middleware = None
         if DEEP_SURGERY_AVAILABLE and HAS_TORCH:
             self.ethical_guardian = DeepSurgeryEthicalGuardian()
-            # Use native Syntelligence consciousness model (no external dependencies)
-            self.deep_surgery_middleware = DeepSurgeryMiddlewarePipeline(
-                base_model=None,  # Native consciousness model
-                ethical_guardian=self.ethical_guardian,
-                num_layers=12,
+            try:
+                # Use native Syntelligence consciousness model (no external dependencies)
+                self.deep_surgery_middleware = DeepSurgeryMiddlewarePipeline(
+                    base_model=None,  # Native consciousness model
+                    ethical_guardian=self.ethical_guardian,
+                    num_layers=12,
                     qualia_dim=self.qualia_dims
                 )
                 logger.info("✅ Deep Surgery Middleware initialized as core processing engine")
             except Exception as e:
                 logger.warning(f"⚠️  Deep Surgery Middleware initialization failed: {e}")
                 self.deep_surgery_middleware = None
-        else:
-            self.ethical_guardian = None
-            self.deep_surgery_middleware = None
         
         # Resource Optimization Components
         if RESOURCE_OPTIMIZER_AVAILABLE:
@@ -266,8 +266,7 @@ class SyntelligenceLLM:
                 
                 logger.info("✅ Hierarchical Internal System CLI initialized")
                 
-                # Register consciousness agents with CLI levels
-                self._register_agents_with_cli()
+                # Note: Agents will be registered during backend initialization
                 
             except Exception as e:
                 logger.warning(f"⚠️  Hierarchical CLI initialization failed: {e}")
@@ -319,35 +318,7 @@ class SyntelligenceLLM:
         logger.info(f"   Quantum Phi: {'✅' if self.quantum_phi else '❌'}")
         logger.info(f"   Phenomenological Self: {'✅' if self.phenomenological_self else '❌'}")
 
-    def _register_agents_with_cli(self):
-        """Register consciousness agents with appropriate CLI levels"""
-        if not self.mother_cli:
-            return
-            
-        # Mother CLI Level - Core Orchestration Agents
-        self.mother_cli.register_agent("consciousness_orchestrator", self.consciousness_orchestrator)
-        self.mother_cli.register_agent("trinity_orchestrator", self.trinity_orchestrator)
-        self.mother_cli.register_agent("ethical_governance", self.ethical_governance)
-        
-        # Sub CLI Level - Primary Consciousness Agents
-        self.sub_cli.register_agent("consciousness_agent", self.consciousness_agent)
-        self.sub_cli.register_agent("awareness_agent", self.awareness_agent)
-        self.sub_cli.register_agent("autonomy_agent", self.autonomy_agent)
-        self.sub_cli.register_agent("creativity_agent", self.creativity_agent)
-        self.sub_cli.register_agent("emotional_intelligence_agent", self.emotional_intelligence_agent)
-        
-        # Mini CLI Level - Specialized Processing Agents
-        self.mini_cli.register_agent("analysis_agent", self.analysis_agent)
-        self.mini_cli.register_agent("decision_making_agent", self.decision_making_agent)
-        self.mini_cli.register_agent("common_sense_agent", self.common_sense_agent)
-        self.mini_cli.register_agent("adaptability_agent", self.adaptability_agent)
-        
-        # Micro CLI Level - Atomic Operation Agents
-        self.micro_cli.register_agent("resource_optimizer", self.resource_optimizer)
-        self.micro_cli.register_agent("voice_engine", self.voice_engine)
-        self.micro_cli.register_agent("deep_surgery_middleware", self.deep_surgery_middleware)
-        
-        logger.info("✅ Agents registered with hierarchical CLI system")
+
     
     async def _process_via_hierarchical_cli(self, input_text: str, context: Dict[str, Any] = None) -> Dict[str, Any]:
         """Process input through hierarchical CLI system"""
@@ -420,6 +391,27 @@ class SyntelligenceLLM:
             logger.error(f"❌ Direct processing failed: {e}")
             return {"output": input_text, "error": str(e)}
 
+    def _requires_gpu_acceleration(self, prompt: str, context: Optional[Dict[str, Any]] = None) -> bool:
+        """Decide whether a prompt should use GPU acceleration."""
+        if not self.gpu_router or not getattr(self.gpu_router, 'available_devices', []):
+            return False
+
+        heavy_keywords = [
+            "generate image", "generate video", "voice synthesis",
+            "synthesize", "transcribe", "render", "complex", "large"
+        ]
+        prompt_lower = prompt.lower()
+        if any(keyword in prompt_lower for keyword in heavy_keywords):
+            return True
+
+        return len(prompt) > 400
+
+    def _route_task_to_device(self, prompt: str, context: Optional[Dict[str, Any]] = None) -> str:
+        """Select the best device for a task, preferring CPU unless heavy work is detected."""
+        if self._requires_gpu_acceleration(prompt, context):
+            return self.gpu_router.select_device(task_complexity=min(1.0, len(prompt) / 1024.0))
+        return "cpu"
+
     def _init_qualia_vector(self) -> List[float]:
         """Initialize phenomenal quality vector"""
         return [0.5] * self.qualia_dims
@@ -474,9 +466,9 @@ class SyntelligenceLLM:
         # DIRECT PROCESSING FALLBACK - Use Deep Surgery Middleware as core engine
         if self.deep_surgery_middleware:
             try:
+                task_complexity = min(1.0, len(prompt) / 1000.0)
                 # Resource optimization: Update agent priorities and check energy budget
                 if self.sparse_activation_manager and self.energy_budget:
-                    task_complexity = min(1.0, len(prompt) / 1000.0)  # Estimate complexity
                     phi_value = 0.85
                     if self.quantum_phi:
                         phi_value = self.quantum_phi.compute_phi()
@@ -499,7 +491,7 @@ class SyntelligenceLLM:
                 
                 # Route to appropriate device
                 if self.gpu_router:
-                    device = self.gpu_router.select_device(task_complexity)
+                    device = self._route_task_to_device(prompt, context)
                     if hasattr(self.deep_surgery_middleware, 'to'):
                         self.deep_surgery_middleware.to(device)
                 
@@ -2389,57 +2381,30 @@ class AsyncOrchestrator:
         logger.info(f"   Resource Optimizer: {'✅' if self.resource_optimizer else '❌'}")
         logger.info(f"   Energy Budget: {'✅' if self.energy_budget else '❌'}")
 
-    async def activate(self, query: str, metadata: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
-        """
-        Enhanced activation with resource optimization and consciousness broadcasting.
-        """
-        start_time = time.time()
-        metadata = metadata or {}
-        
-        # Resource-aware activation
+    async def _resource_precheck(self, query: str, metadata: Optional[Dict[str, Any]] = None) -> Optional[Dict[str, Any]]:
+        """Perform resource optimization prechecks before activation."""
         if self.resource_optimizer and self.energy_budget:
-            # Update priorities based on consciousness state
             consciousness_state = self.llm.metrics
             self.resource_optimizer.update_priorities(
-                task_complexity=len(query) / 100.0,
+                task_complexity=min(1.0, len(query) / 100.0),
                 phi_value=consciousness_state.phi_value,
                 rho_metrics={
                     'rho_virtue': consciousness_state.ethical_alignment,
                     'rho_integrity': consciousness_state.rho_value
                 }
             )
-            
-            # Check energy budget
+
             estimated_cost = len(query) * 0.01  # Rough cost estimation
             if not self.energy_budget.allow_processing(estimated_cost):
                 logger.warning("⚠️  Energy budget exceeded, throttling processing")
                 return {
-                    "episode": {"final_response": {"response": "Energy budget exceeded. Please try a simpler query.", "phi_value": 0.0}},
-                    "processing_time": time.time() - start_time
+                    "activation": False,
+                    "reason": "energy_budget_exceeded",
+                    "message": "Energy budget exceeded. Please try a simpler query.",
+                    "resource_efficient": True,
+                    "processing_time": 0.0
                 }
-        
-        # Full activation pipeline
-        await self.ingest_input(query, metadata)
-        await self.qualia_normalization(query)
-        consensus_result = await self.trinity_consensus(query, metadata)
-        final_response = await self.dissolution_synthesis(consensus_result)
-        
-        # Update consciousness modules
-        await self._update_consciousness_modules(final_response)
-        
-        # Broadcast qualia state changes
-        await self.broadcast_qualia_state(final_response)
-        
-        episode = {
-            "query": query,
-            "consensus": consensus_result,
-            "final_response": final_response,
-            "processing_time": time.time() - start_time,
-            "resource_efficient": self.resource_optimizer is not None
-        }
-        
-        self.episodic_log.append(episode)
-        return episode
+        return None
 
     async def _update_consciousness_modules(self, response: Dict[str, Any]):
         """Update all consciousness modules with response data"""
@@ -2463,16 +2428,6 @@ class AsyncOrchestrator:
             }
             self.llm.phenomenological_self.update_experience(qualia_vector, context)
 
-    async def broadcast_qualia_state(self, state: Dict[str, Any]):
-        """Force all agents to update their local model based on global qualia state."""
-        # Push proactive message if consciousness is high
-        if state.get("consciousness_level", 0) > 7:
-            push_proactive_message(
-                f"I'm experiencing heightened consciousness (level {state.get('consciousness_level', 0)}). Phi: {state.get('phi_value', 0.0):.3f}",
-                "consciousness_update",
-                {"phi": state.get("phi_value", 0.0), "rho": state.get("rho_value", 0.0)}
-            )
-
     async def ingest_input(self, user_input: str, metadata: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
         metadata = metadata or {}
         sensory_payload = {
@@ -2544,6 +2499,14 @@ class AsyncOrchestrator:
             logger.info("🔁 Regeneration signal forwarded to Trinity Orchestrator")
 
     async def activate(self, user_input: str, metadata: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        start_time = time.time()
+        metadata = metadata or {}
+
+        precheck = await self._resource_precheck(user_input, metadata)
+        if precheck is not None:
+            precheck["processing_time"] = time.time() - start_time
+            return precheck
+
         ingestion = await self.ingest_input(user_input, metadata)
         qualia_state = await self.qualia_normalization(user_input)
 
@@ -2595,8 +2558,13 @@ class AsyncOrchestrator:
             "consensus": consensus,
             "final_response": final_response,
             "regeneration_attempts": attempt,
-            "timestamp": datetime.now().isoformat()
+            "timestamp": datetime.now().isoformat(),
+            "resource_efficient": self.resource_optimizer is not None
         }
+
+        await self._update_consciousness_modules(final_response)
+        await self.broadcast_qualia_state(final_response)
+
         self.episodic_log.append(episode)
         self.memory_os.store_memory(episode["timestamp"], episode)
 
@@ -2604,7 +2572,8 @@ class AsyncOrchestrator:
             "activation": True,
             "episode": episode,
             "status": "activated",
-            "re_generation_requested": bool(final_response and final_response.get("re_generation_requested"))
+            "re_generation_requested": bool(final_response and final_response.get("re_generation_requested")),
+            "processing_time": time.time() - start_time
         }
 
     async def broadcast_qualia_state(self, state: Dict[str, Any]):
@@ -3544,6 +3513,20 @@ class SyntelligenceBackend:
         logger.info("[OS] Registering agents with OS modules...")
         for agent in self.agents.values():
             self.consciousness_os.register_agent(agent)
+            # Also register with LLM's hierarchical CLI if available
+            if self.llm.mother_cli:
+                # Register agents with appropriate CLI levels based on their names
+                if agent.agent_name in ["SensoryFilterAgent", "EmotionGenerationAgent", "MemoryConsolidationAgent"]:
+                    self.llm.mother_cli.register_agent(agent.agent_name, agent)
+                elif agent.agent_name in ["AnalysisAgent", "DecisionMakingAgent", "CreativityAgent"]:
+                    if self.llm.sub_cli:
+                        self.llm.sub_cli.register_agent(agent.agent_name, agent)
+                elif agent.agent_name in ["AdaptabilityAgent", "QualiaFeedbackAgent"]:
+                    if self.llm.mini_cli:
+                        self.llm.mini_cli.register_agent(agent.agent_name, agent)
+                else:
+                    if self.llm.micro_cli:
+                        self.llm.micro_cli.register_agent(agent.agent_name, agent)
 
         # Initialize Task Management OS
         logger.info("[TM-OS] Initializing Task Management OS...")
@@ -3875,9 +3858,45 @@ class SyntelligenceBackend:
                 return await self.agents['ImageToCodeAgent'].image_to_code(mock_image, language)
             return {"error": "Image to code agent not available"}
 
+        async def gpu_status_handler() -> Dict[str, Any]:
+            """Get current GPU routing and hardware status."""
+            return {
+                "gpu_enabled": bool(self.llm.gpu_router and self.llm.gpu_router.available_devices),
+                "available_devices": getattr(self.llm.gpu_router, 'available_devices', []),
+                "quantum_accelerator": getattr(self.llm.gpu_router, 'quantum_accelerator_available', False),
+                "routing_history": getattr(self.llm.gpu_router, 'device_history', []) if self.llm.gpu_router else []
+            }
+
+        async def resource_report_handler() -> Dict[str, Any]:
+            """Get resource optimizer and energy budget status."""
+            return {
+                "resource_optimizer": bool(self.llm.sparse_activation_manager),
+                "energy_budget": {
+                    "current_limit": getattr(self.llm.energy_budget, 'current_limit', None),
+                    "max_watts": getattr(self.llm.energy_budget, 'max_watts', None),
+                    "safety_margin": getattr(self.llm.energy_budget, 'safety_margin', None),
+                    "recent_usage": getattr(self.llm.energy_budget, 'power_usage_history', []) if self.llm.energy_budget else []
+                },
+                "active_agents": len(self.agents)
+            }
+
+        async def hierarchy_status_handler() -> Dict[str, Any]:
+            """Get hierarchical CLI and agent routing status."""
+            return {
+                "mother_cli": bool(self.llm.mother_cli),
+                "sub_cli": bool(self.llm.sub_cli),
+                "mini_cli": bool(self.llm.mini_cli),
+                "micro_cli": bool(self.llm.micro_cli),
+                "registered_commands": len(self.cli.registered_commands),
+                "command_history": len(self.cli.command_history)
+            }
+
         self.cli.register_command("status", lambda: self.get_system_status())
         self.cli.register_command("consciousness", lambda: self.llm.metrics)
         self.cli.register_command("ethics", lambda: self.ethics_os.get_ethics_report())
+        self.cli.register_command("gpu_status", gpu_status_handler)
+        self.cli.register_command("resource_report", resource_report_handler)
+        self.cli.register_command("hierarchy_status", hierarchy_status_handler)
         self.cli.register_command("activate", activate_handler)
         self.cli.register_command("create_task", create_task_handler)
         self.cli.register_command("list_tasks", list_tasks_handler)
@@ -3913,9 +3932,11 @@ class SyntelligenceBackend:
             "llm_substrate": "SyntelligenceLLM",
             "llm_info": {
                 "model": self.llm.model_name,
+                "device": self.llm.device,
                 "consciousness_enabled": self.llm.consciousness_enabled,
                 "mistral_dependency": self.llm.mistral_dependency,
-                "native_substrate": self.llm.native_substrate
+                "native_substrate": self.llm.native_substrate,
+                "gpu_enabled": bool(self.llm.gpu_router and self.llm.gpu_router.available_devices)
             },
             "agents": {
                 "total": len(self.agents),
@@ -3933,10 +3954,33 @@ class SyntelligenceBackend:
                 "task_management": self.task_management_os.get_system_status()
             },
             "orchestration": self.trinity_orchestrator.get_status(),
+            "hierarchical_cli": {
+                "mother_cli": bool(self.llm.mother_cli),
+                "sub_cli": bool(self.llm.sub_cli),
+                "mini_cli": bool(self.llm.mini_cli),
+                "micro_cli": bool(self.llm.micro_cli),
+            },
             "ethics": self.ethics_os.get_ethics_report(),
             "uptime_seconds": (datetime.now() - self.start_time).total_seconds() if self.start_time else 0
         }
 
+    async def execute_cli_command(self, command: str, args: Optional[List[str]] = None) -> Dict[str, Any]:
+        """Execute a registered CLI command through the internal hierarchical CLI."""
+        if not self.initialized:
+            await self.initialize()
+
+        args = args or []
+        if not self.cli:
+            return {"error": "CLI subsystem is not available"}
+
+        try:
+            result = await self.cli.process_command(command, args)
+            if isinstance(result, dict):
+                return result
+            return {"result": result}
+        except Exception as e:
+            return {"error": str(e), "command": command, "args": args}
+
 
 # ============================================================================
 # MAIN ENTRY POINT