claude-mpm 3.9.9__py3-none-any.whl → 4.0.3__py3-none-any.whl

claude_mpm/services/memory/cache/shared_prompt_cache.py

@@ -22,24 +22,23 @@ Performance Impact:
 - Reduces redundant file I/O operations
 
 Usage:
-    from claude_pm.services.shared_prompt_cache import SharedPromptCache
-    
+    from claude_mpm.services.shared_prompt_cache import SharedPromptCache
+
     # Get singleton instance
     cache = SharedPromptCache.get_instance()
-    
+
     # Cache prompt data
     cache.set("engineer:profile", prompt_data, ttl=300)
-    
+
     # Retrieve cached data
     prompt_data = cache.get("engineer:profile")
-    
+
     # Invalidate specific cache entries
     cache.invalidate("engineer:profile")
 """
 
 import asyncio
 import json
-import logging
 import threading
 import time
 import weakref
@@ -47,7 +46,6 @@ from collections import OrderedDict
 from dataclasses import dataclass, field
 from datetime import datetime, timedelta
 from functools import wraps
-from pathlib import Path
 from threading import RLock
 from typing import Any, Dict, List, Optional, Set, Tuple, Union
 
@@ -57,7 +55,7 @@ from claude_mpm.core.base_service import BaseService, ServiceHealth, ServiceMetr
 @dataclass
 class CacheEntry:
     """Cache entry with TTL and metadata."""
-    
+
     key: str
     value: Any
     created_at: float
@@ -66,19 +64,19 @@ class CacheEntry:
     last_accessed: float = field(default_factory=time.time)
     size_bytes: int = 0
     metadata: Dict[str, Any] = field(default_factory=dict)
-    
+
     @property
     def is_expired(self) -> bool:
         """Check if cache entry has expired."""
         if self.ttl is None:
             return False
         return time.time() > (self.created_at + self.ttl)
-    
+
     @property
     def age_seconds(self) -> float:
         """Get age of cache entry in seconds."""
         return time.time() - self.created_at
-    
+
     def touch(self) -> None:
         """Update access metrics."""
         self.access_count += 1
@@ -88,7 +86,7 @@ class CacheEntry:
 @dataclass
 class CacheMetrics:
     """Cache performance metrics."""
-    
+
     hits: int = 0
     misses: int = 0
     sets: int = 0
@@ -98,13 +96,13 @@ class CacheMetrics:
     entry_count: int = 0
     evictions: int = 0
     expired_removals: int = 0
-    
+
     @property
     def hit_rate(self) -> float:
         """Calculate cache hit rate."""
         total = self.hits + self.misses
         return self.hits / total if total > 0 else 0.0
-    
+
     @property
     def miss_rate(self) -> float:
         """Calculate cache miss rate."""
@@ -114,59 +112,75 @@ class CacheMetrics:
 class SharedPromptCache(BaseService):
     """
     Shared Prompt Cache Service with Singleton Pattern
-    
+
     Thread-safe, high-performance caching service for subprocess agent prompts.
     Implements LRU eviction with TTL support and comprehensive metrics.
     """
-    
-    _instance: Optional['SharedPromptCache'] = None
+
+    _instance: Optional["SharedPromptCache"] = None
     _lock = threading.Lock()
-    
+
     def __init__(self, config: Optional[Dict[str, Any]] = None):
         """Initialize the shared cache service."""
         # Singleton pattern enforcement
         if SharedPromptCache._instance is not None:
-            raise RuntimeError("SharedPromptCache is a singleton. Use get_instance() instead.")
-        
+            raise RuntimeError(
+                "SharedPromptCache is a singleton. Use get_instance() instead."
+            )
+
         super().__init__("shared_prompt_cache", config)
-        
+
         # Cache configuration
-        self.max_size = self.get_config("max_size", 500)  # Reduced maximum cache entries
-        self.max_memory_mb = self.get_config("max_memory_mb", 50)  # Reduced maximum memory usage
-        self.default_ttl = self.get_config("default_ttl", 300)  # 5 minutes default TTL (was 30)
-        self.cleanup_interval = self.get_config("cleanup_interval", 60)  # 1 minute cleanup (was 5)
+        self.max_size = self.get_config(
+            "max_size", 500
+        )  # Reduced maximum cache entries
+        self.max_memory_mb = self.get_config(
+            "max_memory_mb", 50
+        )  # Reduced maximum memory usage
+        self.default_ttl = self.get_config(
+            "default_ttl", 300
+        )  # 5 minutes default TTL (was 30)
+        self.cleanup_interval = self.get_config(
+            "cleanup_interval", 60
+        )  # 1 minute cleanup (was 5)
         self.enable_metrics = self.get_config("enable_metrics", True)
-        
+
         # Memory pressure handling
-        self.memory_pressure_threshold = 0.8  # 80% of max memory triggers aggressive cleanup
+        self.memory_pressure_threshold = (
+            0.8  # 80% of max memory triggers aggressive cleanup
+        )
         self.aggressive_cleanup_active = False
-        
+
         # Cache storage - OrderedDict for LRU behavior
         self._cache: OrderedDict[str, CacheEntry] = OrderedDict()
         self._cache_lock = RLock()  # Reentrant lock for nested operations
-        
+
         # Metrics and monitoring
         self._metrics = CacheMetrics()
         self._metrics_lock = threading.Lock()
-        
+
         # Background task tracking
         self._cleanup_task: Optional[asyncio.Task] = None
-        
+
         # Cache invalidation tracking
         self._invalidation_callbacks: Dict[str, List[callable]] = {}
         self._namespace_dependencies: Dict[str, Set[str]] = {}
-        
-        self.logger.info(f"SharedPromptCache initialized with max_size={self.max_size}, "
-                        f"max_memory_mb={self.max_memory_mb}, default_ttl={self.default_ttl}s")
-    
+
+        self.logger.info(
+            f"SharedPromptCache initialized with max_size={self.max_size}, "
+            f"max_memory_mb={self.max_memory_mb}, default_ttl={self.default_ttl}s"
+        )
+
     @classmethod
-    def get_instance(cls, config: Optional[Dict[str, Any]] = None) -> 'SharedPromptCache':
+    def get_instance(
+        cls, config: Optional[Dict[str, Any]] = None
+    ) -> "SharedPromptCache":
         """
         Get the singleton instance of SharedPromptCache.
-        
+
         Args:
             config: Optional configuration (only used on first call)
-            
+
         Returns:
             Singleton instance of SharedPromptCache
         """
@@ -175,7 +189,7 @@ class SharedPromptCache(BaseService):
                 if cls._instance is None:
                     cls._instance = cls(config)
         return cls._instance
-    
+
     @classmethod
     def reset_instance(cls) -> None:
         """Reset singleton instance (for testing purposes)."""
@@ -184,85 +198,95 @@ class SharedPromptCache(BaseService):
                 if cls._instance.running:
                     asyncio.create_task(cls._instance.stop())
                 cls._instance = None
-    
+
     async def _initialize(self) -> None:
         """Initialize the cache service."""
         self.logger.info("Initializing SharedPromptCache service...")
-        
+
         # Start cleanup task
         self._cleanup_task = asyncio.create_task(self._cleanup_expired_entries())
-        
+
         # Register with memory pressure coordinator
         try:
             from .memory_pressure_coordinator import register_service_cleanup
-            await register_service_cleanup("shared_prompt_cache", self.handle_memory_pressure)
+
+            await register_service_cleanup(
+                "shared_prompt_cache", self.handle_memory_pressure
+            )
             self.logger.info("Registered with memory pressure coordinator")
         except Exception as e:
-            self.logger.warning(f"Failed to register with memory pressure coordinator: {e}")
-        
+            self.logger.warning(
+                f"Failed to register with memory pressure coordinator: {e}"
+            )
+
         # Note: Metrics collection is handled by parent class
         # Custom metrics are collected in _collect_custom_metrics()
-        
+
         self.logger.info("SharedPromptCache service initialized successfully")
-    
+
     async def _cleanup(self) -> None:
         """Cleanup cache service resources."""
         self.logger.info("Cleaning up SharedPromptCache service...")
-        
+
         # Cancel background tasks
         if self._cleanup_task:
             self._cleanup_task.cancel()
-        
+
         # Clear cache
         with self._cache_lock:
             self._cache.clear()
-        
+
         self.logger.info("SharedPromptCache service cleaned up")
-    
+
     async def _health_check(self) -> Dict[str, bool]:
         """Perform cache-specific health checks."""
         checks = {}
-        
+
         try:
             # Test cache operations
             test_key = f"__health_check_{time.time()}"
             test_value = {"test": True, "timestamp": time.time()}
-            
+
             # Test set operation
             self.set(test_key, test_value, ttl=5)
             checks["cache_set"] = True
-            
+
             # Test get operation
             retrieved = self.get(test_key)
             checks["cache_get"] = retrieved is not None and retrieved["test"] is True
-            
+
             # Test delete operation
             self.delete(test_key)
             checks["cache_delete"] = self.get(test_key) is None
-            
+
             # Check memory usage
             checks["memory_usage_ok"] = self._get_memory_usage_mb() < self.max_memory_mb
-            
+
             # Check cache size
             checks["cache_size_ok"] = len(self._cache) <= self.max_size
-            
+
         except Exception as e:
             self.logger.error(f"Cache health check failed: {e}")
             checks["cache_operations"] = False
-        
+
         return checks
-    
-    def set(self, key: str, value: Any, ttl: Optional[float] = None, 
-            metadata: Optional[Dict[str, Any]] = None) -> bool:
+
+    def set(
+        self,
+        key: str,
+        value: Any,
+        ttl: Optional[float] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> bool:
         """
         Set a cache entry with optional TTL.
-        
+
         Args:
             key: Cache key
             value: Value to cache
             ttl: Time to live in seconds (uses default_ttl if None)
             metadata: Optional metadata for the cache entry
-            
+
         Returns:
             True if successful, False otherwise
         """
@@ -271,10 +295,10 @@ class SharedPromptCache(BaseService):
                 # Use default TTL if not specified
                 if ttl is None:
                     ttl = self.default_ttl
-                
+
                 # Calculate entry size
                 size_bytes = self._calculate_size(value)
-                
+
                 # Create cache entry
                 entry = CacheEntry(
                     key=key,
@@ -282,54 +306,56 @@ class SharedPromptCache(BaseService):
                     created_at=time.time(),
                     ttl=ttl,
                     size_bytes=size_bytes,
-                    metadata=metadata or {}
+                    metadata=metadata or {},
                 )
-                
+
                 # Check if we need to evict entries
                 self._ensure_cache_capacity(size_bytes)
-                
+
                 # Remove existing entry if present
                 if key in self._cache:
                     old_entry = self._cache.pop(key)
                     with self._metrics_lock:
                         self._metrics.size_bytes -= old_entry.size_bytes
-                
+
                 # Add new entry (to end for LRU)
                 self._cache[key] = entry
-                
+
                 # Update metrics
                 with self._metrics_lock:
                     self._metrics.sets += 1
                     self._metrics.size_bytes += size_bytes
                     self._metrics.entry_count = len(self._cache)
-            
-            self.logger.debug(f"Cached key '{key}' with TTL {ttl}s, size {size_bytes} bytes")
+
+            self.logger.debug(
+                f"Cached key '{key}' with TTL {ttl}s, size {size_bytes} bytes"
+            )
             return True
-            
+
         except Exception as e:
             self.logger.error(f"Failed to set cache key '{key}': {e}")
             return False
-    
+
     def get(self, key: str) -> Optional[Any]:
         """
         Get a cache entry by key.
-        
+
         Args:
             key: Cache key to retrieve
-            
+
         Returns:
             Cached value if found and not expired, None otherwise
         """
         try:
             with self._cache_lock:
                 entry = self._cache.get(key)
-                
+
                 if entry is None:
                     # Cache miss
                     with self._metrics_lock:
                         self._metrics.misses += 1
                     return None
-                
+
                 if entry.is_expired:
                     # Entry expired, remove it
                     self._remove_entry(key, entry)
@@ -337,118 +363,124 @@ class SharedPromptCache(BaseService):
                         self._metrics.misses += 1
                         self._metrics.expired_removals += 1
                     return None
-                
+
                 # Cache hit - update access metrics and move to end (LRU)
                 entry.touch()
                 self._cache.move_to_end(key)
-                
+
                 with self._metrics_lock:
                     self._metrics.hits += 1
-                
-                self.logger.debug(f"Cache hit for key '{key}' (age: {entry.age_seconds:.1f}s)")
+
+                self.logger.debug(
+                    f"Cache hit for key '{key}' (age: {entry.age_seconds:.1f}s)"
+                )
                 return entry.value
-                
+
         except Exception as e:
             self.logger.error(f"Failed to get cache key '{key}': {e}")
             with self._metrics_lock:
                 self._metrics.misses += 1
             return None
-    
+
     def delete(self, key: str) -> bool:
         """
         Delete a cache entry.
-        
+
         Args:
             key: Cache key to delete
-            
+
         Returns:
             True if deleted, False if not found
         """
         try:
             with self._cache_lock:
                 entry = self._cache.pop(key, None)
-                
+
                 if entry is not None:
                     with self._metrics_lock:
                         self._metrics.deletes += 1
                         self._metrics.size_bytes -= entry.size_bytes
                         self._metrics.entry_count = len(self._cache)
-                    
+
                     self.logger.debug(f"Deleted cache key '{key}'")
                     return True
-                
+
                 return False
-                
+
         except Exception as e:
             self.logger.error(f"Failed to delete cache key '{key}': {e}")
             return False
-    
+
     def invalidate(self, pattern: str) -> int:
         """
         Invalidate cache entries matching a pattern.
-        
+
         Args:
             pattern: Pattern to match keys (supports wildcards *)
-            
+
         Returns:
             Number of entries invalidated
         """
         try:
             import fnmatch
-            
+
             invalidated = 0
-            
+
             with self._cache_lock:
                 keys_to_remove = []
-                
+
                 for key in self._cache.keys():
                     if fnmatch.fnmatch(key, pattern):
                         keys_to_remove.append(key)
-                
+
                 for key in keys_to_remove:
                     entry = self._cache.pop(key)
                     with self._metrics_lock:
                         self._metrics.size_bytes -= entry.size_bytes
                     invalidated += 1
-                
+
                 with self._metrics_lock:
                     self._metrics.invalidations += invalidated
                     self._metrics.entry_count = len(self._cache)
-            
-            self.logger.info(f"Invalidated {invalidated} cache entries matching pattern '{pattern}'")
-            
+
+            self.logger.info(
+                f"Invalidated {invalidated} cache entries matching pattern '{pattern}'"
+            )
+
             # Trigger invalidation callbacks
             self._trigger_invalidation_callbacks(pattern)
-            
+
             return invalidated
-            
+
         except Exception as e:
             self.logger.error(f"Failed to invalidate pattern '{pattern}': {e}")
             return 0
-    
+
     def clear(self) -> None:
         """Clear all cache entries."""
         try:
             with self._cache_lock:
                 entry_count = len(self._cache)
                 self._cache.clear()
-                
+
                 with self._metrics_lock:
                     self._metrics.size_bytes = 0
                     self._metrics.entry_count = 0
                     self._metrics.invalidations += entry_count
-            
+
             self.logger.info(f"Cleared all {entry_count} cache entries")
-            
+
         except Exception as e:
             self.logger.error(f"Failed to clear cache: {e}")
-    
+
     def get_metrics(self) -> Dict[str, Any]:
         """Get current cache metrics."""
         with self._metrics_lock:
             size_mb = self._metrics.size_bytes / (1024 * 1024)
-            memory_usage_percent = (size_mb / self.max_memory_mb * 100) if self.max_memory_mb > 0 else 0
-            
+            memory_usage_percent = (
+                (size_mb / self.max_memory_mb * 100) if self.max_memory_mb > 0 else 0
+            )
+
             return {
                 "hits": self._metrics.hits,
                 "misses": self._metrics.misses,
@@ -467,15 +499,15 @@ class SharedPromptCache(BaseService):
                 "memory_usage_percent": memory_usage_percent,
                 "memory_pressure": memory_usage_percent > 80,  # Flag high memory usage
                 "ttl_default": self.default_ttl,
-                "cleanup_interval": self.cleanup_interval
+                "cleanup_interval": self.cleanup_interval,
             }
-    
+
     def get_cache_info(self) -> Dict[str, Any]:
         """Get detailed cache information."""
         with self._cache_lock:
             entries_info = []
             total_size = 0
-            
+
             for key, entry in self._cache.items():
                 entry_info = {
                     "key": key,
@@ -484,30 +516,30 @@ class SharedPromptCache(BaseService):
                     "size_bytes": entry.size_bytes,
                     "is_expired": entry.is_expired,
                     "ttl": entry.ttl,
-                    "metadata": entry.metadata
+                    "metadata": entry.metadata,
                 }
                 entries_info.append(entry_info)
                 total_size += entry.size_bytes
-            
+
             return {
                 "total_entries": len(self._cache),
                 "total_size_bytes": total_size,
                 "total_size_mb": total_size / (1024 * 1024),
                 "entries": entries_info,
-                "metrics": self.get_metrics()
+                "metrics": self.get_metrics(),
             }
-    
+
     def register_invalidation_callback(self, pattern: str, callback: callable) -> None:
         """Register a callback for cache invalidation events."""
         if pattern not in self._invalidation_callbacks:
             self._invalidation_callbacks[pattern] = []
         self._invalidation_callbacks[pattern].append(callback)
-    
+
     def _ensure_cache_capacity(self, new_entry_size: int) -> None:
         """Ensure cache has capacity for new entry."""
         current_memory_mb = self._get_memory_usage_mb()
         max_memory_bytes = self.max_memory_mb * 1024 * 1024
-        
+
         # Check if we're under memory pressure
         memory_usage_ratio = current_memory_mb / self.max_memory_mb
         if memory_usage_ratio > self.memory_pressure_threshold:
@@ -516,61 +548,63 @@ class SharedPromptCache(BaseService):
             while self._metrics.size_bytes > target_memory_bytes:
                 if not self._evict_lru_entry():
                     break
-            self.logger.warning(f"Memory pressure detected ({memory_usage_ratio:.1%}), "
-                              f"aggressively cleaned cache to {self._get_memory_usage_mb():.1f} MB")
-        
+            self.logger.warning(
+                f"Memory pressure detected ({memory_usage_ratio:.1%}), "
+                f"aggressively cleaned cache to {self._get_memory_usage_mb():.1f} MB"
+            )
+
         # Check memory limit
         while (self._metrics.size_bytes + new_entry_size) > max_memory_bytes:
             if not self._evict_lru_entry():
                 break
-        
+
         # Check size limit
         while len(self._cache) >= self.max_size:
             if not self._evict_lru_entry():
                 break
-    
+
     def _evict_lru_entry(self) -> bool:
         """Evict least recently used entry."""
         if not self._cache:
             return False
-        
+
         # Get LRU entry (first in OrderedDict)
         key, entry = next(iter(self._cache.items()))
         self._remove_entry(key, entry)
-        
+
         with self._metrics_lock:
             self._metrics.evictions += 1
-        
+
         self.logger.debug(f"Evicted LRU entry '{key}' (age: {entry.age_seconds:.1f}s)")
         return True
-    
+
     def _remove_entry(self, key: str, entry: CacheEntry) -> None:
         """Remove entry from cache and update metrics."""
         self._cache.pop(key, None)
         with self._metrics_lock:
             self._metrics.size_bytes -= entry.size_bytes
             self._metrics.entry_count = len(self._cache)
-    
+
     def _calculate_size(self, value: Any) -> int:
         """Calculate approximate size of value in bytes."""
         try:
             # Use JSON serialization as approximation
-            return len(json.dumps(value, default=str).encode('utf-8'))
+            return len(json.dumps(value, default=str).encode("utf-8"))
         except Exception:
             # Fallback to string representation
-            return len(str(value).encode('utf-8'))
-    
+            return len(str(value).encode("utf-8"))
+
     def _get_memory_usage_mb(self) -> float:
         """Get current memory usage in MB."""
         return self._metrics.size_bytes / (1024 * 1024)
-    
+
     async def handle_memory_pressure(self, severity: str = "warning") -> Dict[str, Any]:
         """
         Handle memory pressure by aggressively cleaning cache.
-        
+
         Args:
             severity: "warning" or "critical" level of memory pressure
-            
+
         Returns:
             Dict with cleanup statistics
         """
@@ -578,9 +612,9 @@ class SharedPromptCache(BaseService):
             "entries_before": len(self._cache),
             "memory_before_mb": self._get_memory_usage_mb(),
             "entries_removed": 0,
-            "memory_freed_mb": 0
+            "memory_freed_mb": 0,
         }
-        
+
         with self._cache_lock:
             if severity == "critical":
                 # Critical: Clear 75% of cache
@@ -588,21 +622,21 @@ class SharedPromptCache(BaseService):
             else:
                 # Warning: Clear 50% of cache
                 target_entries = int(len(self._cache) * 0.5)
-            
+
             # Remove oldest entries first
             while len(self._cache) > target_entries:
                 if not self._evict_lru_entry():
                     break
                 stats["entries_removed"] += 1
-            
+
             # Force cleanup of expired entries
             expired_count = 0
             keys_to_remove = []
-            
+
             for key, entry in self._cache.items():
                 if entry.is_expired:
                     keys_to_remove.append(key)
-            
+
             for key in keys_to_remove:
                 entry = self._cache.pop(key)
                 with self._metrics_lock:
@@ -610,24 +644,26 @@ class SharedPromptCache(BaseService):
                     self._metrics.expired_removals += 1
                 expired_count += 1
                 stats["entries_removed"] += 1
-            
+
             if expired_count > 0:
                 with self._metrics_lock:
                     self._metrics.entry_count = len(self._cache)
-        
+
         stats["entries_after"] = len(self._cache)
         stats["memory_after_mb"] = self._get_memory_usage_mb()
         stats["memory_freed_mb"] = stats["memory_before_mb"] - stats["memory_after_mb"]
-        
-        self.logger.info(f"Memory pressure ({severity}): Removed {stats['entries_removed']} entries, "
-                        f"freed {stats['memory_freed_mb']:.2f} MB")
-        
+
+        self.logger.info(
+            f"Memory pressure ({severity}): Removed {stats['entries_removed']} entries, "
+            f"freed {stats['memory_freed_mb']:.2f} MB"
+        )
+
         return stats
-    
+
     def _trigger_invalidation_callbacks(self, pattern: str) -> None:
         """Trigger invalidation callbacks for pattern."""
         import fnmatch
-        
+
         for callback_pattern, callbacks in self._invalidation_callbacks.items():
             if fnmatch.fnmatch(pattern, callback_pattern):
                 for callback in callbacks:
@@ -635,43 +671,45 @@ class SharedPromptCache(BaseService):
                         callback(pattern)
                     except Exception as e:
                         self.logger.error(f"Invalidation callback failed: {e}")
-    
+
     async def _cleanup_expired_entries(self) -> None:
         """Background task to clean up expired entries."""
         while not self._stop_event.is_set():
             try:
                 expired_count = 0
-                
+
                 with self._cache_lock:
                     keys_to_remove = []
-                    
+
                     for key, entry in self._cache.items():
                         if entry.is_expired:
                             keys_to_remove.append(key)
-                    
+
                     for key in keys_to_remove:
                         entry = self._cache.pop(key)
                         with self._metrics_lock:
                             self._metrics.size_bytes -= entry.size_bytes
                             self._metrics.expired_removals += 1
                         expired_count += 1
-                    
+
                     if expired_count > 0:
                         with self._metrics_lock:
                             self._metrics.entry_count = len(self._cache)
-                
+
                 if expired_count > 0:
-                    self.logger.debug(f"Cleaned up {expired_count} expired cache entries")
-                
+                    self.logger.debug(
+                        f"Cleaned up {expired_count} expired cache entries"
+                    )
+
                 # Wait for next cleanup interval
                 await asyncio.sleep(self.cleanup_interval)
-                
+
             except asyncio.CancelledError:
                 break
             except Exception as e:
                 self.logger.error(f"Cache cleanup task error: {e}")
                 await asyncio.sleep(self.cleanup_interval)
-    
+
     async def _collect_custom_metrics(self) -> None:
         """Collect custom metrics for the service."""
         try:
@@ -682,58 +720,60 @@ class SharedPromptCache(BaseService):
                 cache_misses=metrics["misses"],
                 cache_hit_rate=metrics["hit_rate"],
                 cache_size_mb=metrics["size_mb"],
-                cache_entries=metrics["entry_count"]
+                cache_entries=metrics["entry_count"],
             )
         except Exception as e:
             self.logger.warning(f"Failed to collect cache metrics: {e}")
 
 
 # Decorator for caching function results
-def cache_result(key_pattern: str, ttl: Optional[float] = None, 
-                namespace: Optional[str] = None):
+def cache_result(
+    key_pattern: str, ttl: Optional[float] = None, namespace: Optional[str] = None
+):
     """
     Decorator to cache function results in SharedPromptCache.
-    
+
     Args:
         key_pattern: Pattern for cache key (can use {args} placeholders)
         ttl: Time to live for cached result
         namespace: Optional namespace for cache keys
-        
+
     Example:
         @cache_result("agent_profile:{agent_name}", ttl=300)
         def load_agent_profile(agent_name: str):
             # Load profile logic
             return profile_data
     """
+
     def decorator(func):
         @wraps(func)
         def wrapper(*args, **kwargs):
             # Generate cache key
             import hashlib
-            
+
             # Create key from pattern and args
             cache_key = key_pattern.format(
-                **kwargs, 
-                args_hash=hashlib.md5(str(args).encode()).hexdigest()[:8]
+                **kwargs, args_hash=hashlib.md5(str(args).encode()).hexdigest()[:8]
             )
-            
+
             if namespace:
                 cache_key = f"{namespace}:{cache_key}"
-            
+
             # Try to get from cache
             cache = SharedPromptCache.get_instance()
             result = cache.get(cache_key)
-            
+
             if result is not None:
                 return result
-            
+
             # Call function and cache result
             result = func(*args, **kwargs)
             cache.set(cache_key, result, ttl=ttl)
-            
+
             return result
-        
+
         return wrapper
+
     return decorator
 
 
@@ -755,65 +795,63 @@ if __name__ == "__main__":
         """Demonstrate SharedPromptCache usage."""
         print("🚀 SharedPromptCache Demo")
         print("=" * 50)
-        
+
         # Get cache instance
-        cache = SharedPromptCache.get_instance({
-            "max_size": 100,
-            "max_memory_mb": 10,
-            "default_ttl": 60
-        })
-        
+        cache = SharedPromptCache.get_instance(
+            {"max_size": 100, "max_memory_mb": 10, "default_ttl": 60}
+        )
+
         # Start the service
         await cache.start()
-        
+
         try:
             # Test basic operations
             print("\n📝 Testing basic cache operations...")
-            
+
             # Set some data
             cache.set("test:key1", {"data": "value1", "type": "test"})
             cache.set("test:key2", {"data": "value2", "type": "test"}, ttl=5)
-            
+
             # Get data
             result1 = cache.get("test:key1")
             result2 = cache.get("test:key2")
             print(f"Retrieved: {result1}, {result2}")
-            
+
             # Test metrics
             print("\n📊 Cache metrics:")
             metrics = cache.get_metrics()
             for key, value in metrics.items():
                 print(f"  {key}: {value}")
-            
+
             # Test invalidation
             print("\n🗑️ Testing invalidation...")
             cache.invalidate("test:*")
-            
+
             # Test decorator
             print("\n🎯 Testing cache decorator...")
-            
+
             @cache_result("demo:{name}", ttl=30)
             def get_demo_data(name: str):
                 print(f"Computing data for {name}...")
                 return {"name": name, "timestamp": time.time()}
-            
+
             # First call (cache miss)
             data1 = get_demo_data("test")
             print(f"First call: {data1}")
-            
+
             # Second call (cache hit)
             data2 = get_demo_data("test")
             print(f"Second call: {data2}")
-            
+
             # Final metrics
             print("\n📊 Final metrics:")
             final_metrics = cache.get_metrics()
             for key, value in final_metrics.items():
                 print(f"  {key}: {value}")
-                
+
         finally:
             await cache.stop()
             print("\n✅ Demo completed")
-    
+
     # Run demo
-    asyncio.run(demo())
+    asyncio.run(demo())