| import time |
| import logging |
| from typing import Any |
|
|
| from .event_bus import EventBus |
| from .memory import MemoryEngine |
| from .policy import PolicyEngine, PolicyContext |
| from .observability import ObservabilityBrain |
| from .healing import SelfHealingEngine |
|
|
| logger = logging.getLogger("qkernel.core") |
|
|
| EVENT_TYPES = { |
| "USER_MESSAGE", |
| "POLICY_DECISION", |
| "MEMORY_READ", |
| "MEMORY_WRITE", |
| "TRACE_EVENT", |
| "SERVICE_CALL", |
| "RESPONSE_READY", |
| "NODE_FAILURE", |
| "HEALING_EVENT", |
| } |
|
|
|
|
| class BaseService: |
| name: str = "base" |
|
|
| async def process(self, event: dict) -> dict: |
| raise NotImplementedError |
|
|
|
|
| class QKernel: |
| def __init__( |
| self, |
| memory: MemoryEngine | None = None, |
| policy: PolicyEngine | None = None, |
| obs: ObservabilityBrain | None = None, |
| event_bus: EventBus | None = None, |
| healer: SelfHealingEngine | None = None, |
| ): |
| self.memory = memory or MemoryEngine() |
| self.policy = policy or PolicyEngine() |
| self.obs = obs or ObservabilityBrain() |
| self.bus = event_bus or EventBus() |
| self.healer = healer or SelfHealingEngine() |
| self._services: dict[str, BaseService] = {} |
|
|
| def register_service(self, name: str, service: BaseService) -> None: |
| service.name = name |
| self._services[name] = service |
| logger.info("Service registered: %s", name) |
|
|
| def _route(self, event: dict) -> str: |
| msg_type = event.get("type", "chat") |
| if msg_type == "voice": |
| return "voice" |
| if msg_type == "network": |
| return "network" |
| return "brain" |
|
|
| async def handle(self, event: dict) -> dict: |
| start = time.time() |
| trace_id = self.obs.start_trace(event) |
|
|
| await self.bus.publish("USER_MESSAGE", event) |
|
|
| policy_start = time.time() |
| policy_ctx: PolicyContext = self.policy.evaluate(event) |
| self.obs.record_latency("policy_latency", time.time() - policy_start) |
|
|
| await self.bus.publish("POLICY_DECISION", { |
| "trace_id": trace_id, |
| "allowed": policy_ctx.allowed, |
| "route_override": policy_ctx.route_override, |
| "priority_boost": policy_ctx.priority_boost, |
| }) |
|
|
| if not policy_ctx.allowed: |
| self.obs.add_step(trace_id, "blocked_by_policy", { |
| "reason": "policy_denied", |
| }) |
| self.obs.end_trace(trace_id, success=False) |
| await self._check_healing({ |
| "latency": (time.time() - start) * 1000, |
| "error_rate": self.obs.get_metrics().get("error_rate", 0), |
| }) |
| return {"error": "blocked_by_policy", "trace_id": trace_id} |
|
|
| service_name = policy_ctx.route_override or self._route(event) |
| service = self._services.get(service_name) |
|
|
| if service is None: |
| self.obs.add_step(trace_id, "service_not_found", { |
| "service": service_name, |
| }) |
| self.obs.end_trace(trace_id, success=False) |
| return {"error": f"service_not_found: {service_name}", "trace_id": trace_id} |
|
|
| memory_start = time.time() |
| context = self.memory.read( |
| event.get("user_id", "anonymous"), |
| event.get("session_id", "default"), |
| ) |
| self.obs.record_latency("memory_latency", time.time() - memory_start) |
|
|
| self.obs.add_step(trace_id, "memory_loaded", {"context_size": len(context)}) |
|
|
| await self.bus.publish("MEMORY_READ", { |
| "trace_id": trace_id, |
| "user_id": event.get("user_id"), |
| "session_id": event.get("session_id"), |
| "context_size": len(context), |
| }) |
|
|
| enriched = { |
| **event, |
| "context": context, |
| "trace_id": trace_id, |
| } |
|
|
| await self.bus.publish("SERVICE_CALL", { |
| "trace_id": trace_id, |
| "service": service_name, |
| }) |
|
|
| service_start = time.time() |
| result = await service.process(enriched) |
| self.obs.record_latency("service_latency", time.time() - service_start) |
|
|
| self.obs.add_step(trace_id, "service_completed", { |
| "service": service_name, |
| "latency": time.time() - service_start, |
| }) |
|
|
| response_text = result.get("response", "") |
|
|
| memory_write_start = time.time() |
| self.memory.write( |
| event.get("user_id", "anonymous"), |
| event.get("session_id", "default"), |
| "assistant", |
| response_text, |
| ) |
| self.obs.record_latency("memory_latency", time.time() - memory_write_start) |
|
|
| await self.bus.publish("MEMORY_WRITE", { |
| "trace_id": trace_id, |
| "response_length": len(response_text), |
| }) |
|
|
| self.obs.end_trace(trace_id, success=True) |
|
|
| await self.bus.publish("RESPONSE_READY", { |
| "trace_id": trace_id, |
| "response_length": len(response_text), |
| }) |
|
|
| total_time = time.time() - start |
| await self._check_healing({ |
| "latency": total_time * 1000, |
| "error_rate": self.obs.get_metrics().get("error_rate", 0), |
| }) |
|
|
| return { |
| **result, |
| "trace_id": trace_id, |
| "processing_time_ms": round(total_time * 1000, 2), |
| } |
|
|
| async def _check_healing(self, metrics: dict) -> None: |
| if self.healer.detect(metrics): |
| await self.bus.publish("HEALING_EVENT", metrics) |
|
|
| def get_stats(self) -> dict: |
| return { |
| "memory": self.memory.get_stats(), |
| "metrics": self.obs.get_metrics(), |
| "services": list(self._services.keys()), |
| "healing_history": len(self.healer.get_history()), |
| } |
|
|
