Deep-dive · Health Layer + Medical Wearables¶

# agents/medical-agent/providers/base.py
from abc import ABC, abstractmethod
from datetime import date
from pydantic import BaseModel


class SleepRecord(BaseModel):
    date: date
    total_sleep_minutes: int
    deep_sleep_minutes: int
    rem_sleep_minutes: int
    efficiency_pct: float
    latency_minutes: int
    source: str


class HRVRecord(BaseModel):
    timestamp: str
    rmssd_ms: float
    sdnn_ms: float | None = None
    source: str


class ActivityRecord(BaseModel):
    date: date
    steps: int
    active_calories: int
    distance_meters: float
    source: str


class BaseWearableProvider(ABC):
    provider_id: str
    display_name: str

    @abstractmethod
    async def fetch_sleep(self, days: int = 7) -> list[SleepRecord]: ...

    @abstractmethod
    async def fetch_hrv(self, days: int = 7) -> list[HRVRecord]: ...

    @abstractmethod
    async def fetch_activity(self, days: int = 7) -> list[ActivityRecord]: ...

    @abstractmethod
    async def refresh_token(self) -> None: ...

PROVIDER_PRIORITY = {
    "dexcom": 100,    # FDA-cleared
    "oura": 80,
    "whoop": 75,
    "polar": 70,
    "garmin": 65,
    "apple_healthkit": 60,
    "withings": 55,
}


def resolve_hr(readings: list[tuple[str, float]], strategy: str) -> float:
    if strategy == "highest_priority":
        return max(readings, key=lambda r: PROVIDER_PRIORITY.get(r[0], 0))[1]
    if strategy == "average":
        return sum(v for _, v in readings) / len(readings)
    if strategy == "most_recent":
        return readings[-1][1]
    raise ValueError(strategy)

# Scope: email, personal, daily, heartrate, workout, spo2Daily
# Rate limit: 5000 req / 5 min · Token expiry: 1h

class OuraProvider(BaseWearableProvider):
    provider_id = "oura"

    def __init__(self, access_token, refresh_token, client_id, client_secret):
        self._access_token = access_token
        self._refresh_token = refresh_token
        self._client_id = client_id
        self._client_secret = client_secret

    async def refresh_token(self):
        async with httpx.AsyncClient() as c:
            r = await c.post(
                "https://api.ouraring.com/oauth/token",
                data={
                    "grant_type": "refresh_token",
                    "refresh_token": self._refresh_token,
                    "client_id": self._client_id,
                    "client_secret": self._client_secret,
                },
            )
            r.raise_for_status()
            p = r.json()
            self._access_token = p["access_token"]
            self._refresh_token = p["refresh_token"]

    async def fetch_sleep(self, days=7):
        start = (date.today() - timedelta(days=days)).isoformat()
        async with httpx.AsyncClient() as c:
            r = await c.get(
                "https://api.ouraring.com/v2/usercollection/daily_sleep",
                headers={"Authorization": f"Bearer {self._access_token}"},
                params={"start_date": start},
            )
            r.raise_for_status()
            return [
                SleepRecord(
                    date=item["day"],
                    total_sleep_minutes=item["contributors"]["total_sleep"] // 60,
                    deep_sleep_minutes=item["contributors"]["deep_sleep"] // 60,
                    rem_sleep_minutes=item["contributors"]["rem_sleep"] // 60,
                    efficiency_pct=item["contributors"]["efficiency"],
                    latency_minutes=item["contributors"]["latency"] // 60,
                    source="oura",
                )
                for item in r.json().get("data", [])
            ]

class WhoopProvider(BaseWearableProvider):
    provider_id = "whoop"

    def validate_webhook_signature(self, raw_body: bytes, signature: str) -> bool:
        expected = hmac.new(
            self._webhook_secret.encode(), raw_body, hashlib.sha256
        ).hexdigest()
        return hmac.compare_digest(expected, signature)

    async def fetch_sleep(self, days=7):
        start = (date.today() - timedelta(days=days)).isoformat()
        async with httpx.AsyncClient() as c:
            r = await c.get(
                "https://api.prod.whoop.com/developer/v1/activity/sleep",
                headers={"Authorization": f"Bearer {self._access_token}"},
                params={"start": f"{start}T00:00:00.000Z", "limit": 25},
            )
            r.raise_for_status()
            return [_to_sleep_record(item) for item in r.json().get("records", [])]


# Subscribe webhook (one-time)
async def subscribe_whoop_webhook(token: str, callback_url: str):
    async with httpx.AsyncClient() as c:
        await c.post(
            "https://api.prod.whoop.com/developer/v1/webhook",
            headers={"Authorization": f"Bearer {token}"},
            json={
                "url": callback_url,
                "event_types": ["recovery.updated", "sleep.updated", "workout.updated"],
            },
        )

# Accesso unificato
async with httpx.AsyncClient(base_url="http://openwearables:3000") as c:
    sleep = await c.get("/api/sleep", params={"days": 7})
    hrv = await c.get("/api/hrv", params={"days": 7})

class CoachingContext(BaseModel):
    user_id: str
    avg_hrv_7d: float
    hrv_trend: str
    avg_sleep_efficiency: float
    resting_hr_trend: str
    training_load_7d: str
    glucose_avg_mgdl: float | None = None


COACHING_PROMPT = """
Sei un coach della salute personale. Analizza i dati biometrici degli ultimi
7 giorni e fornisci raccomandazioni concrete. NON fare diagnosi mediche.
Output: 1 insight principale + 1 raccomandazione immediata + 1 settimanale.
DISCLAIMER: Non sostituisce il parere del medico.
"""

class AuditEvent(BaseModel):
    timestamp: str
    user_id: str
    action: str  # read|write|delete|export
    resource_type: str
    resource_id: str
    provider: str
    outcome: str  # success|denied|error


def log_health_access(event: AuditEvent) -> None:
    log.info("health_data_access", **event.model_dump())
    # Scrivere anche FHIR AuditEvent resource

async def delete_user_health_data(user_id: str, fhir_base: str, token: str):
    async with httpx.AsyncClient() as c:
        # Cancella Observation
        search = await c.get(
            f"{fhir_base}/Observation",
            headers={"Authorization": f"Bearer {token}"},
            params={"subject": f"Patient/{user_id}"},
        )
        for entry in search.json().get("entry", []):
            await c.delete(
                f"{fhir_base}/Observation/{entry['resource']['id']}",
                headers={"Authorization": f"Bearer {token}"},
            )
        # Cancella Patient
        await c.delete(
            f"{fhir_base}/Patient/{user_id}",
            headers={"Authorization": f"Bearer {token}"},
        )
        # Revoca tutti i token OAuth dal vault (operazione separata)