Update hf_demo.py

hf_demo.py

@@ -16,6 +16,195 @@ from datetime import datetime, timedelta
 from typing import Dict, List, Optional, Tuple, Any, Union
 import numpy as np
 
+# ============== FASTAPI INTEGRATION ==============
+try:
+    from fastapi import FastAPI, HTTPException
+    from fastapi.middleware.cors import CORSMiddleware
+    from pydantic import BaseModel, Field
+    import uvicorn
+    FASTAPI_AVAILABLE = True
+    print("✅ FastAPI available")
+except ImportError as e:
+    print(f"⚠️ FastAPI not available: {e}")
+    FASTAPI_AVAILABLE = False
+    
+    # Create dummy classes if FastAPI not installed
+    class BaseModel:
+        def dict(self): return {}
+    class FastAPI: pass
+    class HTTPException(Exception): pass
+    class CORSMiddleware: pass
+    def Field(*args, **kwargs): return None
+
+if FASTAPI_AVAILABLE:
+    # Create FastAPI app
+    api_app = FastAPI(title="ARF Mathematical Engine", version="3.3.9")
+
+    # Add CORS middleware
+    api_app.add_middleware(
+        CORSMiddleware,
+        allow_origins=["*"],  # In production, restrict to your Replit domain
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+
+    # Define Pydantic models
+    class ActionEvaluationRequest(BaseModel):
+        proposed_action: str = Field(..., description="The command the AI wants to execute")
+        confidence_score: float = Field(..., ge=0.0, le=1.0, description="AI confidence score")
+        risk_level: str = Field(..., description="Risk level (LOW/MEDIUM/HIGH/CRITICAL)")
+        requires_human: bool = Field(..., description="Whether action requires human oversight")
+        rollback_feasible: bool = Field(..., description="Whether action can be rolled back")
+        description: Optional[str] = Field(None, description="Optional action description")
+        incident_id: Optional[int] = Field(None, description="Optional incident ID")
+
+    class GateEvaluationResponse(BaseModel):
+        gate: str
+        reason: str
+        passed: bool
+        threshold: Optional[float] = None
+        actual: Optional[float] = None
+        metadata: Optional[dict] = None
+
+    class ActionEvaluationResponse(BaseModel):
+        allowed: bool
+        required_level: str
+        gates_triggered: list[GateEvaluationResponse]
+        should_escalate: bool
+        escalation_reason: Optional[str] = None
+
+    class ConfigResponse(BaseModel):
+        confidenceThreshold: float
+        maxAutonomousRisk: str
+        riskScoreThresholds: dict
+
+    # Add API 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
+            }
+        }
+
+    @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
+            gates = []
+            
+            # Confidence gate
+            confidence_passed = request.confidence_score >= 0.9
+            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",
+                passed=confidence_passed,
+                threshold=0.9,
+                actual=request.confidence_score
+            ))
+            
+            # Risk gate
+            risk_passed = request.risk_level in ["LOW", "MEDIUM"]
+            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",
+                passed=risk_passed,
+                metadata={"maxAutonomousRisk": "MEDIUM", "actionRisk": request.risk_level}
+            ))
+            
+            # Rollback gate
+            destructive_keywords = ['delete', 'drop', 'terminate', 'remove', 'destroy']
+            is_destructive = any(keyword in request.proposed_action.lower() for keyword in destructive_keywords)
+            rollback_passed = not is_destructive or request.rollback_feasible
+            gates.append(GateEvaluationResponse(
+                gate="rollback_feasibility",
+                reason="Non-destructive operation" if not is_destructive
+                       else "Has rollback plan" if request.rollback_feasible
+                       else "Destructive operation lacks rollback plan",
+                passed=rollback_passed,
+                metadata={"isDestructive": is_destructive, "requiresRollback": is_destructive}
+            ))
+            
+            # Human review gate
+            human_passed = not request.requires_human
+            gates.append(GateEvaluationResponse(
+                gate="human_review",
+                reason="Human review not required" if human_passed else "Human review required by policy",
+                passed=human_passed,
+                metadata={"policyRequiresHuman": request.requires_human}
+            ))
+            
+            # License gate (always passes in this simulation)
+            gates.append(GateEvaluationResponse(
+                gate="license_check",
+                reason="No license violations detected",
+                passed=True,
+                metadata={"licenseSensitive": False}
+            ))
+            
+            all_passed = all(g.passed for g in gates)
+            
+            # Determine required level
+            if all_passed:
+                if request.risk_level == "LOW":
+                    required_level = "AUTONOMOUS_LOW"
+                elif request.risk_level == "MEDIUM":
+                    required_level = "AUTONOMOUS_HIGH"
+                else:
+                    required_level = "SUPERVISED"
+            else:
+                required_level = "OPERATOR_REVIEW"
+            
+            return ActionEvaluationResponse(
+                allowed=all_passed,
+                required_level=required_level,
+                gates_triggered=gates,
+                should_escalate=not all_passed,
+                escalation_reason=None if all_passed else "Failed critical gates"
+            )
+            
+        except Exception as 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"""
+        evaluation = await evaluate_action(request)
+        
+        # Determine final status based on evaluation
+        if evaluation.allowed and not evaluation.should_escalate:
+            final_status = "executed"
+        elif evaluation.should_escalate:
+            final_status = "needs_approval"
+        else:
+            final_status = "blocked"
+        
+        return {
+            "action": request.dict(),
+            "evaluation": evaluation.dict(),
+            "finalStatus": final_status
+        }
+
+    @api_app.post("/api/v1/simulate")
+    async def simulate_action(request: ActionEvaluationRequest, config: dict = None):
+        """Simulate action with temporary configuration"""
+        evaluation = await evaluate_action(request)
+        return evaluation
+
+    def run_fastapi():
+        """Run FastAPI server in background thread"""
+        uvicorn.run(api_app, host="0.0.0.0", port=8000, log_level="warning")
+
 # ============== HUGGING FACE SPACES DETECTION ==============
 def is_huggingface_spaces():
     """Detect if running in Hugging Face Spaces environment"""
@@ -973,6 +1162,17 @@ if __name__ == "__main__":
     print("🌐 Environment:", "Hugging Face Spaces" if is_huggingface_spaces() else "Local Development")
     print("="*80)
     
+    # Start FastAPI in background thread if available
+    if FASTAPI_AVAILABLE:
+        fastapi_thread = threading.Thread(target=run_fastapi, daemon=True)
+        fastapi_thread.start()
+        print("✅ FastAPI server started on port 8000")
+        print("   API endpoints available at:")
+        print("   - GET  /api/v1/config")
+        print("   - POST /api/v1/evaluate")
+        print("   - POST /api/v1/process")
+        print("   - POST /api/v1/simulate")
+    
     # Create the demo
     demo = create_enhanced_demo()