Update hf_demo.py

hf_demo.py

@@ -22,6 +22,7 @@ try:
     from fastapi.middleware.cors import CORSMiddleware
     from pydantic import BaseModel, Field
     from gradio import mount_gradio_app
+    from typing import Optional
     FASTAPI_AVAILABLE = True
     print("✅ FastAPI available")
 except ImportError as e:
@@ -35,6 +36,7 @@ except ImportError as e:
     class HTTPException(Exception): pass
     class CORSMiddleware: pass
     def Field(*args, **kwargs): return None
+    Optional = lambda x: x
 
 if FASTAPI_AVAILABLE:
     # Create FastAPI app
@@ -49,6 +51,19 @@ if FASTAPI_AVAILABLE:
         allow_headers=["*"],
     )
 
+    # ============== IN-MEMORY CONFIGURATION STORAGE ==============
+    # This is the key fix - persistent storage for config
+    current_config = {
+        "confidenceThreshold": 0.9,
+        "maxAutonomousRisk": "MEDIUM",
+        "riskScoreThresholds": {
+            "LOW": 0.7,
+            "MEDIUM": 0.5,
+            "HIGH": 0.3,
+            "CRITICAL": 0.1
+        }
+    }
+
     # Define Pydantic models
     class ActionEvaluationRequest(BaseModel):
         proposed_action: str = Field(..., description="The command the AI wants to execute")
@@ -79,47 +94,70 @@ if FASTAPI_AVAILABLE:
         maxAutonomousRisk: str
         riskScoreThresholds: dict
 
-    # Add API endpoints
+    class ConfigUpdateRequest(BaseModel):
+        confidenceThreshold: Optional[float] = Field(None, ge=0.5, le=1.0)
+        maxAutonomousRisk: Optional[str] = Field(None, regex="^(LOW|MEDIUM|HIGH|CRITICAL)$")
+
+    # ============== CONFIGURATION ENDPOINTS ==============
+    
     @api_app.get("/api/v1/config", response_model=ConfigResponse)
     async def get_config():
         """Get current ARF configuration"""
-        return {
-            "confidenceThreshold": 0.9,
-            "maxAutonomousRisk": "MEDIUM",
-            "riskScoreThresholds": {
-                "LOW": 0.7,
-                "MEDIUM": 0.5,
-                "HIGH": 0.3,
-                "CRITICAL": 0.1
-            }
-        }
+        print(f"📊 GET /api/v1/config -> {current_config}")
+        return current_config
 
+    @api_app.post("/api/v1/config", response_model=ConfigResponse)
+    async def update_config(config_update: ConfigUpdateRequest):
+        """Update ARF configuration"""
+        global current_config
+        print(f"🔄 POST /api/v1/config with: {config_update}")
+        
+        # Update only the fields that were sent
+        if config_update.confidenceThreshold is not None:
+            current_config["confidenceThreshold"] = config_update.confidenceThreshold
+            print(f"   Updated confidenceThreshold to {config_update.confidenceThreshold}")
+        
+        if config_update.maxAutonomousRisk is not None:
+            current_config["maxAutonomousRisk"] = config_update.maxAutonomousRisk
+            print(f"   Updated maxAutonomousRisk to {config_update.maxAutonomousRisk}")
+        
+        print(f"✅ New config: {current_config}")
+        return current_config
+
+    # ============== EVALUATION ENDPOINTS ==============
+    
     @api_app.post("/api/v1/evaluate", response_model=ActionEvaluationResponse)
     async def evaluate_action(request: ActionEvaluationRequest):
         """Evaluate an action using mathematical Bayesian assessment"""
         try:
-            # Simulate gate evaluations
+            print(f"🔍 Evaluating action: {request.proposed_action}")
+            print(f"   Using config: confidence={current_config['confidenceThreshold']}, maxRisk={current_config['maxAutonomousRisk']}")
+            
             gates = []
             
-            # Confidence gate
-            confidence_passed = request.confidence_score >= 0.9
+            # Confidence gate - using current_config
+            confidence_passed = request.confidence_score >= current_config["confidenceThreshold"]
             gates.append(GateEvaluationResponse(
                 gate="confidence_threshold",
-                reason=f"Confidence {request.confidence_score:.2f} meets threshold 0.9" if confidence_passed 
-                       else f"Confidence {request.confidence_score:.2f} below threshold 0.9",
+                reason=f"Confidence {request.confidence_score:.2f} meets threshold {current_config['confidenceThreshold']}" if confidence_passed 
+                       else f"Confidence {request.confidence_score:.2f} below threshold {current_config['confidenceThreshold']}",
                 passed=confidence_passed,
-                threshold=0.9,
+                threshold=current_config["confidenceThreshold"],
                 actual=request.confidence_score
             ))
             
-            # Risk gate
-            risk_passed = request.risk_level in ["LOW", "MEDIUM"]
+            # Risk gate - using current_config
+            risk_levels = ["LOW", "MEDIUM", "HIGH", "CRITICAL"]
+            max_risk_index = risk_levels.index(current_config["maxAutonomousRisk"])
+            action_risk_index = risk_levels.index(request.risk_level)
+            risk_passed = action_risk_index <= max_risk_index
+            
             gates.append(GateEvaluationResponse(
                 gate="risk_assessment",
-                reason=f"Risk level {request.risk_level} within autonomous range" if risk_passed
-                       else f"Risk level {request.risk_level} exceeds autonomous threshold",
+                reason=f"Risk level {request.risk_level} within autonomous range (≤ {current_config['maxAutonomousRisk']})" if risk_passed
+                       else f"Risk level {request.risk_level} exceeds autonomous threshold (max: {current_config['maxAutonomousRisk']})",
                 passed=risk_passed,
-                metadata={"maxAutonomousRisk": "MEDIUM", "actionRisk": request.risk_level}
+                metadata={"maxAutonomousRisk": current_config["maxAutonomousRisk"], "actionRisk": request.risk_level}
             ))
             
             # Rollback gate
@@ -154,7 +192,7 @@ if FASTAPI_AVAILABLE:
             
             all_passed = all(g.passed for g in gates)
             
-            # Determine required level
+            # Determine required level based on gates and config
             if all_passed:
                 if request.risk_level == "LOW":
                     required_level = "AUTONOMOUS_LOW"
@@ -165,7 +203,7 @@ if FASTAPI_AVAILABLE:
             else:
                 required_level = "OPERATOR_REVIEW"
             
-            return ActionEvaluationResponse(
+            result = ActionEvaluationResponse(
                 allowed=all_passed,
                 required_level=required_level,
                 gates_triggered=gates,
@@ -173,12 +211,17 @@ if FASTAPI_AVAILABLE:
                 escalation_reason=None if all_passed else "Failed critical gates"
             )
             
+            print(f"✅ Evaluation complete: allowed={result.allowed}, required_level={result.required_level}")
+            return result
+            
         except Exception as e:
+            print(f"❌ Evaluation error: {e}")
             raise HTTPException(status_code=500, detail=str(e))
 
     @api_app.post("/api/v1/process")
     async def process_action(request: ActionEvaluationRequest):
         """Process action through full ARF pipeline"""
+        print(f"⚙️ Processing action: {request.proposed_action}")
         evaluation = await evaluate_action(request)
         
         # Determine final status based on evaluation
@@ -189,24 +232,30 @@ if FASTAPI_AVAILABLE:
         else:
             final_status = "blocked"
         
-        return {
+        result = {
             "action": request.dict(),
             "evaluation": evaluation.dict(),
             "finalStatus": final_status
         }
+        print(f"✅ Process complete: {final_status}")
+        return result
 
     @api_app.post("/api/v1/simulate")
     async def simulate_action(request: ActionEvaluationRequest, config: dict = None):
         """Simulate action with temporary configuration"""
+        print(f"🎮 Simulating action with custom config: {config}")
         evaluation = await evaluate_action(request)
         return evaluation
 
-    print("✅ FastAPI endpoints configured")
-    print("   Endpoints will be available at:")
-    print("   - /api/v1/config")
-    print("   - /api/v1/evaluate")
-    print("   - /api/v1/process")
-    print("   - /api/v1/simulate")
+    print("\n" + "="*80)
+    print("✅ FASTAPI ENDPOINTS CONFIGURED")
+    print("="*80)
+    print("   📍 GET  /api/v1/config")
+    print("   📍 POST /api/v1/config")
+    print("   📍 POST /api/v1/evaluate")
+    print("   📍 POST /api/v1/process")
+    print("   📍 POST /api/v1/simulate")
+    print("="*80 + "\n")
 
 # ============== HUGGING FACE SPACES DETECTION ==============
 def is_huggingface_spaces():