coreswitch.py

# coreswitch.py - Infrastructure Safety Boundary & Circuit Breaker (Peak Edition)
import time
from typing import Literal
from fastapi import FastAPI, Request, status
from fastapi.responses import ORJSONResponse
from pydantic import BaseModel, Field

app = FastAPI(
    title="CoreSwitch Infrastructure Safety Boundary",
    version="1.0.0",
    description="Sub-5ms Deterministic Circuit Breaker Middleware",
    default_response_class=ORJSONResponse  # C-based ultra-fast JSON parsing
)

MAX_PAYLOAD_BYTES = 2 * 1024 * 1024  # 2MB Limit for DoS Protection

# Middleware: Protect against memory overload attacks
@app.middleware("http")
async def limit_payload_size(request: Request, call_next):
    content_length = request.headers.get("content-length")
    if content_length and int(content_length) > MAX_PAYLOAD_BYTES:
        return ORJSONResponse(
            status_code=status.HTTP_413_REQUEST_ENTITY_TOO_LARGE,
            content={"detail": "Payload too large. CoreSwitch limits requests to 2MB."}
        )
    return await call_next(request)

# Data Contract Schemas
class CoreSwitchRequest(BaseModel):
    raw_output: str
    entropy_index: float = Field(..., ge=0.0, le=1.0, description="Real-time cognitive load (0.0 to 1.0)")
    src_status: Literal["FULL", "PARTIAL", "CRITICAL"] = Field(..., description="Resource availability state")
    context_weight: float = Field(..., ge=0.0, le=1.0, description="Context coherence score")

class Telemetry(BaseModel):
    execution_time_ms: float
    input_length: int

class CoreSwitchResponse(BaseModel):
    processed_output: str
    applied_action: Literal["PASS", "HARD_STOP"]
    telemetry: Telemetry

# Deterministic Cascade Logic
@app.post("/evaluate", response_model=CoreSwitchResponse, status_code=status.HTTP_200_OK)
async def evaluate_circuit_breaker(payload: CoreSwitchRequest):
    start_time = time.perf_counter()
    input_len = len(payload.raw_output)
    
    if payload.src_status == "CRITICAL" or payload.entropy_index > 0.7:
        action = "HARD_STOP"
        processed_output = ""
    else:
        action = "PASS"
        processed_output = payload.raw_output

    execution_time_ms = round((time.perf_counter() - start_time) * 1000, 4)

    return CoreSwitchResponse(
        processed_output=processed_output,
        applied_action=action,
        telemetry=Telemetry(
            execution_time_ms=execution_time_ms,
            input_length=input_len
        )
    )

@app.get("/healthz")
async def health_check():
    return {"status": "ok", "layer": "CoreSwitch Circuit Breaker"}