solves review comments

Author: Josephrp

radioshaq/radioshaq/api/routes/messages.py

@@ -369,7 +369,7 @@ async def inject_and_store(
     )
     transcript_id = None
     storage = get_transcript_storage(request)
-    if storage and getattr(storage, "_db", None):
+    if storage and getattr(storage, "db", None):
         transcript_id = await storage.store(
             session_id=f"inject-store-{uuid.uuid4().hex[:12]}",
             source_callsign=src,

radioshaq/radioshaq/database/models.py

@@ -310,7 +310,11 @@ class CoordinationEvent(Base):
     )
 
     def to_dict(self) -> dict[str, Any]:
-        """Convert to dictionary."""
+        """Convert to dictionary. Redacts emergency_contact_phone in extra_data for privacy."""
+        extra = dict(self.extra_data) if self.extra_data else {}
+        if "emergency_contact_phone" in extra and extra["emergency_contact_phone"]:
+            raw = str(extra["emergency_contact_phone"])
+            extra["emergency_contact_phone"] = "****" + raw[-4:] if len(raw) >= 4 else "****"
         return {
             "id": self.id,
             "event_type": self.event_type,
@@ -323,7 +327,7 @@ def to_dict(self) -> dict[str, Any]:
             "priority": self.priority,
             "notes": self.notes,
             "created_at": self.created_at.isoformat() if self.created_at else None,
-            "extra_data": self.extra_data,
+            "extra_data": extra,
         }
 
 

radioshaq/radioshaq/orchestrator/factory.py

@@ -408,12 +408,14 @@ def create_tool_registry(config: Config, db: Any = None, *, app: Any = None) ->
                 app.state.agent_registry.get_agent("radio_tx")
                 if getattr(app.state, "agent_registry", None) else None
             )
+            message_bus = getattr(app.state, "message_bus", None) if app else None
             relay_tool = RelayMessageTool(
                 storage=storage,
                 injection_queue=injection_queue,
                 get_radio_tx=get_radio_tx,
                 config=config,
                 callsign_repository=callsign_repo,
+                message_bus=message_bus,
             )
             registry.register(relay_tool)
             logger.debug("Registered relay tool: %s", relay_tool.name)

radioshaq/radioshaq/specialized/radio_rx_audio.py

@@ -392,7 +392,7 @@ async def _on_segment_ready(self, segment: Any) -> None:
             return
 
         # Optionally store voice transcript (band, source=voice_listener) for GET /transcripts and relay
-        if getattr(self._radio_config, "voice_store_transcript", False) and self._transcript_storage and getattr(self._transcript_storage, "_db", None):
+        if getattr(self._radio_config, "voice_store_transcript", False) and self._transcript_storage and getattr(self._transcript_storage, "db", None):
             min_len = getattr(self._radio_config, "voice_store_min_length", 0) or 0
             keywords = getattr(self._radio_config, "voice_store_keywords", None) or []
             stripped = transcript.strip()

radioshaq/radioshaq/specialized/relay_tools.py

@@ -6,8 +6,10 @@
 from typing import Any
 
 from radioshaq.compliance_plugin import get_band_plan_source_for_config
+from radioshaq.constants import E164_PATTERN
 from radioshaq.radio.bands import BAND_PLANS
 from radioshaq.relay.service import relay_message_between_bands_service
+from radioshaq.utils.phone import normalize_e164
 
 # Optional ISO datetime for deliver_at (lenient)
 DELIVER_AT_PATTERN = re.compile(
@@ -34,12 +36,14 @@ def __init__(
         get_radio_tx: Any = None,
         config: Any = None,
         callsign_repository: Any = None,
+        message_bus: Any = None,
     ) -> None:
         self._storage = storage
         self._injection_queue = injection_queue
         self._get_radio_tx = get_radio_tx
         self._config = config
         self._callsign_repository = callsign_repository
+        self._message_bus = message_bus
 
     def to_schema(self) -> dict[str, Any]:
         return {
@@ -119,6 +123,12 @@ def validate_params(self, params: dict[str, Any]) -> list[str]:
             errors.append("target_channel must be radio, sms, or whatsapp")
         if target_channel in ("sms", "whatsapp") and not destination_phone:
             errors.append("destination_phone is required when target_channel is sms or whatsapp")
+        if target_channel in ("sms", "whatsapp") and destination_phone:
+            normalised = normalize_e164(destination_phone)
+            if not E164_PATTERN.match(normalised):
+                errors.append(
+                    f"destination_phone must be E.164 (e.g. +14155552671); got: {destination_phone!r}"
+                )
         if params.get("emergency") is True and target_channel not in ("sms", "whatsapp"):
             errors.append("emergency only applies when target_channel is sms or whatsapp")
         config = self._config
@@ -165,7 +175,7 @@ async def execute(
         emergency: bool = False,
         **kwargs: Any,
     ) -> str:
-        if self._storage is None or not getattr(self._storage, "_db", None):
+        if self._storage is None or getattr(self._storage, "db", None) is None:
             return "Error: Relay not available (no storage)."
 
         config = self._config
@@ -223,6 +233,7 @@ async def execute(
             target_channel=(target_channel or "radio").strip().lower(),
             destination_phone=(destination_phone or "").strip() or None,
             emergency=emergency,
+            message_bus=self._message_bus,
         )
 
         if not result.get("ok"):

radioshaq/radioshaq/specialized/sms_agent.py

@@ -64,12 +64,20 @@ async def _send(
                 "notes": "Twilio client or from_number not configured",
                 "reason": "twilio_not_configured",
             }
+        from_e164 = normalize_e164(self.from_number)
+        if not from_e164:
+            return {
+                "success": False,
+                "to": to,
+                "notes": "from_number normalizes to empty string; check Twilio sender config",
+                "reason": "invalid_from",
+            }
 
         try:
             msg = await asyncio.to_thread(
                 self.twilio_client.messages.create,
                 body=body,
-                from_=normalize_e164(self.from_number),
+                from_=from_e164,
                 to=to,
             )
             result = {

radioshaq/radioshaq/specialized/whatsapp_agent.py

@@ -83,6 +83,12 @@ async def _do_send(self, to: str, message: str) -> dict[str, Any]:
                 "to": to,
                 "notes": "to (phone number) is required",
             }
+        if not from_e164:
+            return {
+                "success": False,
+                "to": to,
+                "notes": "from_number normalizes to empty string; check Twilio WhatsApp sender config",
+            }
         try:
             msg = await asyncio.to_thread(
                 self.client.messages.create,

radioshaq/tests/unit/specialized/test_relay_tools.py

@@ -94,7 +94,8 @@ async def test_relay_tool_execute_no_storage_returns_error() -> None:
 @pytest.mark.asyncio
 async def test_relay_tool_execute_calls_service_and_formats_result() -> None:
     """Execute calls relay_message_between_bands_service and returns string with Relayed and ids."""
-    storage = MagicMock(_db=MagicMock())
+    storage = MagicMock()
+    storage.db = MagicMock()
     storage.store = AsyncMock(side_effect=[101, 102])
     queue = MagicMock()
     get_radio_tx = MagicMock(return_value=None)