jaf-py 2.5.9__py3-none-any.whl → 2.5.11__py3-none-any.whl

jaf/core/guardrails.py

@@ -31,7 +31,7 @@ from .types import (
     GuardrailEvent,
     GuardrailEventData,
     GuardrailViolationEvent,
-    GuardrailViolationEventData
+    GuardrailViolationEventData,
 )
 
 # Constants for content length limits
@@ -48,7 +48,7 @@ OUTPUT_GUARDRAIL_TIMEOUT_MS = 15000
 
 class GuardrailCircuitBreaker:
     """Circuit breaker for guardrail execution to handle repeated failures."""
-    
+
     def __init__(self, max_failures: int = 5, reset_time_ms: int = 60000):
         self.failures = 0
         self.last_failure_time = 0
@@ -59,12 +59,12 @@ class GuardrailCircuitBreaker:
         """Check if circuit breaker is open (blocking requests)."""
         if self.failures < self.max_failures:
             return False
-        
+
         time_since_last_failure = (time.time() * 1000) - self.last_failure_time
         if time_since_last_failure > self.reset_time_ms:
             self.failures = 0
             return False
-        
+
         return True
 
     def record_failure(self) -> None:
@@ -79,14 +79,17 @@ class GuardrailCircuitBreaker:
     def should_be_cleaned_up(self, max_age: int) -> bool:
         """Check if this circuit breaker should be cleaned up."""
         now = time.time() * 1000
-        return (self.last_failure_time > 0 and 
-                (now - self.last_failure_time) > max_age and 
-                not self.is_open())
+        return (
+            self.last_failure_time > 0
+            and (now - self.last_failure_time) > max_age
+            and not self.is_open()
+        )
 
 
 @dataclass
 class CacheEntry:
     """Cache entry for guardrail results."""
+
     result: ValidationResult
     timestamp: float
     hit_count: int = 1
@@ -94,7 +97,7 @@ class CacheEntry:
 
 class GuardrailCache:
     """LRU cache for guardrail results."""
-    
+
     def __init__(self, max_size: int = 1000, ttl_ms: int = 300000):
         self.cache: Dict[str, CacheEntry] = {}
         self.max_size = max_size
@@ -105,7 +108,7 @@ class GuardrailCache:
         content_hash = self._hash_string(content[:1000])
         rule_hash = self._hash_string(rule_prompt)
         return f"guardrail_{stage}_{model_name}_{rule_hash}_{content_hash}_{len(content)}"
-    
+
     def _hash_string(self, s: str) -> str:
         """Simple hash function for strings."""
         hash_val = 0
@@ -122,47 +125,47 @@ class GuardrailCache:
         """Evict least recently used entry."""
         if len(self.cache) < self.max_size:
             return
-        
+
         lru_key: Optional[str] = None
-        lru_score = float('inf')
+        lru_score = float("inf")
         now = time.time() * 1000
-        
+
         for key, entry in self.cache.items():
             age_hours = (now - entry.timestamp) / (1000 * 60 * 60)
             score = entry.hit_count / (1 + age_hours)
             if score < lru_score:
                 lru_score = score
                 lru_key = key
-        
+
         if lru_key:
             del self.cache[lru_key]
 
-    def get(self, stage: str, rule_prompt: str, content: str, model_name: str) -> Optional[ValidationResult]:
+    def get(
+        self, stage: str, rule_prompt: str, content: str, model_name: str
+    ) -> Optional[ValidationResult]:
         """Get cached result."""
         key = self._create_key(stage, rule_prompt, content, model_name)
         entry = self.cache.get(key)
-        
+
         if not entry or self._is_expired(entry):
             if entry:
                 del self.cache[key]
             return None
-        
+
         entry.hit_count += 1
         entry.timestamp = time.time() * 1000
-        
+
         return entry.result
 
-    def set(self, stage: str, rule_prompt: str, content: str, model_name: str, result: ValidationResult) -> None:
+    def set(
+        self, stage: str, rule_prompt: str, content: str, model_name: str, result: ValidationResult
+    ) -> None:
         """Cache a result."""
         key = self._create_key(stage, rule_prompt, content, model_name)
-        
+
         self._evict_lru()
-        
-        self.cache[key] = CacheEntry(
-            result=result,
-            timestamp=time.time() * 1000,
-            hit_count=1
-        )
+
+        self.cache[key] = CacheEntry(result=result, timestamp=time.time() * 1000, hit_count=1)
 
     def clear(self) -> None:
         """Clear all cached entries."""
@@ -170,10 +173,7 @@ class GuardrailCache:
 
     def get_stats(self) -> Dict[str, Any]:
         """Get cache statistics."""
-        return {
-            'size': len(self.cache),
-            'max_size': self.max_size
-        }
+        return {"size": len(self.cache), "max_size": self.max_size}
 
 
 # Global instances
@@ -202,19 +202,26 @@ async def _create_llm_guardrail(
     stage: str,
     rule_prompt: str,
     fast_model: Optional[str] = None,
-    fail_safe: str = 'allow',
-    timeout_ms: int = 30000
+    fail_safe: str = "allow",
+    timeout_ms: int = 30000,
 ) -> Guardrail:
     """Create an LLM-based guardrail function."""
-    
+
     async def guardrail_func(content: Any) -> ValidationResult:
         content_str = str(content) if not isinstance(content, str) else content
-        
+
         model_to_use = fast_model or config.default_fast_model
         if not model_to_use:
-            print(f"[JAF:GUARDRAILS] No fast model available for LLM guardrail evaluation, using failSafe: {fail_safe}")
-            return (ValidValidationResult() if fail_safe == 'allow' 
-                   else InvalidValidationResult(error_message='No model available for guardrail evaluation'))
+            print(
+                f"[JAF:GUARDRAILS] No fast model available for LLM guardrail evaluation, using failSafe: {fail_safe}"
+            )
+            return (
+                ValidValidationResult()
+                if fail_safe == "allow"
+                else InvalidValidationResult(
+                    error_message="No model available for guardrail evaluation"
+                )
+            )
 
         # Check cache first
         cached_result = _guardrail_cache.get(stage, rule_prompt, content_str, model_to_use)
@@ -225,35 +232,52 @@ async def _create_llm_guardrail(
         # Check circuit breaker
         circuit_breaker = _get_circuit_breaker(stage, model_to_use)
         if circuit_breaker.is_open():
-            print(f"[JAF:GUARDRAILS] Circuit breaker open for {stage} guardrail on model {model_to_use}, using failSafe: {fail_safe}")
-            return (ValidValidationResult() if fail_safe == 'allow' 
-                   else InvalidValidationResult(error_message='Circuit breaker open - too many recent failures'))
+            print(
+                f"[JAF:GUARDRAILS] Circuit breaker open for {stage} guardrail on model {model_to_use}, using failSafe: {fail_safe}"
+            )
+            return (
+                ValidValidationResult()
+                if fail_safe == "allow"
+                else InvalidValidationResult(
+                    error_message="Circuit breaker open - too many recent failures"
+                )
+            )
 
         # Validate content
         if not content_str:
             print(f"[JAF:GUARDRAILS] Invalid content provided to {stage} guardrail")
-            return (ValidValidationResult() if fail_safe == 'allow' 
-                   else InvalidValidationResult(error_message='Invalid content provided to guardrail'))
+            return (
+                ValidValidationResult()
+                if fail_safe == "allow"
+                else InvalidValidationResult(error_message="Invalid content provided to guardrail")
+            )
 
         # Check content length
-        max_content_length = SHORT_TIMEOUT_MAX_CONTENT if timeout_ms < 10000 else LONG_TIMEOUT_MAX_CONTENT
+        max_content_length = (
+            SHORT_TIMEOUT_MAX_CONTENT if timeout_ms < 10000 else LONG_TIMEOUT_MAX_CONTENT
+        )
         if len(content_str) > max_content_length:
-            print(f"[JAF:GUARDRAILS] Content too large for {stage} guardrail ({len(content_str)} chars, max: {max_content_length})")
-            return (ValidValidationResult() if fail_safe == 'allow' 
-                   else InvalidValidationResult(error_message=f'Content too large for guardrail evaluation ({len(content_str)} > {max_content_length} chars)'))
+            print(
+                f"[JAF:GUARDRAILS] Content too large for {stage} guardrail ({len(content_str)} chars, max: {max_content_length})"
+            )
+            return (
+                ValidValidationResult()
+                if fail_safe == "allow"
+                else InvalidValidationResult(
+                    error_message=f"Content too large for guardrail evaluation ({len(content_str)} > {max_content_length} chars)"
+                )
+            )
 
         # Prepare content for evaluation
-        sanitized_content = (content_str
-                           .replace('"""', '[TRIPLE_QUOTE]')
-                           .replace('\n', ' ')[:2000])
-        
+        sanitized_content = content_str.replace('"""', "[TRIPLE_QUOTE]").replace("\n", " ")[:2000]
+
         eval_prompt = f"""You are a guardrail validator for {stage}.
 Rules:
 {rule_prompt}
 
-Decide if the {stage} {'user message' if stage == 'input' else 'assistant output'} complies with the rules.
+Decide if the {stage} {"user message" if stage == "input" else "assistant output"} complies with the rules.
 Return a JSON object with keys: {{"allowed": boolean, "reason": string}}. Do not include extra text.
-{stage.capitalize()} {'user message' if stage == 'input' else 'assistant output'}:
+{stage.capitalize()} {"user message" if stage == "input" else "assistant output"}:
 \"\"\"
 {sanitized_content}
 \"\"\""""
@@ -261,22 +285,22 @@ Return a JSON object with keys: {{"allowed": boolean, "reason": string}}. Do not
         try:
             # Create temporary state for guardrail evaluation
             temp_state = RunState(
-                run_id=create_run_id('guardrail-eval'),
-                trace_id=create_trace_id('guardrail-eval'),
+                run_id=create_run_id("guardrail-eval"),
+                trace_id=create_trace_id("guardrail-eval"),
                 messages=[Message(role=ContentRole.USER, content=eval_prompt)],
-                current_agent_name='guardrail-evaluator',
+                current_agent_name="guardrail-evaluator",
                 context={},
-                turn_count=0
+                turn_count=0,
             )
 
             # Create evaluation agent
             def eval_instructions(state: RunState) -> str:
-                return 'You are a guardrail validator. Return only valid JSON.'
+                return "You are a guardrail validator. Return only valid JSON."
 
             eval_agent = Agent(
-                name='guardrail-evaluator',
+                name="guardrail-evaluator",
                 instructions=eval_instructions,
-                model_config={'name': model_to_use} if hasattr(config, 'ModelConfig') else None
+                model_config={"name": model_to_use} if hasattr(config, "ModelConfig") else None,
             )
 
             # Create guardrail config (no guardrails to avoid recursion)
@@ -289,28 +313,30 @@ Return a JSON object with keys: {{"allowed": boolean, "reason": string}}. Do not
                 initial_input_guardrails=None,
                 final_output_guardrails=None,
                 on_event=None,
-                prefer_streaming=config.prefer_streaming
+                prefer_streaming=config.prefer_streaming,
             )
 
             # Execute with timeout
-            completion_promise = config.model_provider.get_completion(temp_state, eval_agent, guardrail_config)
+            completion_promise = config.model_provider.get_completion(
+                temp_state, eval_agent, guardrail_config
+            )
             response = await _with_timeout(
                 completion_promise,
                 timeout_ms,
-                f"{stage} guardrail evaluation timed out after {timeout_ms}ms"
+                f"{stage} guardrail evaluation timed out after {timeout_ms}ms",
             )
 
             # Handle different response formats
             response_content = None
-            if hasattr(response, 'message') and response.message:
-                if hasattr(response.message, 'content'):
+            if hasattr(response, "message") and response.message:
+                if hasattr(response.message, "content"):
                     response_content = response.message.content
             elif isinstance(response, dict):
-                if 'message' in response and response['message']:
-                    if isinstance(response['message'], dict) and 'content' in response['message']:
-                        response_content = response['message']['content']
-                    elif hasattr(response['message'], 'content'):
-                        response_content = response['message'].content
+                if "message" in response and response["message"]:
+                    if isinstance(response["message"], dict) and "content" in response["message"]:
+                        response_content = response["message"]["content"]
+                    elif hasattr(response["message"], "content"):
+                        response_content = response["message"].content
 
             if not response_content:
                 circuit_breaker.record_success()
@@ -320,62 +346,76 @@ Return a JSON object with keys: {{"allowed": boolean, "reason": string}}. Do not
 
             # Parse response
             parsed = json_parse_llm_output(response_content)
-            allowed = bool(parsed.get('allowed', True) if parsed else True)
-            reason = str(parsed.get('reason', 'Guardrail violation') if parsed else 'Guardrail violation')
-            
+            allowed = bool(parsed.get("allowed", True) if parsed else True)
+            reason = str(
+                parsed.get("reason", "Guardrail violation") if parsed else "Guardrail violation"
+            )
+
             circuit_breaker.record_success()
-            
-            result = (ValidValidationResult() if allowed 
-                     else InvalidValidationResult(error_message=reason))
-            
+
+            result = (
+                ValidValidationResult()
+                if allowed
+                else InvalidValidationResult(error_message=reason)
+            )
+
             _guardrail_cache.set(stage, rule_prompt, content_str, model_to_use, result)
             return result
 
         except Exception as e:
             circuit_breaker.record_failure()
-            
+
             error_message = str(e)
-            is_timeout = 'Timeout' in error_message
-            
+            is_timeout = "Timeout" in error_message
+
             log_message = f"[JAF:GUARDRAILS] {stage} guardrail evaluation failed"
             if is_timeout:
                 print(f"{log_message} due to timeout ({timeout_ms}ms), using failSafe: {fail_safe}")
             else:
                 print(f"{log_message}, using failSafe: {fail_safe} - {error_message}")
-            
-            return (ValidValidationResult() if fail_safe == 'allow' 
-                   else InvalidValidationResult(error_message=f'Guardrail evaluation failed: {error_message}'))
+
+            return (
+                ValidValidationResult()
+                if fail_safe == "allow"
+                else InvalidValidationResult(
+                    error_message=f"Guardrail evaluation failed: {error_message}"
+                )
+            )
 
     return guardrail_func
 
 
 async def build_effective_guardrails(
-    current_agent: Agent,
-    config: RunConfig
+    current_agent: Agent, config: RunConfig
 ) -> Tuple[List[Guardrail], List[Guardrail]]:
     """Build effective input and output guardrails for an agent."""
     effective_input_guardrails: List[Guardrail] = []
     effective_output_guardrails: List[Guardrail] = []
-    
+
     try:
-        raw_guardrails_cfg = (current_agent.advanced_config.guardrails 
-                             if current_agent.advanced_config 
-                             else None)
+        raw_guardrails_cfg = (
+            current_agent.advanced_config.guardrails if current_agent.advanced_config else None
+        )
         guardrails_cfg = validate_guardrails_config(raw_guardrails_cfg)
 
         fast_model = guardrails_cfg.fast_model or config.default_fast_model
         if not fast_model and (guardrails_cfg.input_prompt or guardrails_cfg.output_prompt):
-            print('[JAF:GUARDRAILS] No fast model available for LLM guardrails - skipping LLM-based validation')
-
-        print('[JAF:GUARDRAILS] Configuration:', {
-            'hasInputPrompt': bool(guardrails_cfg.input_prompt),
-            'hasOutputPrompt': bool(guardrails_cfg.output_prompt),
-            'requireCitations': guardrails_cfg.require_citations,
-            'executionMode': guardrails_cfg.execution_mode,
-            'failSafe': guardrails_cfg.fail_safe,
-            'timeoutMs': guardrails_cfg.timeout_ms,
-            'fastModel': fast_model or 'none'
-        })
+            print(
+                "[JAF:GUARDRAILS] No fast model available for LLM guardrails - skipping LLM-based validation"
+            )
+
+        print(
+            "[JAF:GUARDRAILS] Configuration:",
+            {
+                "hasInputPrompt": bool(guardrails_cfg.input_prompt),
+                "hasOutputPrompt": bool(guardrails_cfg.output_prompt),
+                "requireCitations": guardrails_cfg.require_citations,
+                "executionMode": guardrails_cfg.execution_mode,
+                "failSafe": guardrails_cfg.fail_safe,
+                "timeoutMs": guardrails_cfg.timeout_ms,
+                "fastModel": fast_model or "none",
+            },
+        )
 
         # Start with global guardrails
         effective_input_guardrails = list(config.initial_input_guardrails or [])
@@ -384,41 +424,55 @@ async def build_effective_guardrails(
         # Add input prompt guardrail
         if guardrails_cfg.input_prompt and guardrails_cfg.input_prompt.strip():
             input_guardrail = await _create_llm_guardrail(
-                config, 'input', guardrails_cfg.input_prompt, 
-                fast_model, guardrails_cfg.fail_safe, guardrails_cfg.timeout_ms
+                config,
+                "input",
+                guardrails_cfg.input_prompt,
+                fast_model,
+                guardrails_cfg.fail_safe,
+                guardrails_cfg.timeout_ms,
             )
             effective_input_guardrails.append(input_guardrail)
 
         # Add citation requirement guardrail
         if guardrails_cfg.require_citations:
+
             def citation_guardrail(output: Any) -> ValidationResult:
                 def find_text(val: Any) -> str:
                     if isinstance(val, str):
                         return val
                     elif isinstance(val, list):
-                        return ' '.join(find_text(item) for item in val)
+                        return " ".join(find_text(item) for item in val)
                     elif isinstance(val, dict):
-                        return ' '.join(find_text(v) for v in val.values())
+                        return " ".join(find_text(v) for v in val.values())
                     else:
                         return str(val)
-                
+
                 text = find_text(output)
-                has_citation = bool(re.search(r'\[(\d+)\]', text))
-                return (ValidValidationResult() if has_citation 
-                       else InvalidValidationResult(error_message="Missing required [n] citation in output"))
-            
+                has_citation = bool(re.search(r"\[(\d+)\]", text))
+                return (
+                    ValidValidationResult()
+                    if has_citation
+                    else InvalidValidationResult(
+                        error_message="Missing required [n] citation in output"
+                    )
+                )
+
             effective_output_guardrails.append(citation_guardrail)
 
         # Add output prompt guardrail
         if guardrails_cfg.output_prompt and guardrails_cfg.output_prompt.strip():
             output_guardrail = await _create_llm_guardrail(
-                config, 'output', guardrails_cfg.output_prompt,
-                fast_model, guardrails_cfg.fail_safe, guardrails_cfg.timeout_ms
+                config,
+                "output",
+                guardrails_cfg.output_prompt,
+                fast_model,
+                guardrails_cfg.fail_safe,
+                guardrails_cfg.timeout_ms,
             )
             effective_output_guardrails.append(output_guardrail)
 
     except Exception as e:
-        print(f'[JAF:GUARDRAILS] Failed to configure advanced guardrails: {e}')
+        print(f"[JAF:GUARDRAILS] Failed to configure advanced guardrails: {e}")
         # Fall back to global guardrails only
         effective_input_guardrails = list(config.initial_input_guardrails or [])
         effective_output_guardrails = list(config.final_output_guardrails or [])
@@ -427,192 +481,212 @@ async def build_effective_guardrails(
 
 
 async def execute_input_guardrails_sequential(
-    input_guardrails: List[Guardrail],
-    first_user_message: Message,
-    config: RunConfig
+    input_guardrails: List[Guardrail], first_user_message: Message, config: RunConfig
 ) -> ValidationResult:
     """Execute input guardrails sequentially."""
     if not input_guardrails:
         return ValidValidationResult()
 
     print(f"[JAF:GUARDRAILS] Starting {len(input_guardrails)} input guardrails (sequential)")
-    
+
     content = get_text_content(first_user_message.content)
-    
+
     for i, guardrail in enumerate(input_guardrails):
         guardrail_name = f"input-guardrail-{i + 1}"
-        
+
         try:
             print(f"[JAF:GUARDRAILS] Starting {guardrail_name}")
-            
+
             timeout_ms = GUARDRAIL_TIMEOUT_MS
             result = await _with_timeout(
-                guardrail(content) if asyncio.iscoroutinefunction(guardrail) else guardrail(content),
+                guardrail(content)
+                if asyncio.iscoroutinefunction(guardrail)
+                else guardrail(content),
                 timeout_ms,
-                f"{guardrail_name} execution timed out after {timeout_ms}ms"
+                f"{guardrail_name} execution timed out after {timeout_ms}ms",
             )
-            
+
             print(f"[JAF:GUARDRAILS] {guardrail_name} completed: {result}")
-            
+
             if not result.is_valid:
-                error_message = getattr(result, 'error_message', 'Guardrail violation')
+                error_message = getattr(result, "error_message", "Guardrail violation")
                 print(f"🚨 {guardrail_name} violation: {error_message}")
                 if config.on_event:
-                    config.on_event(GuardrailViolationEvent(
-                        data=GuardrailViolationEventData(stage='input', reason=error_message)
-                    ))
+                    config.on_event(
+                        GuardrailViolationEvent(
+                            data=GuardrailViolationEventData(stage="input", reason=error_message)
+                        )
+                    )
                 return result
-                
+
         except Exception as error:
             error_message = str(error)
             print(f"[JAF:GUARDRAILS] {guardrail_name} failed: {error_message}")
-            
-            is_system_error = 'Timeout' in error_message or 'Circuit breaker' in error_message
-            
+
+            is_system_error = "Timeout" in error_message or "Circuit breaker" in error_message
+
             if is_system_error:
-                print(f"[JAF:GUARDRAILS] {guardrail_name} system error, continuing: {error_message}")
+                print(
+                    f"[JAF:GUARDRAILS] {guardrail_name} system error, continuing: {error_message}"
+                )
                 continue
             else:
                 if config.on_event:
-                    config.on_event(GuardrailViolationEvent(
-                        data=GuardrailViolationEventData(stage='input', reason=error_message)
-                    ))
+                    config.on_event(
+                        GuardrailViolationEvent(
+                            data=GuardrailViolationEventData(stage="input", reason=error_message)
+                        )
+                    )
                 return InvalidValidationResult(error_message=error_message)
-    
+
     print("✅ All input guardrails passed (sequential).")
     return ValidValidationResult()
 
 
 async def execute_input_guardrails_parallel(
-    input_guardrails: List[Guardrail],
-    first_user_message: Message,
-    config: RunConfig
+    input_guardrails: List[Guardrail], first_user_message: Message, config: RunConfig
 ) -> ValidationResult:
     """Execute input guardrails in parallel."""
     if not input_guardrails:
         return ValidValidationResult()
 
     print(f"[JAF:GUARDRAILS] Starting {len(input_guardrails)} input guardrails")
-    
+
     content = get_text_content(first_user_message.content)
-    
+
     async def run_guardrail(guardrail: Guardrail, index: int):
         guardrail_name = f"input-guardrail-{index + 1}"
-        
+
         try:
             print(f"[JAF:GUARDRAILS] Starting {guardrail_name}")
-            
-            timeout_ms = DEFAULT_FAST_MODEL_TIMEOUT_MS if config.default_fast_model else DEFAULT_TIMEOUT_MS
-            
+
+            timeout_ms = (
+                DEFAULT_FAST_MODEL_TIMEOUT_MS if config.default_fast_model else DEFAULT_TIMEOUT_MS
+            )
+
             if asyncio.iscoroutinefunction(guardrail):
-                result = await _with_timeout(guardrail(content), timeout_ms, 
-                                           f"{guardrail_name} execution timed out after {timeout_ms}ms")
+                result = await _with_timeout(
+                    guardrail(content),
+                    timeout_ms,
+                    f"{guardrail_name} execution timed out after {timeout_ms}ms",
+                )
             else:
                 result = guardrail(content)
-            
+
             print(f"[JAF:GUARDRAILS] {guardrail_name} completed: {result}")
-            return {'result': result, 'guardrail_index': index}
-            
+            return {"result": result, "guardrail_index": index}
+
         except Exception as error:
             error_message = str(error)
             print(f"[JAF:GUARDRAILS] {guardrail_name} failed: {error_message}")
-            
+
             return {
-                'result': ValidValidationResult(),
-                'guardrail_index': index,
-                'warning': f"Guardrail {index + 1} failed but was skipped: {error_message}"
+                "result": ValidValidationResult(),
+                "guardrail_index": index,
+                "warning": f"Guardrail {index + 1} failed but was skipped: {error_message}",
             }
-    
+
     try:
         # Run all guardrails in parallel
         tasks = [run_guardrail(guardrail, i) for i, guardrail in enumerate(input_guardrails)]
         results = await asyncio.gather(*tasks, return_exceptions=True)
-        
+
         print("[JAF:GUARDRAILS] Input guardrails completed. Checking results...")
-        
+
         warnings = []
-        
+
         for i, result in enumerate(results):
             if isinstance(result, Exception):
                 error_message = str(result)
                 print(f"[JAF:GUARDRAILS] Input guardrail {i + 1} promise rejected: {error_message}")
                 warnings.append(f"Guardrail {i + 1} failed: {error_message}")
                 continue
-            
-            if 'warning' in result:
-                warnings.append(result['warning'])
-            
-            validation_result = result['result']
+
+            if "warning" in result:
+                warnings.append(result["warning"])
+
+            validation_result = result["result"]
             if not validation_result.is_valid:
-                error_message = getattr(validation_result, 'error_message', 'Guardrail violation')
-                print(f"🚨 Input guardrail {result['guardrail_index'] + 1} violation: {error_message}")
+                error_message = getattr(validation_result, "error_message", "Guardrail violation")
+                print(
+                    f"🚨 Input guardrail {result['guardrail_index'] + 1} violation: {error_message}"
+                )
                 if config.on_event:
-                    config.on_event(GuardrailViolationEvent(
-                        data=GuardrailViolationEventData(stage='input', reason=error_message)
-                    ))
+                    config.on_event(
+                        GuardrailViolationEvent(
+                            data=GuardrailViolationEventData(stage="input", reason=error_message)
+                        )
+                    )
                 return validation_result
-        
+
         if warnings:
             print(f"[JAF:GUARDRAILS] {len(warnings)} guardrail warnings: {warnings}")
-        
+
         print("✅ All input guardrails passed.")
         return ValidValidationResult()
-        
+
     except Exception as error:
         print(f"[JAF:GUARDRAILS] Catastrophic failure in input guardrail execution: {error}")
         return ValidValidationResult()  # Fail gracefully
 
 
 async def execute_output_guardrails(
-    output_guardrails: List[Guardrail],
-    output: Any,
-    config: RunConfig
+    output_guardrails: List[Guardrail], output: Any, config: RunConfig
 ) -> ValidationResult:
     """Execute output guardrails sequentially."""
     if not output_guardrails:
         return ValidValidationResult()
 
     print(f"[JAF:GUARDRAILS] Checking {len(output_guardrails)} output guardrails")
-    
+
     for i, guardrail in enumerate(output_guardrails):
         guardrail_name = f"output-guardrail-{i + 1}"
-        
+
         try:
             timeout_ms = OUTPUT_GUARDRAIL_TIMEOUT_MS
-            
+
             if asyncio.iscoroutinefunction(guardrail):
-                result = await _with_timeout(guardrail(output), timeout_ms,
-                                           f"{guardrail_name} execution timed out after {timeout_ms}ms")
+                result = await _with_timeout(
+                    guardrail(output),
+                    timeout_ms,
+                    f"{guardrail_name} execution timed out after {timeout_ms}ms",
+                )
             else:
                 result = guardrail(output)
-            
+
             if not result.is_valid:
-                error_message = getattr(result, 'error_message', 'Guardrail violation')
+                error_message = getattr(result, "error_message", "Guardrail violation")
                 print(f"🚨 {guardrail_name} violation: {error_message}")
                 if config.on_event:
-                    config.on_event(GuardrailViolationEvent(
-                        data=GuardrailViolationEventData(stage='output', reason=error_message)
-                    ))
+                    config.on_event(
+                        GuardrailViolationEvent(
+                            data=GuardrailViolationEventData(stage="output", reason=error_message)
+                        )
+                    )
                 return result
-            
+
             print(f"✅ {guardrail_name} passed")
-            
+
         except Exception as error:
             error_message = str(error)
             print(f"[JAF:GUARDRAILS] {guardrail_name} failed: {error_message}")
-            
-            is_system_error = 'Timeout' in error_message or 'Circuit breaker' in error_message
-            
+
+            is_system_error = "Timeout" in error_message or "Circuit breaker" in error_message
+
             if is_system_error:
-                print(f"[JAF:GUARDRAILS] {guardrail_name} system error, allowing output: {error_message}")
+                print(
+                    f"[JAF:GUARDRAILS] {guardrail_name} system error, allowing output: {error_message}"
+                )
                 continue
             else:
                 if config.on_event:
-                    config.on_event(GuardrailViolationEvent(
-                        data=GuardrailViolationEventData(stage='output', reason=error_message)
-                    ))
+                    config.on_event(
+                        GuardrailViolationEvent(
+                            data=GuardrailViolationEventData(stage="output", reason=error_message)
+                        )
+                    )
                 return InvalidValidationResult(error_message=error_message)
-    
+
     print("✅ All output guardrails passed")
     return ValidValidationResult()
 
@@ -623,40 +697,40 @@ def cleanup_circuit_breakers() -> None:
     for key, breaker in _circuit_breakers.items():
         if breaker.should_be_cleaned_up(CIRCUIT_BREAKER_CLEANUP_MAX_AGE):
             to_remove.append(key)
-    
+
     for key in to_remove:
         del _circuit_breakers[key]
 
 
 class GuardrailCacheManager:
     """Manager for guardrail cache operations."""
-    
+
     @staticmethod
     def get_stats() -> Dict[str, Any]:
         """Get cache statistics."""
         return _guardrail_cache.get_stats()
-    
+
     @staticmethod
     def clear() -> None:
         """Clear cache."""
         _guardrail_cache.clear()
-    
+
     @staticmethod
     def get_metrics() -> Dict[str, Any]:
         """Get cache metrics."""
         stats = _guardrail_cache.get_stats()
         return {
             **stats,
-            'utilization_percent': (stats['size'] / stats['max_size']) * 100,
-            'circuit_breakers_count': len(_circuit_breakers)
+            "utilization_percent": (stats["size"] / stats["max_size"]) * 100,
+            "circuit_breakers_count": len(_circuit_breakers),
         }
-    
+
     @staticmethod
     def log_stats() -> None:
         """Log cache statistics."""
         metrics = GuardrailCacheManager.get_metrics()
-        print('[JAF:GUARDRAILS] Cache stats:', metrics)
-    
+        print("[JAF:GUARDRAILS] Cache stats:", metrics)
+
     @staticmethod
     def cleanup() -> None:
         """Cleanup old entries."""
@@ -664,4 +738,4 @@ class GuardrailCacheManager:
 
 
 # Export the cache manager
-guardrail_cache_manager = GuardrailCacheManager()
+guardrail_cache_manager = GuardrailCacheManager()