dhisana 0.0.1.dev303__tar.gz → 0.0.1.dev305__tar.gz

{dhisana-0.0.1.dev303 → dhisana-0.0.1.dev305}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dhisana
-Version: 0.0.1.dev303
+Version: 0.0.1.dev305
 Summary: A Python SDK for Dhisana AI Platform
 Home-page: https://github.com/dhisana-ai/dhisana-python-sdk
 Author: Admin

{dhisana-0.0.1.dev303 → dhisana-0.0.1.dev305}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name='dhisana',  
-    version='0.0.1-dev303',
+    version='0.0.1-dev305',
     description='A Python SDK for Dhisana AI Platform',
     author='Admin',
     author_email='contact@dhisana.ai',

{dhisana-0.0.1.dev303 → dhisana-0.0.1.dev305}/src/dhisana/schemas/common.py

@@ -380,19 +380,24 @@ class SendEmailContext(BaseModel):
     body_format: BodyFormat = BodyFormat.AUTO
     headers: Optional[Dict[str, str]] = None
     email_open_token: Optional[str] = None
-    
+    to_recipients: Optional[List["EmailRecipient"]] = None
+    cc_recipients: Optional[List["EmailRecipient"]] = None
+    bcc_recipients: Optional[List["EmailRecipient"]] = None
+
 class QueryEmailContext(BaseModel):
     start_time: str
     end_time: str
     sender_email: str
     unread_only: bool = True
     labels: Optional[List[str]] = None
-    
+
 
 class EmailRecipient(BaseModel):
     email: str
     name: Optional[str] = None
 
+SendEmailContext.model_rebuild()
+
 
 class ReplyEmailContext(BaseModel):
     """Context for replying to or forwarding an email."""

{dhisana-0.0.1.dev303 → dhisana-0.0.1.dev305}/src/dhisana/utils/enrich_lead_information.py

@@ -658,9 +658,57 @@ async def enrich_user_info(
                 tool_config=tool_config,
             )
             if found_linkedin_url:
-                user_linkedin_url = found_linkedin_url
-                input_properties["user_linkedin_url"] = user_linkedin_url
-        if not user_linkedin_url and email:
+                should_use_url = True
+                if use_strict_check and org_domain:
+                    try:
+                        temp_props = {"user_linkedin_url": found_linkedin_url}
+                        enriched = await enrich_with_provider(temp_props, tool_config)
+                        enriched_domain = (enriched.get("primary_domain_of_organization") or "").strip().lower()
+                        # If no domain returned but we have an organization LinkedIn URL,
+                        # look up the org to get its domain
+                        if not enriched_domain:
+                            enriched_org_linkedin = (enriched.get("organization_linkedin_url") or "").strip()
+                            if enriched_org_linkedin:
+                                try:
+                                    org_info = await search_organization_by_linkedin_or_domain(
+                                        linkedin_url=enriched_org_linkedin,
+                                        tool_config=tool_config,
+                                    )
+                                    enriched_domain = (org_info.get("domain") or "").strip().lower()
+                                except Exception:
+                                    logger.debug("Could not look up org domain from LinkedIn URL: %s", enriched_org_linkedin)
+                        input_org_domain = org_domain.strip().lower()
+                        if input_org_domain and enriched_domain and enriched_domain != input_org_domain:
+                            logger.info(
+                                "Skipping Google-found LinkedIn URL %s: enriched domain '%s' does not match input domain '%s'",
+                                found_linkedin_url, enriched_domain, input_org_domain,
+                            )
+                            should_use_url = False
+                        elif input_org_domain and not enriched_domain:
+                            logger.info(
+                                "Skipping Google-found LinkedIn URL %s: could not determine enriched org domain to verify against input domain '%s'",
+                                found_linkedin_url, input_org_domain,
+                            )
+                            should_use_url = False
+                    except Exception:
+                        logger.debug("Could not verify LinkedIn URL domain via enrichment; proceeding with found URL.")
+                if should_use_url:
+                    user_linkedin_url = found_linkedin_url
+                    input_properties["user_linkedin_url"] = user_linkedin_url
+        # Skip email-based LinkedIn search if strict check is on and the email
+        # domain doesn't match the expected org domain (would waste API calls
+        # searching for a person at a different company).
+        skip_email_search = False
+        if use_strict_check and org_domain and email:
+            email_domain = email.split("@")[-1].strip().lower()
+            if email_domain and org_domain.strip().lower() != email_domain:
+                skip_email_search = True
+                logger.info(
+                    "Skipping email-based LinkedIn search: email domain '%s' does not match org domain '%s'",
+                    email_domain, org_domain,
+                )
+
+        if not user_linkedin_url and email and not skip_email_search:
             # If we have an email but no LinkedIn URL yet, try searching by email via Google
             email_lookup_result = await find_user_linkedin_url_by_email_google(
                 email=email,

{dhisana-0.0.1.dev303 → dhisana-0.0.1.dev305}/src/dhisana/utils/google_oauth_tools.py

@@ -210,6 +210,27 @@ async def send_email_using_google_oauth_async(
     message["from"] = f"{send_email_context.sender_name} <{send_email_context.sender_email}>"
     message["subject"] = send_email_context.subject
 
+    # Add extra To recipients
+    extra_to = getattr(send_email_context, "to_recipients", None) or []
+    if extra_to:
+        additional = [r.email if hasattr(r, "email") else (r.get("email") if isinstance(r, dict) else str(r)) for r in extra_to]
+        additional = [a for a in additional if a and a.lower() != send_email_context.recipient.strip().lower()]
+        if additional:
+            del message["to"]
+            message["to"] = ", ".join([send_email_context.recipient] + additional)
+
+    # Add CC recipients
+    cc_list = getattr(send_email_context, "cc_recipients", None) or []
+    if cc_list:
+        cc_addrs = [r.email if hasattr(r, "email") else (r.get("email") if isinstance(r, dict) else str(r)) for r in cc_list]
+        message["cc"] = ", ".join(a for a in cc_addrs if a)
+
+    # Add BCC recipients (header set for envelope; Gmail strips it before delivery)
+    bcc_list = getattr(send_email_context, "bcc_recipients", None) or []
+    if bcc_list:
+        bcc_addrs = [r.email if hasattr(r, "email") else (r.get("email") if isinstance(r, dict) else str(r)) for r in bcc_list]
+        message["bcc"] = ", ".join(a for a in bcc_addrs if a)
+
     extra_headers = getattr(send_email_context, "headers", None) or {}
     for header, value in extra_headers.items():
         if not header or value is None:

{dhisana-0.0.1.dev303 → dhisana-0.0.1.dev305}/src/dhisana/utils/microsoft365_tools.py

@@ -227,6 +227,35 @@ async def send_email_using_microsoft_graph_async(
         ],
     }
 
+    # Merge additional To recipients from the new field
+    extra_to = getattr(send_email_context, "to_recipients", None) or []
+    for r in extra_to:
+        addr = r.email if hasattr(r, "email") else (r.get("email") if isinstance(r, dict) else str(r))
+        if addr and addr.lower() != send_email_context.recipient.strip().lower():
+            message_payload["toRecipients"].append({"emailAddress": {"address": addr}})
+
+    # CC recipients
+    cc_list = getattr(send_email_context, "cc_recipients", None) or []
+    if cc_list:
+        cc_entries = []
+        for r in cc_list:
+            addr = r.email if hasattr(r, "email") else (r.get("email") if isinstance(r, dict) else str(r))
+            if addr:
+                cc_entries.append({"emailAddress": {"address": addr}})
+        if cc_entries:
+            message_payload["ccRecipients"] = cc_entries
+
+    # BCC recipients
+    bcc_list = getattr(send_email_context, "bcc_recipients", None) or []
+    if bcc_list:
+        bcc_entries = []
+        for r in bcc_list:
+            addr = r.email if hasattr(r, "email") else (r.get("email") if isinstance(r, dict) else str(r))
+            if addr:
+                bcc_entries.append({"emailAddress": {"address": addr}})
+        if bcc_entries:
+            message_payload["bccRecipients"] = bcc_entries
+
     extra_headers = getattr(send_email_context, "headers", None) or {}
     if extra_headers:
         message_payload["internetMessageHeaders"] = [

{dhisana-0.0.1.dev303 → dhisana-0.0.1.dev305}/src/dhisana/utils/serpapi_search_tools.py

@@ -401,12 +401,6 @@ async def find_user_linkedin_url_by_email_google(
         if query and query not in queries:
             queries.append(query)
 
-    def add_query_parts(*parts: str) -> None:
-        tokens = [part.strip() for part in parts if part and part.strip()]
-        if not tokens:
-            return
-        add_query(" ".join(tokens))
-
     enriched_terms = []
     if user_name:
         enriched_terms.append(f'"{user_name}"')
@@ -418,47 +412,23 @@ async def find_user_linkedin_url_by_email_google(
         enriched_terms.append(f'"{user_location}"')
     base_hint = " ".join(enriched_terms)
 
-    # Prioritise the direct email search variants before broader fallbacks.
-    add_query_parts(normalized_email, "linkedin.com/in", base_hint)
-    add_query_parts(normalized_email, "linkedin.com", base_hint)
-    add_query_parts(normalized_email, "linkedin", base_hint)
-    add_query_parts(normalized_email, base_hint)
-    add_query(f'"{normalized_email}" "linkedin.com/in" {base_hint}')
-    add_query(f'"{normalized_email}" "linkedin.com" {base_hint}')
-    add_query(f'"{normalized_email}" linkedin {base_hint}')
+    # 1) Best query: site-scoped with exact email
+    add_query(f'site:linkedin.com/in "{normalized_email}" {base_hint}')
 
-    if email_local_part and email_local_part != normalized_email:
-        add_query_parts(email_local_part, "linkedin.com/in", base_hint)
-        add_query_parts(email_local_part, "linkedin.com", base_hint)
-        add_query_parts(email_local_part, "linkedin", base_hint)
-        add_query(f'"{email_local_part}" "linkedin.com/in" {base_hint}')
-        add_query(f'"{email_local_part}" "linkedin.com" {base_hint}')
+    # 2) Exact email with linkedin scope (Google may surface LinkedIn even without site:)
+    add_query(f'"{normalized_email}" linkedin.com/in {base_hint}')
 
-    if email_local_humanized and email_local_humanized not in {email_local_part, normalized_email}:
-        add_query_parts(email_local_humanized, "linkedin", base_hint)
-        add_query(f'"{email_local_humanized}" linkedin {base_hint}')
+    # 3) Unquoted email with linkedin scope (catches partial matches)
+    add_query(f'{normalized_email} linkedin.com/in {base_hint}')
 
-    if normalized_email:
-        add_query(f'site:linkedin.com/in "{normalized_email}" {base_hint}')
-
-    if email_local_part:
+    # 4) Local part fallback with site scope (e.g. "santosh" on linkedin)
+    if email_local_part and email_local_part != normalized_email:
         add_query(f'site:linkedin.com/in "{email_local_part}" {base_hint}')
 
-    if email_local_humanized and email_local_humanized != email_local_part:
+    # 5) Humanized local part fallback (e.g. "john smith" from "john.smith")
+    if email_local_humanized and email_local_humanized not in {email_local_part, normalized_email}:
         add_query(f'site:linkedin.com/in "{email_local_humanized}" {base_hint}')
 
-    if base_hint:
-        lookup_hint = user_name or email_local_humanized or email_local_part or normalized_email
-        add_query(
-            f'site:linkedin.com/in "{normalized_email}" {base_hint} '
-            f'intitle:"{lookup_hint}" -intitle:"profiles"'
-        )
-        if email_local_humanized:
-            add_query(
-                f'site:linkedin.com/in "{email_local_humanized}" {base_hint} '
-                f'intitle:"{lookup_hint}" -intitle:"profiles"'
-            )
-
     candidate_records: List[Dict[str, str]] = []
     seen_links: Set[str] = set()
     best_llm_choice: Optional[LinkedinCandidateChoice] = None

{dhisana-0.0.1.dev303 → dhisana-0.0.1.dev305}/src/dhisana/utils/smtp_email_tools.py

@@ -226,6 +226,35 @@ async def send_email_via_smtp_async(
     msg["To"] = ctx.recipient
     msg["Subject"] = ctx.subject
 
+    # Build envelope recipient list starting with primary
+    envelope_recipients = [ctx.recipient]
+
+    # Add extra To recipients
+    extra_to = getattr(ctx, "to_recipients", None) or []
+    if extra_to:
+        additional = [r.email if hasattr(r, "email") else (r.get("email") if isinstance(r, dict) else str(r)) for r in extra_to]
+        additional = [a for a in additional if a and a.lower() != ctx.recipient.strip().lower()]
+        if additional:
+            del msg["To"]
+            msg["To"] = ", ".join([ctx.recipient] + additional)
+            envelope_recipients.extend(additional)
+
+    # Add CC recipients
+    cc_list = getattr(ctx, "cc_recipients", None) or []
+    if cc_list:
+        cc_addrs = [r.email if hasattr(r, "email") else (r.get("email") if isinstance(r, dict) else str(r)) for r in cc_list]
+        cc_addrs = [a for a in cc_addrs if a]
+        if cc_addrs:
+            msg["Cc"] = ", ".join(cc_addrs)
+            envelope_recipients.extend(cc_addrs)
+
+    # Add BCC recipients (envelope only, no header)
+    bcc_list = getattr(ctx, "bcc_recipients", None) or []
+    if bcc_list:
+        bcc_addrs = [r.email if hasattr(r, "email") else (r.get("email") if isinstance(r, dict) else str(r)) for r in bcc_list]
+        bcc_addrs = [a for a in bcc_addrs if a]
+        envelope_recipients.extend(bcc_addrs)
+
     # Generate a real RFC 5322 Message-ID
     domain_part = ctx.sender_email.split("@", 1)[-1] or "local"
     generated_id = f"<{uuid.uuid4()}@{domain_part}>"
@@ -236,6 +265,12 @@ async def send_email_via_smtp_async(
         if not header or value is None:
             continue
         msg[header] = str(value)
+        # Preserve envelope delivery for Cc/Bcc/To addresses set via extra headers,
+        # since explicit recipients= overrides aiosmtplib's header extraction.
+        if header.lower() in ("to", "cc", "bcc"):
+            for _, addr in email.utils.getaddresses([str(value)]):
+                if addr and addr.lower() not in {a.lower() for a in envelope_recipients}:
+                    envelope_recipients.append(addr)
 
     smtp_kwargs = dict(
         hostname=smtp_server,
@@ -253,7 +288,7 @@ async def send_email_via_smtp_async(
     try:
         # aiosmtplib.send returns a (code, response) tuple, but no server message ID.
         # We rely on the real Message-ID we have just set.
-        await aiosmtplib.send(msg, **smtp_kwargs)
+        await aiosmtplib.send(msg, recipients=envelope_recipients, **smtp_kwargs)
         logging.info("SMTP send OK – msg id %s", generated_id)
         return generated_id
     except Exception:

{dhisana-0.0.1.dev303 → dhisana-0.0.1.dev305}/src/dhisana.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dhisana
-Version: 0.0.1.dev303
+Version: 0.0.1.dev305
 Summary: A Python SDK for Dhisana AI Platform
 Home-page: https://github.com/dhisana-ai/dhisana-python-sdk
 Author: Admin

{dhisana-0.0.1.dev303 → dhisana-0.0.1.dev305}/src/dhisana.egg-info/SOURCES.txt

@@ -119,4 +119,5 @@ tests/test_normalize_graph_datetime.py
 tests/test_proxycurl_get_company_search_id.py
 tests/test_proxycurl_job_count.py
 tests/test_reply_thread_fallback.py
+tests/test_send_email_recipients.py
 tests/test_structured_output_with_mcp.py

dhisana-0.0.1.dev305/tests/test_send_email_recipients.py

@@ -0,0 +1,403 @@
+"""Tests for SendEmailContext multi-recipient support (to/cc/bcc).
+
+Validates that each provider function correctly handles the new
+to_recipients, cc_recipients, and bcc_recipients fields on SendEmailContext.
+"""
+
+import base64
+import email
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+
+from dhisana.schemas.common import (
+    BodyFormat,
+    EmailRecipient,
+    SendEmailContext,
+)
+
+# Provider imports may fail when the full test suite poisons sys.modules
+# (the stale build/ directory creates a competing dhisana namespace).
+# Use importorskip so these tests are skipped rather than erroring.
+google_oauth_tools = pytest.importorskip("dhisana.utils.google_oauth_tools")
+send_email_using_google_oauth_async = google_oauth_tools.send_email_using_google_oauth_async
+
+microsoft365_tools = pytest.importorskip("dhisana.utils.microsoft365_tools")
+send_email_using_microsoft_graph_async = microsoft365_tools.send_email_using_microsoft_graph_async
+
+smtp_email_tools = pytest.importorskip("dhisana.utils.smtp_email_tools")
+send_email_via_smtp_async = smtp_email_tools.send_email_via_smtp_async
+
+
+# ---------------------------------------------------------------------------
+# Fixtures
+# ---------------------------------------------------------------------------
+
+@pytest.fixture
+def basic_context():
+    """SendEmailContext with a single primary recipient."""
+    return SendEmailContext(
+        recipient="primary@example.com",
+        subject="Test Subject",
+        body="Hello world",
+        sender_name="Sender",
+        sender_email="sender@example.com",
+        labels=None,
+        body_format=BodyFormat.TEXT,
+    )
+
+
+@pytest.fixture
+def multi_recipient_context():
+    """SendEmailContext with to/cc/bcc recipients."""
+    return SendEmailContext(
+        recipient="primary@example.com",
+        subject="Multi Recipient Test",
+        body="Hello everyone",
+        sender_name="Sender",
+        sender_email="sender@example.com",
+        labels=None,
+        body_format=BodyFormat.TEXT,
+        to_recipients=[
+            EmailRecipient(email="extra-to@example.com", name="Extra To"),
+        ],
+        cc_recipients=[
+            EmailRecipient(email="cc1@example.com", name="CC One"),
+            EmailRecipient(email="cc2@example.com", name="CC Two"),
+        ],
+        bcc_recipients=[
+            EmailRecipient(email="bcc@example.com", name="BCC One"),
+        ],
+    )
+
+
+# ---------------------------------------------------------------------------
+# Schema tests
+# ---------------------------------------------------------------------------
+
+class TestSendEmailContextSchema:
+    """Model-level tests for the new fields."""
+
+    def test_new_fields_default_to_none(self, basic_context):
+        assert basic_context.to_recipients is None
+        assert basic_context.cc_recipients is None
+        assert basic_context.bcc_recipients is None
+
+    def test_accepts_email_recipient_objects(self, multi_recipient_context):
+        assert len(multi_recipient_context.to_recipients) == 1
+        assert multi_recipient_context.to_recipients[0].email == "extra-to@example.com"
+        assert len(multi_recipient_context.cc_recipients) == 2
+        assert len(multi_recipient_context.bcc_recipients) == 1
+
+    def test_backward_compatible_serialization(self, basic_context):
+        """Existing code that doesn't set the new fields should still serialize fine."""
+        data = basic_context.model_dump()
+        assert data["recipient"] == "primary@example.com"
+        assert data["to_recipients"] is None
+        assert data["cc_recipients"] is None
+        assert data["bcc_recipients"] is None
+
+
+# ---------------------------------------------------------------------------
+# Google OAuth (Gmail API) tests
+# ---------------------------------------------------------------------------
+
+class TestGoogleOAuthRecipients:
+    """Verify Gmail MIME message includes to/cc/bcc headers."""
+
+    @pytest.mark.asyncio
+    async def test_gmail_message_includes_cc_bcc(self, multi_recipient_context):
+        captured_raw = {}
+
+        with patch(
+            "dhisana.utils.google_oauth_tools.get_google_access_token",
+            return_value="fake-token",
+        ), patch("httpx.AsyncClient") as mock_client_cls:
+            mock_resp = MagicMock()
+            mock_resp.status_code = 200
+            mock_resp.raise_for_status = MagicMock()
+            mock_resp.json.return_value = {"id": "gmail-msg-123"}
+
+            mock_client = AsyncMock()
+
+            async def fake_post(url, **kwargs):
+                captured_raw.update(kwargs.get("json", {}))
+                return mock_resp
+
+            mock_client.post = fake_post
+            mock_client.__aenter__ = AsyncMock(return_value=mock_client)
+            mock_client.__aexit__ = AsyncMock(return_value=False)
+            mock_client_cls.return_value = mock_client
+
+            result = await send_email_using_google_oauth_async(
+                multi_recipient_context,
+                tool_config=[{"name": "google", "configuration": []}],
+            )
+
+        assert result == "gmail-msg-123"
+
+        # Decode the raw MIME message
+        raw_b64 = captured_raw.get("raw", "")
+        mime_bytes = base64.urlsafe_b64decode(raw_b64)
+        parsed = email.message_from_bytes(mime_bytes)
+
+        # To header should include primary + extra-to
+        to_header = parsed["to"]
+        assert "primary@example.com" in to_header
+        assert "extra-to@example.com" in to_header
+
+        # CC header
+        cc_header = parsed.get("cc", "")
+        assert "cc1@example.com" in cc_header
+        assert "cc2@example.com" in cc_header
+
+        # BCC header (Gmail strips it before delivery, but it should be in the raw payload)
+        bcc_header = parsed.get("bcc", "")
+        assert "bcc@example.com" in bcc_header
+
+    @pytest.mark.asyncio
+    async def test_gmail_no_extra_headers_when_none(self, basic_context):
+        """When no extra recipients, only To header should be present."""
+        captured_raw = {}
+
+        with patch(
+            "dhisana.utils.google_oauth_tools.get_google_access_token",
+            return_value="fake-token",
+        ), patch("httpx.AsyncClient") as mock_client_cls:
+            mock_resp = MagicMock()
+            mock_resp.status_code = 200
+            mock_resp.raise_for_status = MagicMock()
+            mock_resp.json.return_value = {"id": "gmail-msg-456"}
+
+            mock_client = AsyncMock()
+
+            async def fake_post(url, **kwargs):
+                captured_raw.update(kwargs.get("json", {}))
+                return mock_resp
+
+            mock_client.post = fake_post
+            mock_client.__aenter__ = AsyncMock(return_value=mock_client)
+            mock_client.__aexit__ = AsyncMock(return_value=False)
+            mock_client_cls.return_value = mock_client
+
+            await send_email_using_google_oauth_async(
+                basic_context,
+                tool_config=[{"name": "google", "configuration": []}],
+            )
+
+        raw_b64 = captured_raw.get("raw", "")
+        mime_bytes = base64.urlsafe_b64decode(raw_b64)
+        parsed = email.message_from_bytes(mime_bytes)
+
+        assert parsed["to"] == "primary@example.com"
+        assert parsed.get("cc") is None
+        assert parsed.get("bcc") is None
+
+
+# ---------------------------------------------------------------------------
+# Microsoft 365 tests
+# ---------------------------------------------------------------------------
+
+class TestMicrosoft365Recipients:
+    """Verify Graph API payload includes cc/bcc/to recipients."""
+
+    @pytest.mark.asyncio
+    async def test_graph_payload_includes_cc_bcc(self, multi_recipient_context):
+        captured_payload = {}
+
+        with patch(
+            "dhisana.utils.microsoft365_tools.get_microsoft365_access_token",
+            return_value="fake-token",
+        ), patch(
+            "dhisana.utils.microsoft365_tools._base_resource",
+            return_value="/users/sender@example.com",
+        ), patch("httpx.AsyncClient") as mock_client_cls:
+            mock_resp_send = MagicMock()
+            mock_resp_send.status_code = 202
+            mock_resp_send.raise_for_status = MagicMock()
+
+            mock_resp_list = MagicMock()
+            mock_resp_list.status_code = 200
+            mock_resp_list.raise_for_status = MagicMock()
+            mock_resp_list.json.return_value = {"value": []}
+
+            mock_client = AsyncMock()
+
+            async def fake_post(url, **kwargs):
+                captured_payload.update(kwargs.get("json", {}))
+                return mock_resp_send
+
+            mock_client.post = fake_post
+            mock_client.get = AsyncMock(return_value=mock_resp_list)
+            mock_client.__aenter__ = AsyncMock(return_value=mock_client)
+            mock_client.__aexit__ = AsyncMock(return_value=False)
+            mock_client_cls.return_value = mock_client
+
+            await send_email_using_microsoft_graph_async(
+                multi_recipient_context,
+                tool_config=[{"name": "microsoft365", "configuration": []}],
+            )
+
+        msg = captured_payload.get("message", {})
+
+        # toRecipients should include primary + extra-to
+        to_addrs = [r["emailAddress"]["address"] for r in msg.get("toRecipients", [])]
+        assert "primary@example.com" in to_addrs
+        assert "extra-to@example.com" in to_addrs
+
+        # ccRecipients
+        cc_addrs = [r["emailAddress"]["address"] for r in msg.get("ccRecipients", [])]
+        assert "cc1@example.com" in cc_addrs
+        assert "cc2@example.com" in cc_addrs
+
+        # bccRecipients
+        bcc_addrs = [r["emailAddress"]["address"] for r in msg.get("bccRecipients", [])]
+        assert "bcc@example.com" in bcc_addrs
+
+    @pytest.mark.asyncio
+    async def test_graph_no_extra_fields_when_none(self, basic_context):
+        """When no extra recipients, payload should only have toRecipients."""
+        captured_payload = {}
+
+        with patch(
+            "dhisana.utils.microsoft365_tools.get_microsoft365_access_token",
+            return_value="fake-token",
+        ), patch(
+            "dhisana.utils.microsoft365_tools._base_resource",
+            return_value="/users/sender@example.com",
+        ), patch("httpx.AsyncClient") as mock_client_cls:
+            mock_resp = MagicMock()
+            mock_resp.status_code = 202
+            mock_resp.raise_for_status = MagicMock()
+
+            mock_resp_list = MagicMock()
+            mock_resp_list.status_code = 200
+            mock_resp_list.raise_for_status = MagicMock()
+            mock_resp_list.json.return_value = {"value": []}
+
+            mock_client = AsyncMock()
+
+            async def fake_post(url, **kwargs):
+                captured_payload.update(kwargs.get("json", {}))
+                return mock_resp
+
+            mock_client.post = fake_post
+            mock_client.get = AsyncMock(return_value=mock_resp_list)
+            mock_client.__aenter__ = AsyncMock(return_value=mock_client)
+            mock_client.__aexit__ = AsyncMock(return_value=False)
+            mock_client_cls.return_value = mock_client
+
+            await send_email_using_microsoft_graph_async(
+                basic_context,
+                tool_config=[{"name": "microsoft365", "configuration": []}],
+            )
+
+        msg = captured_payload.get("message", {})
+        assert len(msg["toRecipients"]) == 1
+        assert "ccRecipients" not in msg
+        assert "bccRecipients" not in msg
+
+
+# ---------------------------------------------------------------------------
+# SMTP tests
+# ---------------------------------------------------------------------------
+
+class TestSMTPRecipients:
+    """Verify SMTP adds Cc header and includes all envelope recipients."""
+
+    @pytest.mark.asyncio
+    async def test_smtp_envelope_includes_all_recipients(self, multi_recipient_context):
+        captured_kwargs = {}
+        captured_recipients = []
+
+        async def fake_send(msg, *, recipients=None, **kwargs):
+            captured_kwargs.update(kwargs)
+            if recipients:
+                captured_recipients.extend(recipients)
+            # Parse the MIME message to verify headers
+            parsed = email.message_from_string(msg.as_string())
+            captured_kwargs["_parsed_to"] = parsed["To"]
+            captured_kwargs["_parsed_cc"] = parsed.get("Cc", "")
+            # BCC should NOT be in headers
+            captured_kwargs["_parsed_bcc"] = parsed.get("Bcc")
+
+        with patch("dhisana.utils.smtp_email_tools.aiosmtplib.send", side_effect=fake_send):
+            result = await send_email_via_smtp_async(
+                multi_recipient_context,
+                smtp_server="smtp.example.com",
+                smtp_port=587,
+                username="user",
+                password="pass",
+            )
+
+        assert result  # Should return a message ID
+
+        # Envelope recipients include all addresses
+        assert "primary@example.com" in captured_recipients
+        assert "extra-to@example.com" in captured_recipients
+        assert "cc1@example.com" in captured_recipients
+        assert "cc2@example.com" in captured_recipients
+        assert "bcc@example.com" in captured_recipients
+
+        # Cc header present
+        assert "cc1@example.com" in captured_kwargs["_parsed_cc"]
+        assert "cc2@example.com" in captured_kwargs["_parsed_cc"]
+
+        # BCC should NOT appear in headers
+        assert captured_kwargs["_parsed_bcc"] is None
+
+    @pytest.mark.asyncio
+    async def test_smtp_basic_send_unchanged(self, basic_context):
+        """Without extra recipients, SMTP sends to single recipient as before."""
+        captured_recipients = []
+
+        async def fake_send(msg, *, recipients=None, **kwargs):
+            if recipients:
+                captured_recipients.extend(recipients)
+
+        with patch("dhisana.utils.smtp_email_tools.aiosmtplib.send", side_effect=fake_send):
+            await send_email_via_smtp_async(
+                basic_context,
+                smtp_server="smtp.example.com",
+                smtp_port=587,
+                username="user",
+                password="pass",
+            )
+
+        assert captured_recipients == ["primary@example.com"]
+
+    @pytest.mark.asyncio
+    async def test_smtp_headers_cc_bcc_included_in_envelope(self):
+        """Cc/Bcc set via ctx.headers must also appear in envelope recipients."""
+        ctx = SendEmailContext(
+            recipient="primary@example.com",
+            subject="Header CC Test",
+            body="body",
+            sender_name="Sender",
+            sender_email="sender@example.com",
+            labels=None,
+            body_format=BodyFormat.TEXT,
+            headers={
+                "Cc": "header-cc@example.com",
+                "Bcc": "header-bcc@example.com",
+            },
+        )
+
+        captured_recipients = []
+
+        async def fake_send(msg, *, recipients=None, **kwargs):
+            if recipients:
+                captured_recipients.extend(recipients)
+
+        with patch("dhisana.utils.smtp_email_tools.aiosmtplib.send", side_effect=fake_send):
+            await send_email_via_smtp_async(
+                ctx,
+                smtp_server="smtp.example.com",
+                smtp_port=587,
+                username="user",
+                password="pass",
+            )
+
+        assert "primary@example.com" in captured_recipients
+        assert "header-cc@example.com" in captured_recipients
+        assert "header-bcc@example.com" in captured_recipients