Enhance API endpoints with async locking and error handling

Refactor /reset, /step, and /state endpoints to use async locks for thread safety. Update ResetRequest to handle optional seed.

src/api.py

@@ -8,32 +8,31 @@ Exposes HTTP endpoints for environment interaction:
   GET  /health  — Health check (returns 200)
 """
 
-from fastapi import FastAPI
+import asyncio
+from typing import Any, Dict, Optional
+
+from fastapi import FastAPI, HTTPException, Request
 from pydantic import BaseModel
-from typing import Any, Dict
 
 from src.models import Observation, Action, Reward, State
 from src.env import PLLAttackEnv
 
-
 app = FastAPI(
     title="PLL Cyberattack Detection OpenEnv",
     description="OpenEnv for AI-driven cyberattack detection on SRF-PLLs",
     version="1.0.0",
 )
 
-# Global environment instance
 env = PLLAttackEnv()
+env_lock = asyncio.Lock()
 
 
 class ResetRequest(BaseModel):
-    """Request body for /reset endpoint."""
     task_id: int = 0
-    seed: int = None
+    seed: Optional[int] = None
 
 
 class StepResponse(BaseModel):
-    """Response body for /step endpoint."""
     observation: Observation
     reward: Reward
     done: bool
@@ -41,31 +40,36 @@ class StepResponse(BaseModel):
 
 
 @app.post("/reset", response_model=Observation)
-async def reset(request: ResetRequest):
+async def reset(req: Request):
     """Reset the environment and return initial observation."""
-    obs = env.reset(task_id=request.task_id, seed=request.seed)
-    return obs
+    async with env_lock:
+        try:
+            body = await req.body()
+            if body:
+                data = await req.json()
+                request = ResetRequest(**data)
+            else:
+                request = ResetRequest()
+        except Exception:
+            request = ResetRequest()
+        return env.reset(task_id=request.task_id, seed=request.seed)
 
 
 @app.post("/step", response_model=StepResponse)
 async def step(action: Action):
-    """Submit an action and advance the environment one step."""
-    obs, reward, done, info = env.step(action)
-    return StepResponse(
-        observation=obs,
-        reward=reward,
-        done=done,
-        info=info,
-    )
+    async with env_lock:
+        if env.attack_generator is None:
+            raise HTTPException(status_code=400, detail="Call /reset before /step")
+        obs, reward, done, info = env.step(action)
+        return StepResponse(observation=obs, reward=reward, done=done, info=info)
 
 
 @app.get("/state", response_model=State)
 async def get_state():
-    """Return the current internal state."""
-    return env.get_state()
+    async with env_lock:
+        return env.get_state()
 
 
 @app.get("/health")
 async def health():
-    """Health check endpoint."""
     return {"status": "ok"}