Create app.py

app.py

@@ -0,0 +1,168 @@
+import os
+import uvicorn
+from fastapi import FastAPI, HTTPException, Path, Query
+from pydantic import BaseModel
+from typing import Optional, Any
+from utils.supabase_client import supabase, get_pending_tasks, lock_task, unlock_task, submit_task_decision, fetch_context_for_task
+import datetime
+
+app = FastAPI(title="CareFlow Nexus Backend API")
+
+# --- Pydantic models
+class PatientIn(BaseModel):
+    name: str
+    age: Optional[int] = None
+    issue: Optional[str] = None
+    priority: Optional[str] = "normal"
+
+class TaskDecision(BaseModel):
+    action: str
+    bed_id: Optional[int] = None
+    nurse_id: Optional[int] = None
+    cleaner_id: Optional[int] = None
+    reason: Optional[str] = None
+    details: Optional[Any] = None
+
+# --- Frontend endpoints
+@app.post("/api/patients")
+def create_patient(inp: PatientIn):
+    data = {
+        "name": inp.name,
+        "age": inp.age,
+        "issue": inp.issue,
+        "status": "pending_bed",
+        "created_at": datetime.datetime.utcnow().isoformat()
+    }
+    res = supabase.table("patients").insert([data]).execute()
+    if res.status_code != 201 and res.status_code != 200:
+        raise HTTPException(status_code=500, detail="Failed to insert patient")
+    patient = res.data[0]
+    return {"patient": patient}
+
+@app.post("/api/patients/{patient_id}/admit")
+def admit_patient(patient_id: int = Path(...)):
+    # create initial bed_assignment task assigned to MASTER agent per spec
+    task = {
+        "type": "bed_assignment",
+        "target_role": "AGENT",
+        "agent_role": "MASTER",
+        "assigned_to": None,
+        "patient_id": patient_id,
+        "bed_id": None,
+        "status": "pending",
+        "created_at": datetime.datetime.utcnow().isoformat()
+    }
+    res = supabase.table("tasks").insert([task]).execute()
+    if res.error:
+        raise HTTPException(status_code=500, detail="Failed to create bed_assignment task")
+    return {"ok": True, "task_created": res.data[0]}
+
+@app.get("/api/beds")
+def get_beds():
+    res = supabase.table("beds").select("*").execute()
+    return {"beds": res.data}
+
+@app.get("/api/logs")
+def get_logs(limit: int = Query(100)):
+    res = supabase.table("logs").select("*").order("timestamp", {"ascending": False}).limit(limit).execute()
+    return {"logs": res.data}
+
+# --- Agent-facing endpoints
+@app.get("/api/tasks/pending")
+def tasks_pending(role: str = Query(...), include: Optional[str] = Query(None)):
+    """
+    Agents call this to fetch pending tasks for their role.
+    Backend locks task immediately to prevent double-processing.
+    """
+    tasks = get_pending_tasks(role)
+    # convert and lock first N tasks (be conservative - return one by default)
+    if not tasks:
+        return []
+    out = []
+    for t in tasks:
+        task_id = t.get("id")
+        # lock
+        lock_task(task_id)
+        # attach context if requested
+        if include and "context" in include:
+            context = fetch_context_for_task(t)
+            t["context"] = context
+        out.append(t)
+    return out
+
+@app.post("/api/agent/tasks/{task_id}/decision")
+def agent_decision(task_id: int, decision: TaskDecision):
+    """
+    Validate the agent decision, apply DB updates, and generate follow-up tasks.
+    This follows your workflow rules from the spec. Agents return simple JSON actions.
+    """
+    # fetch task
+    t = supabase.table("tasks").select("*").eq("id", task_id).single().execute()
+    if t.error or not t.data:
+        raise HTTPException(status_code=404, detail="Task not found")
+    task = t.data
+    # basic validation
+    if task["status"] not in ("locked", "pending"):
+        raise HTTPException(status_code=409, detail="Task not in processable state")
+
+    # handle actions
+    action = decision.action
+    if action == "assign_bed":
+        if not decision.bed_id:
+            return {"error": "bed_id required"}
+        # update bed and admission/patient state
+        supabase.table("beds").update({"status": "pending_cleaning", "patient_id": task.get("patient_id")}).eq("id", decision.bed_id).execute()
+        # update patient status
+        supabase.table("patients").update({"status": "awaiting_cleaning"}).eq("id", task.get("patient_id")).execute()
+        # create cleaning task for CLEANER
+        new_task = {
+            "type": "cleaning",
+            "target_role": "AGENT",
+            "agent_role": "CLEANER",
+            "patient_id": task.get("patient_id"),
+            "bed_id": decision.bed_id,
+            "status": "pending",
+            "created_at": datetime.datetime.utcnow().isoformat()
+        }
+        supabase.table("tasks").insert([new_task]).execute()
+        # write decision log
+        supabase.table("logs").insert([{"message": f"MASTER assigned bed {decision.bed_id} to patient {task.get('patient_id')}", "timestamp": datetime.datetime.utcnow().isoformat()}]).execute()
+    elif action == "assign_cleaner":
+        if not decision.cleaner_id or not task.get("bed_id"):
+            return {"error": "cleaner_id and bed context required"}
+        # mark cleaner busy and bed cleaning_in_progress
+        supabase.table("staff").update({"available": False}).eq("id", decision.cleaner_id).execute()
+        supabase.table("beds").update({"status": "cleaning_in_progress", "cleaner_id": decision.cleaner_id}).eq("id", task.get("bed_id")).execute()
+        supabase.table("logs").insert([{"message": f"CLEANER {decision.cleaner_id} cleaning bed {task.get('bed_id')}", "timestamp": datetime.datetime.utcnow().isoformat()}]).execute()
+    elif action == "assign_nurse":
+        if not decision.nurse_id:
+            return {"error": "nurse_id required"}
+        # assign nurse and schedule tasks
+        supabase.table("staff").update({"available": False}).eq("id", decision.nurse_id).execute()
+        # set bed's nurse_id
+        supabase.table("beds").update({"nurse_id": decision.nurse_id}).eq("id", task.get("bed_id")).execute()
+        # schedule a nurse_checkup task immediately (example)
+        nurse_task = {
+            "type": "nurse_checkup",
+            "target_role": "HUMAN",
+            "agent_role": None,
+            "assigned_to": decision.nurse_id,
+            "patient_id": task.get("patient_id"),
+            "bed_id": task.get("bed_id"),
+            "status": "pending",
+            "scheduled_at": datetime.datetime.utcnow().isoformat(),
+            "created_at": datetime.datetime.utcnow().isoformat()
+        }
+        supabase.table("tasks").insert([nurse_task]).execute()
+        supabase.table("logs").insert([{"message": f"NURSE {decision.nurse_id} assigned to bed {task.get('bed_id')}", "timestamp": datetime.datetime.utcnow().isoformat()}]).execute()
+    elif action == "defer":
+        # put task back to pending and set a retry timestamp or note
+        supabase.table("tasks").update({"status": "pending", "retry_after": (datetime.datetime.utcnow() + datetime.timedelta(minutes=5)).isoformat()}).eq("id", task_id).execute()
+        supabase.table("logs").insert([{"message": f"TASK {task_id} deferred by agent: {decision.reason}", "timestamp": datetime.datetime.utcnow().isoformat()}]).execute()
+        return {"ok": True}
+    else:
+        return {"error": "unknown action"}
+
+    # mark current task completed
+    supabase.table("tasks").update({"status": "completed"}).eq("id", task_id).execute()
+    return {"ok": True}