FEAT: email action plan or referrals backend (#182)

Co-authored-by: Claude Sonnet 4.5 <noreply@anthropic.com>

Author: michelle-hadfield-nava

app/src/common/components.py

@@ -147,13 +147,31 @@ def run(self, messages: List[ChatMessage]) -> dict:
 
 
 @component
-class LoadResult:
+class LoadResultOptional:
     """
-    Loads result from database.
+    Loads result from database with optional result_id.
+
+    If result_id is None or empty string, returns an empty dict instead of raising an error.
+    This allows pipelines to gracefully handle optional inputs.
+
+    Returns:
+        dict: {"result_json": dict} where dict is either the loaded JSON or empty dict
     """
 
-    @component.output_types(result_json=dict)
-    def run(self, result_id: str) -> dict:
+    @staticmethod
+    def _load_and_parse_result(result_id: str) -> dict:
+        """
+        Helper function to load result from database and parse JSON.
+
+        Args:
+            result_id: The UUID of the result to load
+
+        Returns:
+            dict: The parsed JSON result
+
+        Raises:
+            ValueError: If result not found or JSON parsing fails
+        """
         with config.db_session() as db_session, db_session.begin():
             db_record = (
                 db_session.query(LlmResponse).filter(LlmResponse.id == result_id).one_or_none()
@@ -172,6 +190,17 @@ def run(self, result_id: str) -> dict:
             raise ValueError(f"Invalid JSON format in result with id={result_id}: {text!r}")
 
         json_dict = json.loads(text[start : end + 1])
+        return json_dict
+
+    @component.output_types(result_json=dict)
+    def run(self, result_id: Optional[str]) -> dict:
+        # Return empty dict if no result_id provided
+        if not result_id:
+            logger.debug("No result_id provided, returning empty dict")
+            return {"result_json": {}}
+
+        # Otherwise, use shared helper to load and parse result
+        json_dict = self._load_and_parse_result(result_id)
         return {"result_json": json_dict}
 
 
@@ -346,54 +375,94 @@ def _add_child_spans(self, web_search_responses: list[ResponseFunctionWebSearch]
 Here is your personalized report with resources your case manager recommends to support your goals.
 You've already taken a great first step by exploring these options.
 
-**Your next step**: Look over the resources to see contact info and details about how to get started.
+**Your next step**: Look over the resources to see contact info and details about how to get started.\
 """
 
 
 @component
-class EmailFullResult:
+class EmailResponses:
     """
-    Formats JSON object (representing a list of resources and action plan) and sends it to email address.
+    Unified email component that handles sending resources, action plans, or both.
+
+    This component consolidates the functionality of EmailResult, EmailActionPlan, and
+    EmailFullResult into a single component that dynamically formats and sends emails
+    based on what content is provided.
+
+    Scenarios handled:
+        1. Resources only: resources_dict provided, action_plan_dict empty
+        2. Action plan only: action_plan_dict provided, resources_dict empty
+        3. Both: both dicts provided
+
+    Args:
+        email: Recipient email address
+        resources_dict: Dict containing resources data (empty dict if not provided)
+        action_plan_dict: Dict containing action plan data (empty dict if not provided)
+
+    Returns:
+        dict: Contains status ("success" or "failed"), email, and message content
+
+    Raises:
+        ValueError: If neither resources_dict nor action_plan_dict has content
     """
 
     @component.output_types(status=str, email=str, message=str)
     def run(self, email: str, resources_dict: dict, action_plan_dict: dict) -> dict:
-        logger.info("Emailing result to %s", email)
-        logger.debug("Resources JSON content:\n%s", json.dumps(resources_dict, indent=2))
-        if action_plan_dict:
-            logger.debug("Action plan JSON content:\n%s", json.dumps(action_plan_dict, indent=2))
+        # Determine what content we have
+        # Check if resources dict has a non-empty "resources" list
+        has_resources = bool(resources_dict and resources_dict.get("resources"))
+        # Check if action plan dict has content (title, summary, or content fields)
+        has_action_plan = bool(
+            action_plan_dict
+            and (
+                action_plan_dict.get("title")
+                or action_plan_dict.get("summary")
+                or action_plan_dict.get("content")
+            )
+        )
 
-        formatted_resources = format_resources(resources_dict.get("resources", []))
-        formatted_action_plan = format_action_plan(action_plan_dict)
+        # Validate that at least one type of content is provided
+        if not has_resources and not has_action_plan:
+            raise ValueError(
+                "At least one of resources_dict or action_plan_dict must contain valid data. "
+                f"Received resources_dict={bool(resources_dict)}, action_plan_dict={bool(action_plan_dict)}"
+            )
 
-        message = f"{EMAIL_INTRO}\n{formatted_resources}\n\n{formatted_action_plan}"
+        logger.info(
+            "Emailing to %s (resources=%s, action_plan=%s)", email, has_resources, has_action_plan
+        )
 
-        # Send email via AWS SES
-        subject = "Your Requested Resources and Action Plan"
-        success = send_email(recipient=email, subject=subject, body=message)
-        status = "success" if success else "failed"
+        # Log the content we're working with
+        if has_resources:
+            logger.debug("Resources JSON content:\n%s", json.dumps(resources_dict, indent=2))
+        if has_action_plan:
+            logger.debug("Action plan JSON content:\n%s", json.dumps(action_plan_dict, indent=2))
 
-        return {"status": status, "email": email, "message": message}
+        # Format content based on what's available
+        message_parts = [EMAIL_INTRO]
 
+        if has_resources:
+            formatted_resources = format_resources(resources_dict.get("resources", []))
+            message_parts.append(formatted_resources)
 
-@component
-class EmailResult:
-    """
-    Formats JSON object (representing a list of resources) and sends it to email address.
-    """
+        if has_action_plan:
+            formatted_action_plan = format_action_plan(action_plan_dict)
+            message_parts.append(formatted_action_plan)
 
-    @component.output_types(status=str, email=str, message=str)
-    def run(self, email: str, json_dict: dict) -> dict:
-        logger.info("Emailing result to %s", email)
-        logger.debug("JSON content:\n%s", json.dumps(json_dict, indent=2))
-        formatted_resources = format_resources(json_dict.get("resources", []))
-        message = f"{EMAIL_INTRO}\n{formatted_resources}"
+        message = "\n\n".join(message_parts)
+
+        # Set subject based on what's included
+        if has_resources and has_action_plan:
+            subject = "Your Requested Resources and Action Plan"
+        elif has_resources:
+            subject = "Your Requested Resources"
+        else:  # has_action_plan only
+            subject = "Your Personalized Action Plan"
 
         # Send email via AWS SES
-        subject = "Your Requested Resources"
         success = send_email(recipient=email, subject=subject, body=message)
         status = "success" if success else "failed"
 
+        logger.info("Email send status: %s", status)
         return {"status": status, "email": email, "message": message}
 
 

app/src/pipelines/email_full_result/__init__.py

@@ -0,0 +1,13 @@
+"""
+Email Responses Pipeline
+
+Consolidated pipeline for emailing resources, action plans, or both to users.
+Handles three scenarios:
+1. Email only resources (resources_result_id provided)
+2. Email only action plan (action_plan_result_id provided)
+3. Email both resources and action plan (both IDs provided)
+"""
+
+from .pipeline_wrapper import PipelineWrapper
+
+__all__ = ["PipelineWrapper"]