dhisana 0.0.1.dev278__py3-none-any.whl → 0.0.1.dev280__py3-none-any.whl

dhisana/utils/microsoft365_tools.py

@@ -15,6 +15,64 @@ from dhisana.schemas.sales import MessageItem
 from dhisana.utils.email_body_utils import body_variants
 
 
+def _normalize_recipient(recipient: Any) -> Optional[Dict[str, str]]:
+    if recipient is None:
+        return None
+    if isinstance(recipient, dict):
+        email = recipient.get("email") or recipient.get("address")
+        name = recipient.get("name")
+    else:
+        email = getattr(recipient, "email", None) or getattr(recipient, "address", None)
+        name = getattr(recipient, "name", None)
+        if isinstance(recipient, str):
+            email = recipient
+            name = None
+    if not email:
+        return None
+    return {"email": email, "name": name}
+
+
+def _normalize_recipients(recipients: Optional[List[Any]]) -> List[Dict[str, str]]:
+    normalized: List[Dict[str, str]] = []
+    for recipient in recipients or []:
+        item = _normalize_recipient(recipient)
+        if item:
+            normalized.append(item)
+    return normalized
+
+
+def _dedupe_recipients(
+    recipients: List[Dict[str, str]],
+    exclude_emails: Optional[List[str]] = None,
+) -> List[Dict[str, str]]:
+    excluded = {email.lower() for email in (exclude_emails or []) if email}
+    seen: set[str] = set()
+    result: List[Dict[str, str]] = []
+    for recipient in recipients:
+        email = (recipient.get("email") or "").strip()
+        if not email:
+            continue
+        email_lc = email.lower()
+        if email_lc in seen or email_lc in excluded:
+            continue
+        seen.add(email_lc)
+        result.append({"email": email, "name": recipient.get("name")})
+    return result
+
+
+def _recipients_to_m365(recipients: List[Dict[str, str]]) -> List[Dict[str, Any]]:
+    result: List[Dict[str, Any]] = []
+    for recipient in recipients:
+        email = recipient.get("email")
+        if not email:
+            continue
+        payload = {"emailAddress": {"address": email}}
+        name = recipient.get("name")
+        if name:
+            payload["emailAddress"]["name"] = name
+        result.append(payload)
+    return result
+
 def get_microsoft365_access_token(tool_config: Optional[List[Dict]] = None) -> str:
     """
     Retrieve a Microsoft Graph OAuth2 access token from tool_config or env.
@@ -349,6 +407,14 @@ async def reply_to_email_m365_async(
     base_res = _base_resource(reply_email_context.sender_email, tool_config, auth_mode)
     headers = {"Authorization": f"Bearer {token}", "Content-Type": "application/json"}
 
+    reply_type = (reply_email_context.reply_type or "reply").lower()
+    if reply_type not in {"reply", "reply_all", "forward"}:
+        reply_type = "reply"
+
+    explicit_to = _normalize_recipients(reply_email_context.to_recipients)
+    explicit_cc = _normalize_recipients(reply_email_context.cc_recipients)
+    explicit_bcc = _normalize_recipients(reply_email_context.bcc_recipients)
+
     # 1) Fetch original message for context (subject, recipients, thread)
     async with httpx.AsyncClient(timeout=30) as client:
         get_url = f"{base_url}{base_res}/messages/{reply_email_context.message_id}"
@@ -357,68 +423,148 @@ async def reply_to_email_m365_async(
         orig = get_resp.json()
 
         orig_subject = orig.get("subject", "")
-        subject = orig_subject if orig_subject.startswith("Re:") else f"Re: {orig_subject}"
         thread_id = orig.get("conversationId", "")
         cc_list = orig.get("ccRecipients", [])
         to_list = orig.get("toRecipients", [])
+        from_addr = (orig.get("from", {}) or {}).get("emailAddress", {}) or {}
+        from_email = from_addr.get("address", "")
+        from_name = from_addr.get("name")
+
         sender_email_lc = (reply_email_context.sender_email or "").lower()
 
         def _is_self(addr: str) -> bool:
             return bool(sender_email_lc) and sender_email_lc in addr.lower()
 
-        def _addresses(recipients: List[Dict[str, Any]]) -> List[str]:
-            return [
-                (recipient.get("emailAddress", {}) or {}).get("address", "")
-                for recipient in recipients
-                if recipient
-            ]
+        def _address_dicts(recipients: List[Dict[str, Any]]) -> List[Dict[str, str]]:
+            result: List[Dict[str, str]] = []
+            for recipient in recipients or []:
+                email_address = recipient.get("emailAddress", {}) if recipient else {}
+                address = email_address.get("address")
+                if not address:
+                    continue
+                result.append({"email": address, "name": email_address.get("name")})
+            return result
+
+        to_recipients: List[Dict[str, str]] = []
+        cc_recipients: List[Dict[str, str]] = []
+        bcc_recipients: List[Dict[str, str]] = []
+
+        if reply_type == "forward":
+            if not explicit_to:
+                raise ValueError("Forward requires explicit to_recipients.")
+            to_recipients = _dedupe_recipients(explicit_to)
+            cc_recipients = _dedupe_recipients(explicit_cc)
+            bcc_recipients = _dedupe_recipients(explicit_bcc)
+
+            if reply_email_context.subject:
+                subject = reply_email_context.subject
+            elif orig_subject and not orig_subject.lower().startswith("fwd:"):
+                subject = f"Fwd: {orig_subject}"
+            else:
+                subject = orig_subject or "Fwd:"
+        else:
+            subject = orig_subject if orig_subject.startswith("Re:") else f"Re: {orig_subject}"
 
-        to_addresses = ", ".join(
-            [addr for addr in _addresses(to_list) if addr and not _is_self(addr)]
-        )
-        cc_addresses = ", ".join(
-            [addr for addr in _addresses(cc_list) if addr and not _is_self(addr)]
-        )
+            if reply_type == "reply_all":
+                base_to = _dedupe_recipients(
+                    [{"email": from_email, "name": from_name}] if from_email and not _is_self(from_email) else [],
+                    exclude_emails=[reply_email_context.sender_email],
+                )
+                if not base_to:
+                    base_to = _dedupe_recipients(
+                        _address_dicts(to_list),
+                        exclude_emails=[reply_email_context.sender_email],
+                    )
+                if not base_to and reply_email_context.fallback_recipient and not _is_self(reply_email_context.fallback_recipient):
+                    base_to = _dedupe_recipients([{"email": reply_email_context.fallback_recipient}])
+                if not base_to:
+                    raise ValueError(
+                        "No valid recipient found in the original message; refusing to reply to sender."
+                    )
+                base_to_emails = [recipient.get("email") for recipient in base_to if recipient.get("email")]
+                base_cc_candidates = _address_dicts(to_list) + _address_dicts(cc_list)
+                base_cc = _dedupe_recipients(
+                    base_cc_candidates,
+                    exclude_emails=[reply_email_context.sender_email] + base_to_emails,
+                )
+            else:
+                base_to = _dedupe_recipients(
+                    [{"email": from_email, "name": from_name}] if from_email and not _is_self(from_email) else [],
+                    exclude_emails=[reply_email_context.sender_email],
+                )
+                if not base_to:
+                    base_to = _dedupe_recipients(
+                        _address_dicts(to_list),
+                        exclude_emails=[reply_email_context.sender_email],
+                    )
+                base_cc = _dedupe_recipients(
+                    _address_dicts(cc_list),
+                    exclude_emails=[reply_email_context.sender_email],
+                )
+                if not base_to and reply_email_context.fallback_recipient and not _is_self(reply_email_context.fallback_recipient):
+                    base_to = _dedupe_recipients([{"email": reply_email_context.fallback_recipient}])
+                    base_cc = []
+                if not base_to:
+                    raise ValueError(
+                        "No valid recipient found in the original message; refusing to reply to sender."
+                    )
+
+            to_recipients = base_to
+            if explicit_to:
+                to_recipients = _dedupe_recipients(explicit_to)
+
+            cc_recipients = base_cc
+            if explicit_cc:
+                cc_recipients = _dedupe_recipients(
+                    base_cc + explicit_cc,
+                    exclude_emails=[recipient.get("email") for recipient in to_recipients if recipient.get("email")],
+                )
+
+            bcc_recipients = _dedupe_recipients(explicit_bcc)
+
+        to_addresses = ", ".join([recipient.get("email") for recipient in to_recipients if recipient.get("email")])
+        cc_addresses = ", ".join([recipient.get("email") for recipient in cc_recipients if recipient.get("email")])
 
-        all_recipients = [addr for addr in _addresses(to_list + cc_list) if addr]
-        if not any(all_recipients):
-            from_addr = orig.get("from", {}).get("emailAddress", {})
-            from_address = from_addr.get("address", "")
-            if from_address:
-                all_recipients.append(from_address)
-
-        non_self_recipients = [addr for addr in all_recipients if not _is_self(addr)]
-        if not non_self_recipients and reply_email_context.fallback_recipient:
-            fr = reply_email_context.fallback_recipient
-            if fr and not _is_self(fr):
-                non_self_recipients.append(fr)
-
-        if not to_addresses and non_self_recipients:
-            to_addresses = ", ".join(non_self_recipients)
-            cc_addresses = ""
-
-        if not non_self_recipients:
-            raise httpx.HTTPStatusError(
-                "No valid recipient found in the original message; refusing to reply to sender.",
-                request=get_resp.request,
-                response=get_resp,
+        if not to_addresses:
+            raise ValueError(
+                "No valid recipient found in the original message; refusing to reply to sender."
             )
 
-        # 2) Create reply-all draft with comment
-        create_reply_url = (
-            f"{base_url}{base_res}/messages/{reply_email_context.message_id}/createReplyAll"
-        )
+        # 2) Create draft with comment
+        if reply_type == "forward":
+            create_reply_url = (
+                f"{base_url}{base_res}/messages/{reply_email_context.message_id}/createForward"
+            )
+        elif reply_type == "reply":
+            create_reply_url = (
+                f"{base_url}{base_res}/messages/{reply_email_context.message_id}/createReply"
+            )
+        else:
+            create_reply_url = (
+                f"{base_url}{base_res}/messages/{reply_email_context.message_id}/createReplyAll"
+            )
         create_payload = {"comment": reply_email_context.reply_body}
         create_resp = await client.post(create_reply_url, headers=headers, json=create_payload)
         create_resp.raise_for_status()
         reply_msg = create_resp.json()
         reply_id = reply_msg.get("id")
 
-        # 3) Optionally add categories (labels) to the reply draft
+        # 3) Optionally update recipients/subject and add categories (labels) to the draft
+        patch_payload: Dict[str, Any] = {}
+        if to_recipients:
+            patch_payload["toRecipients"] = _recipients_to_m365(to_recipients)
+        if cc_recipients:
+            patch_payload["ccRecipients"] = _recipients_to_m365(cc_recipients)
+        if bcc_recipients:
+            patch_payload["bccRecipients"] = _recipients_to_m365(bcc_recipients)
+        if reply_type == "forward":
+            patch_payload["subject"] = subject
         if reply_email_context.add_labels:
-            patch_url = f"{base_url}{base_res}/messages/{reply_id}"
             categories = list(set((reply_msg.get("categories") or []) + reply_email_context.add_labels))
-            await client.patch(patch_url, headers=headers, json={"categories": categories})
+            patch_payload["categories"] = categories
+        if patch_payload:
+            patch_url = f"{base_url}{base_res}/messages/{reply_id}"
+            await client.patch(patch_url, headers=headers, json=patch_payload)
 
         # 4) Send the reply
         send_url = f"{base_url}{base_res}/messages/{reply_id}/send"
@@ -448,6 +594,8 @@ async def reply_to_email_m365_async(
         "email_subject": subject,
         "email_sender": reply_email_context.sender_email,
         "email_recipients": [to_addresses] + ([cc_addresses] if cc_addresses else []),
+        "to_recipients": to_recipients,
+        "cc_recipients": cc_recipients,
         "read_email_status": "READ" if str(reply_email_context.mark_as_read).lower() == "true" else "UNREAD",
         "email_labels": email_labels,
     }

dhisana/utils/smtp_email_tools.py

@@ -39,6 +39,69 @@ from dhisana.utils.email_body_utils import body_variants
 #  Helper / Utility
 # --------------------------------------------------------------------------- #
 
+def _normalize_recipient(recipient: Any) -> Optional[Dict[str, str]]:
+    if recipient is None:
+        return None
+    if isinstance(recipient, dict):
+        email_value = recipient.get("email") or recipient.get("address")
+        name = recipient.get("name")
+    else:
+        email_value = getattr(recipient, "email", None) or getattr(recipient, "address", None)
+        name = getattr(recipient, "name", None)
+        if isinstance(recipient, str):
+            email_value = recipient
+            name = None
+    if not email_value:
+        return None
+    return {"email": email_value, "name": name}
+
+
+def _normalize_recipients(recipients: Optional[List[Any]]) -> List[Dict[str, str]]:
+    normalized: List[Dict[str, str]] = []
+    for recipient in recipients or []:
+        item = _normalize_recipient(recipient)
+        if item:
+            normalized.append(item)
+    return normalized
+
+
+def _parse_header_recipients(header_value: str) -> List[Dict[str, str]]:
+    parsed = email.utils.getaddresses([header_value]) if header_value else []
+    return [{"email": address, "name": name} for name, address in parsed if address]
+
+
+def _dedupe_recipients(
+    recipients: List[Dict[str, str]],
+    exclude_emails: Optional[List[str]] = None,
+) -> List[Dict[str, str]]:
+    excluded = {email_value.lower() for email_value in (exclude_emails or []) if email_value}
+    seen: set[str] = set()
+    result: List[Dict[str, str]] = []
+    for recipient in recipients:
+        email_value = (recipient.get("email") or "").strip()
+        if not email_value:
+            continue
+        email_lc = email_value.lower()
+        if email_lc in seen or email_lc in excluded:
+            continue
+        seen.add(email_lc)
+        result.append({"email": email_value, "name": recipient.get("name")})
+    return result
+
+
+def _recipients_to_header(recipients: List[Dict[str, str]]) -> str:
+    parts: List[str] = []
+    for recipient in recipients:
+        name = recipient.get("name")
+        email_value = recipient.get("email")
+        if not email_value:
+            continue
+        if name:
+            parts.append(f"{name} <{email_value}>")
+        else:
+            parts.append(email_value)
+    return ", ".join(parts)
+
 
 def _decode_header_value(value: Any) -> str:
     """Return a unicode string for an e-mail header field."""
@@ -475,7 +538,7 @@ async def reply_to_email_via_smtp_async(
                     if status == "OK" and nums and nums[0]:
                         num = nums[0].split()[0]
                         _, data = conn.fetch(num, "(RFC822)")
-                        if ctx.mark_as_read.lower() == "true":
+                        if str(ctx.mark_as_read).lower() == "true":
                             conn.store(num, "+FLAGS", "\\Seen")
                         msg_data = data[0][1] if data and data[0] else None
                         break
@@ -496,28 +559,129 @@ async def reply_to_email_via_smtp_async(
 
     raw_original = await asyncio.to_thread(_fetch_original)
     if raw_original is None:
-        raise RuntimeError(f"Could not locate original message with ID {ctx.message_id!r}")
+        raise ValueError(f"Could not locate original message with ID {ctx.message_id!r}")
 
     original = email.message_from_bytes(raw_original)
     hdr = lambda h: original.get(h, "")
 
-    # 2. Derive reply headers
-    to_addrs = hdr("Reply-To") or hdr("From")
-    cc_addrs = hdr("Cc")
-    # If the derived recipient points back to the sender or is missing, fall back to provided recipient.
+    reply_type = (ctx.reply_type or "reply").lower()
+    if reply_type not in {"reply", "reply_all", "forward"}:
+        reply_type = "reply"
+
     sender_email_lc = (ctx.sender_email or "").lower()
+
     def _is_self(addr: str) -> bool:
         return bool(sender_email_lc) and sender_email_lc in addr.lower()
-    if (not to_addrs or _is_self(to_addrs)) and getattr(ctx, "fallback_recipient", None):
-        fr = ctx.fallback_recipient
-        if fr and not _is_self(fr):
-            to_addrs = fr
-            cc_addrs = ""
-    if not to_addrs or _is_self(to_addrs):
-        raise RuntimeError("No valid recipient found in original message; refusing to reply to sender.")
-    subject = hdr("Subject")
-    if not subject.lower().startswith("re:"):
-        subject = f"Re: {subject}"
+
+    explicit_to = _normalize_recipients(getattr(ctx, "to_recipients", None))
+    explicit_cc = _normalize_recipients(getattr(ctx, "cc_recipients", None))
+    explicit_bcc = _normalize_recipients(getattr(ctx, "bcc_recipients", None))
+
+    to_recipients: List[Dict[str, str]] = []
+    cc_recipients: List[Dict[str, str]] = []
+    bcc_recipients: List[Dict[str, str]] = []
+
+    from_header = hdr("From")
+    reply_to_header = hdr("Reply-To")
+    to_header = hdr("To")
+    cc_header = hdr("Cc")
+
+    if reply_type == "forward":
+        if not explicit_to:
+            raise ValueError("Forward requires explicit to_recipients.")
+        to_recipients = _dedupe_recipients(explicit_to)
+        cc_recipients = _dedupe_recipients(explicit_cc)
+        bcc_recipients = _dedupe_recipients(explicit_bcc)
+        # Respect custom subject if explicitly provided; otherwise derive from original
+        if ctx.subject:
+            subject = ctx.subject
+        else:
+            subject = hdr("Subject")
+            if subject and not subject.lower().startswith("fwd:"):
+                subject = f"Fwd: {subject}"
+            elif not subject:
+                subject = "Fwd:"
+    else:
+        if reply_type == "reply_all":
+            base_to = _dedupe_recipients(
+                _parse_header_recipients(from_header),
+                exclude_emails=[ctx.sender_email],
+            )
+            if not base_to:
+                base_to = _dedupe_recipients(
+                    _parse_header_recipients(reply_to_header),
+                    exclude_emails=[ctx.sender_email],
+                )
+            if not base_to:
+                base_to = _dedupe_recipients(
+                    _parse_header_recipients(to_header),
+                    exclude_emails=[ctx.sender_email],
+                )
+            if not base_to and getattr(ctx, "fallback_recipient", None):
+                fr = ctx.fallback_recipient
+                if fr and not _is_self(fr):
+                    base_to = _dedupe_recipients([{"email": fr}])
+            if not base_to:
+                raise ValueError("No valid recipient found in original message; refusing to reply to sender.")
+            base_to_emails = [recipient.get("email") for recipient in base_to if recipient.get("email")]
+            base_cc_candidates = _parse_header_recipients(to_header) + _parse_header_recipients(cc_header)
+            base_cc = _dedupe_recipients(
+                base_cc_candidates,
+                exclude_emails=[ctx.sender_email] + base_to_emails,
+            )
+        else:
+            cc_header_value = cc_header or ""
+            if reply_to_header and not _is_self(reply_to_header):
+                to_header_value = reply_to_header
+            elif from_header and not _is_self(from_header):
+                to_header_value = from_header
+            elif to_header and not _is_self(to_header):
+                to_header_value = to_header
+            else:
+                to_header_value = ", ".join([v for v in (to_header, cc_header, from_header) if v])
+                cc_header_value = ""
+
+            base_to = _dedupe_recipients(
+                _parse_header_recipients(to_header_value),
+                exclude_emails=[ctx.sender_email],
+            )
+            base_cc = _dedupe_recipients(
+                _parse_header_recipients(cc_header_value),
+                exclude_emails=[ctx.sender_email],
+            )
+
+            if not base_to and getattr(ctx, "fallback_recipient", None):
+                fr = ctx.fallback_recipient
+                if fr and not _is_self(fr):
+                    base_to = _dedupe_recipients([{"email": fr}])
+                    base_cc = []
+
+            if not base_to:
+                raise ValueError("No valid recipient found in original message; refusing to reply to sender.")
+
+        to_recipients = base_to
+        if explicit_to:
+            to_recipients = _dedupe_recipients(explicit_to)
+
+        cc_recipients = base_cc
+        if explicit_cc:
+            cc_recipients = _dedupe_recipients(
+                base_cc + explicit_cc,
+                exclude_emails=[recipient.get("email") for recipient in to_recipients if recipient.get("email")],
+            )
+
+        bcc_recipients = _dedupe_recipients(explicit_bcc)
+
+        subject = hdr("Subject")
+        if not subject.lower().startswith("re:"):
+            subject = f"Re: {subject}"
+
+    to_addrs = _recipients_to_header(to_recipients)
+    cc_addrs = _recipients_to_header(cc_recipients)
+    bcc_addrs = _recipients_to_header(bcc_recipients)
+    if not to_addrs:
+        raise ValueError("No valid recipient found in original message; refusing to reply to sender.")
+
     orig_msg_id = hdr("Message-ID")  # parent's ID
 
     # Build the References header by appending the parent's ID
@@ -529,13 +693,17 @@ async def reply_to_email_via_smtp_async(
 
     # 3. Build the MIMEText reply
     msg = MIMEText(ctx.reply_body, _charset="utf-8")
-    msg["From"] = f"{ctx.sender_name} <{ctx.sender_email}>"
+    sender_display = ctx.sender_name or ctx.sender_email
+    msg["From"] = f"{sender_display} <{ctx.sender_email}>"
     msg["To"] = to_addrs
     if cc_addrs:
         msg["Cc"] = cc_addrs
+    if bcc_addrs:
+        msg["Bcc"] = bcc_addrs
     msg["Subject"] = subject
-    msg["In-Reply-To"] = orig_msg_id
-    msg["References"] = references
+    if reply_type != "forward":
+        msg["In-Reply-To"] = orig_msg_id
+        msg["References"] = references
 
     # Generate a new Message-ID for this reply
     domain_part = ctx.sender_email.split("@", 1)[-1] or "local"
@@ -571,6 +739,8 @@ async def reply_to_email_via_smtp_async(
         "email_subject": subject,
         "email_sender": ctx.sender_email,
         "email_recipients": recipients,
-        "read_email_status": "READ" if ctx.mark_as_read.lower() == "true" else "UNREAD",
+        "to_recipients": to_recipients,
+        "cc_recipients": cc_recipients,
+        "read_email_status": "READ" if str(ctx.mark_as_read).lower() == "true" else "UNREAD",
         "email_labels": [],  # Not applicable for IMAP
     }