Wire medication reminders into Sam runtime

mr_reachy/main.py

@@ -25,7 +25,10 @@ from reachy_mini import ReachyMini, ReachyMiniApp
 from . import expressions
 from .config import ServiceConfig, load_settings
 from .io_backends import LocalBackend, RobotBackend, select_backend
+from .medication import is_confirmation_intent, is_medication_intent, parse_medication_instruction, plan_summary
 from .og_client import OGClient, Reply
+from .reminders import confirm_due_dose, start_reminder_thread
+from .storage import HybridMedicationStore, build_medication_store
 
 # Phrases that make Sam try to look and describe the scene (0G vision).
 _VISION_INTENT = re.compile(
@@ -53,9 +56,40 @@ def express_and_speak(reachy, reply: Reply, *, backend, voice: str | None, speak
     expressions.talk_animation(reachy, done)
 
 
-def handle_turn(reachy, og, history: list[dict], user_text: str, *, backend, voice, speak) -> Reply:
+def handle_turn(
+    reachy,
+    og,
+    history: list[dict],
+    user_text: str,
+    *,
+    backend,
+    voice,
+    speak,
+    medication_store: HybridMedicationStore | None = None,
+) -> Reply:
     """Run one full think+react turn for the given user utterance."""
     user_text = user_text.strip()
+
+    if medication_store is not None and is_confirmation_intent(user_text):
+        confirmed, message = confirm_due_dose(medication_store)
+        reply = Reply(speech=message, emotion="happy" if confirmed else "curious")
+        print(f"  Sam [{reply.emotion}]: {reply.speech}")
+        express_and_speak(reachy, reply, backend=backend, voice=voice, speak=speak)
+        return reply
+
+    if medication_store is not None and is_medication_intent(user_text):
+        result = parse_medication_instruction(user_text, og)
+        if result.accepted and result.plan is not None:
+            memory = medication_store.load()
+            memory.plans.append(result.plan)
+            medication_store.save(memory)
+            reply = Reply(speech=plan_summary(result.plan), emotion="happy")
+        else:
+            reply = Reply(speech=result.reason, emotion="confused")
+        print(f"  Sam [{reply.emotion}]: {reply.speech}")
+        express_and_speak(reachy, reply, backend=backend, voice=voice, speak=speak)
+        return reply
+
     history.append({"role": "user", "content": user_text})
 
     # Optional vision: only if the user asked AND a vision provider is funded.
@@ -88,6 +122,7 @@ def run_conversation(
     mode: str = "voice",
     voice: str | None = None,
     speak: bool = True,
+    medication_store: HybridMedicationStore | None = None,
 ) -> None:
     """The main loop. mode='voice' uses the backend mic; mode='text' reads stdin."""
     if reachy is None and mode != "text":
@@ -106,6 +141,14 @@ def run_conversation(
     print(f"  Sam [{greeting.emotion}]: {greeting.speech}")
     express_and_speak(reachy, greeting, backend=backend, voice=voice, speak=speak)
 
+    reminder_thread = None
+    if medication_store is not None:
+        reminder_thread = start_reminder_thread(
+            store=medication_store,
+            stop_event=stop_event,
+            notify=lambda reply: express_and_speak(reachy, reply, backend=backend, voice=voice, speak=speak),
+        )
+
     while not stop_event.is_set():
         if mode == "text":
             try:
@@ -153,7 +196,16 @@ def run_conversation(
                 break
 
         try:
-            handle_turn(reachy, og, history, user_text, backend=backend, voice=voice, speak=speak)
+            handle_turn(
+                reachy,
+                og,
+                history,
+                user_text,
+                backend=backend,
+                voice=voice,
+                speak=speak,
+                medication_store=medication_store,
+            )
         except Exception as exc:
             print(f"  [error] {exc}")
             express_and_speak(
@@ -166,6 +218,8 @@ def run_conversation(
 
     if reachy is not None:
         expressions.go_rest(reachy)
+    if reminder_thread is not None:
+        reminder_thread.join(timeout=1.0)
     print("\nSam: bye!")
 
 
@@ -188,10 +242,20 @@ class MrReachy(ReachyMiniApp):
         return RobotBackend() if self.running_on_wireless else LocalBackend()
 
     def run(self, reachy_mini: ReachyMini, stop_event: threading.Event) -> None:
-        og = OGClient(load_settings())
+        settings = load_settings()
+        og = OGClient(settings)
+        medication_store = build_medication_store(settings.storage)
         backend = self._backend()
         print(f"Sam backend: {backend.name}")
-        run_conversation(reachy_mini, stop_event, og=og, backend=backend, mode="voice", speak=True)
+        run_conversation(
+            reachy_mini,
+            stop_event,
+            og=og,
+            backend=backend,
+            mode="voice",
+            speak=True,
+            medication_store=medication_store,
+        )
 
 
 # --------------------------------------------------------------------------- #
@@ -205,6 +269,10 @@ def _build_client() -> OGClient:
     return og
 
 
+def _build_medication_store() -> HybridMedicationStore:
+    return build_medication_store(load_settings().storage)
+
+
 def _service_status(name: str, cfg: ServiceConfig) -> str:
     missing = []
     if not cfg.base_url:
@@ -306,12 +374,30 @@ def cli(argv: list[str] | None = None) -> None:
             if reachy is not None:
                 reachy.wake_up()
                 expressions.go_rest(reachy)
-            handle_turn(reachy, og, [], args.once, backend=backend, voice=args.voice, speak=speak)
+            handle_turn(
+                reachy,
+                og,
+                [],
+                args.once,
+                backend=backend,
+                voice=args.voice,
+                speak=speak,
+                medication_store=_build_medication_store(),
+            )
             if reachy is not None:
                 expressions.go_rest(reachy)
             return
         mode = "text" if args.text else "voice"
-        run_conversation(reachy, stop_event, og=og, backend=backend, mode=mode, voice=args.voice, speak=speak)
+        run_conversation(
+            reachy,
+            stop_event,
+            og=og,
+            backend=backend,
+            mode=mode,
+            voice=args.voice,
+            speak=speak,
+            medication_store=_build_medication_store(),
+        )
 
 
 if __name__ == "__main__":

mr_reachy/reminders.py

@@ -0,0 +1,144 @@
+"""Background reminder loop for Sam medication doses."""
+
+from __future__ import annotations
+
+import os
+import threading
+import time
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Callable
+
+from .medication import Dose, MedicationMemory, _now_iso
+from .storage import HybridMedicationStore
+
+
+MAX_REMINDERS = 3
+REMINDER_CHECK_SECONDS = float(os.getenv("SAM_REMINDER_CHECK_SECONDS", "30"))
+REMINDER_RETRY_SECONDS = float(os.getenv("SAM_REMINDER_RETRY_SECONDS", "300"))
+
+
+@dataclass
+class ReminderReply:
+    speech: str
+    emotion: str = "neutral"
+
+
+def start_reminder_thread(
+    *,
+    store: HybridMedicationStore,
+    stop_event: threading.Event,
+    notify: Callable[[ReminderReply], None],
+    check_seconds: float = REMINDER_CHECK_SECONDS,
+    retry_seconds: float = REMINDER_RETRY_SECONDS,
+) -> threading.Thread:
+    thread = threading.Thread(
+        target=_run_loop,
+        kwargs={
+            "store": store,
+            "stop_event": stop_event,
+            "notify": notify,
+            "check_seconds": check_seconds,
+            "retry_seconds": retry_seconds,
+        },
+        daemon=True,
+    )
+    thread.start()
+    return thread
+
+
+def confirm_due_dose(store: HybridMedicationStore, now: datetime | None = None) -> tuple[bool, str]:
+    memory = store.load()
+    due = memory.active_pending_doses(now)
+    if not due:
+        return False, "I do not have a due medication waiting for confirmation right now."
+
+    dose = due[0]
+    plan = memory.plan_for_dose(dose.id)
+    dose.status = "confirmed"
+    dose.confirmed_at = _now_iso(now)
+    memory.updated_at = _now_iso(now)
+    store.save(memory)
+    name = plan.medication_name if plan is not None else "your medicine"
+    return True, f"Thank you. I marked your {name} dose as taken."
+
+
+def process_due_reminders(
+    *,
+    store: HybridMedicationStore,
+    notify: Callable[[ReminderReply], None],
+    now: datetime | None = None,
+    retry_seconds: float = REMINDER_RETRY_SECONDS,
+) -> bool:
+    now = now or datetime.now().astimezone()
+    memory = store.load()
+    changed = False
+    for dose in memory.active_pending_doses(now):
+        if _should_mark_missed(dose):
+            dose.status = "missed"
+            dose.missed_at = _now_iso(now)
+            changed = True
+            plan = memory.plan_for_dose(dose.id)
+            name = plan.medication_name if plan is not None else "your medicine"
+            notify(ReminderReply(speech=f"I am worried. I could not confirm your {name} dose.", emotion="sad"))
+            continue
+        if _should_remind(dose, retry_seconds, now):
+            plan = memory.plan_for_dose(dose.id)
+            name = plan.medication_name if plan is not None else "your medicine"
+            dose.reminder_count += 1
+            dose.last_reminded_at = _now_iso(now)
+            changed = True
+            notify(
+                    ReminderReply(
+                    speech=f"It is time for your {name}. Please take it now, then tell me when you have taken it.",
+                    emotion="thinking",
+                )
+            )
+    if changed:
+        memory.updated_at = _now_iso(now)
+        store.save(memory)
+    else:
+        store.sync_pending_async()
+    return changed
+
+
+def medication_status_text(memory: MedicationMemory) -> str:
+    if not memory.plans:
+        return "No medication reminders saved yet."
+    lines: list[str] = []
+    for plan in memory.plans:
+        pending = sum(1 for dose in plan.doses if dose.status == "pending")
+        confirmed = sum(1 for dose in plan.doses if dose.status == "confirmed")
+        missed = sum(1 for dose in plan.doses if dose.status == "missed")
+        times = ", ".join(plan.dose_times)
+        lines.append(
+            f"{plan.medication_name}: {plan.frequency_per_day}x/day at {times} "
+            f"for {plan.duration_days} days. Confirmed {confirmed}, pending {pending}, missed {missed}."
+        )
+    sync = "0G sync pending" if memory.pending_sync else "0G sync current"
+    if memory.last_sync_error:
+        sync = f"{sync}; last sync error: {memory.last_sync_error}"
+    return "\n".join([*lines, sync])
+
+
+def _run_loop(
+    *,
+    store: HybridMedicationStore,
+    stop_event: threading.Event,
+    notify: Callable[[ReminderReply], None],
+    check_seconds: float,
+    retry_seconds: float,
+) -> None:
+    while not stop_event.wait(check_seconds):
+        process_due_reminders(store=store, notify=notify, retry_seconds=retry_seconds)
+
+
+def _should_remind(dose: Dose, retry_seconds: float, now: datetime | None = None) -> bool:
+    if dose.reminder_count == 0 or not dose.last_reminded_at:
+        return True
+    last = datetime.fromisoformat(dose.last_reminded_at)
+    return ((now or datetime.now().astimezone()) - last).total_seconds() >= retry_seconds
+
+
+def _should_mark_missed(dose: Dose) -> bool:
+    return dose.reminder_count >= MAX_REMINDERS

tests/test_reminders.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+import tempfile
+import unittest
+from datetime import datetime, timedelta
+from pathlib import Path
+
+from mr_reachy.medication import MedicationMemory, build_plan
+from mr_reachy.reminders import confirm_due_dose, process_due_reminders
+from mr_reachy.storage import HybridMedicationStore, LocalMedicationStore
+
+
+def _store_with_due_plan(tmp: str) -> tuple[HybridMedicationStore, datetime]:
+    now = datetime(2026, 5, 28, 9, 5).astimezone()
+    plan = build_plan(
+        raw_instruction="Take metformin once a day for one day.",
+        medication_name="metformin",
+        frequency_per_day=1,
+        duration_days=1,
+        dose_times=["09:00"],
+        now=now,
+    )
+    store = HybridMedicationStore(LocalMedicationStore(Path(tmp) / "memory.json"), auto_sync=False)
+    store.save(MedicationMemory(plans=[plan]))
+    return store, now
+
+
+class ReminderTest(unittest.TestCase):
+    def test_due_dose_triggers_reminder(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            store, now = _store_with_due_plan(tmp)
+            replies = []
+
+            changed = process_due_reminders(store=store, notify=replies.append, now=now)
+            memory = store.load()
+
+            self.assertTrue(changed)
+            self.assertEqual(len(replies), 1)
+            self.assertIn("metformin", replies[0].speech)
+            self.assertEqual(memory.plans[0].doses[0].reminder_count, 1)
+
+    def test_confirmation_marks_due_dose_complete(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            store, now = _store_with_due_plan(tmp)
+
+            confirmed, message = confirm_due_dose(store, now=now)
+            memory = store.load()
+
+            self.assertTrue(confirmed)
+            self.assertIn("metformin", message)
+            self.assertEqual(memory.plans[0].doses[0].status, "confirmed")
+
+    def test_missed_dose_after_three_reminders(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            store, now = _store_with_due_plan(tmp)
+            memory = store.load()
+            dose = memory.plans[0].doses[0]
+            dose.reminder_count = 3
+            dose.last_reminded_at = (now - timedelta(minutes=10)).isoformat()
+            store.save(memory)
+            replies = []
+
+            changed = process_due_reminders(store=store, notify=replies.append, now=now)
+            updated = store.load()
+
+            self.assertTrue(changed)
+            self.assertEqual(updated.plans[0].doses[0].status, "missed")
+            self.assertEqual(replies[0].emotion, "sad")
+
+
+if __name__ == "__main__":
+    unittest.main()