dhisana 0.0.1.dev234__tar.gz → 0.0.1.dev236__tar.gz

{dhisana-0.0.1.dev234 → dhisana-0.0.1.dev236}/PKG-INFO

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

{dhisana-0.0.1.dev234 → dhisana-0.0.1.dev236}/setup.py

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

{dhisana-0.0.1.dev234 → dhisana-0.0.1.dev236}/src/dhisana/schemas/common.py

@@ -392,6 +392,7 @@ class ReplyEmailContext(BaseModel):
     reply_body: str
     sender_email: str
     sender_name: str
+    fallback_recipient: Optional[str] = None
     mark_as_read: str = "True"
     add_labels: Optional[List[str]] = None
     reply_body_format: BodyFormat = BodyFormat.AUTO

{dhisana-0.0.1.dev234 → dhisana-0.0.1.dev236}/src/dhisana/utils/enrich_lead_information.py

@@ -765,16 +765,32 @@ async def enrich_organization_info_from_company_url(
     organization_linkedin_url: str,
     use_strict_check: bool = True,
     tool_config: Optional[List[Dict[str, Any]]] = None,
+    categories: Optional[bool] = None,
+    funding_data: Optional[bool] = None,
+    exit_data: Optional[bool] = None,
+    acquisitions: Optional[bool] = None,
+    extra: Optional[bool] = None,
+    use_cache: Optional[str] = "if-present",
+    fallback_to_cache: Optional[str] = "on-error",
 ) -> Dict[str, Any]:
     """
     Given an organization LinkedIn URL, attempt to enrich its data (e.g. name, website)
-    via ProxyCurl. If data is found, set domain, then return the dict. Otherwise, return {}.
+    via ProxyCurl. Additional Proxycurl Company API boolean flags (categories, funding_data, etc.)
+    can be supplied to control the returned payload (True -> "include"). If data is found,
+    set domain, then return the dict. Otherwise, return {}.
     """
 
     # Call ProxyCurl to enrich
     company_data = await enrich_organization_info_from_proxycurl(
         organization_linkedin_url=organization_linkedin_url,
-        tool_config=tool_config
+        tool_config=tool_config,
+        categories=categories,
+        funding_data=funding_data,
+        exit_data=exit_data,
+        acquisitions=acquisitions,
+        extra=extra,
+        use_cache=use_cache,
+        fallback_to_cache=fallback_to_cache,
     )
 
     # If ProxyCurl returned any data, set domain, then return

{dhisana-0.0.1.dev234 → dhisana-0.0.1.dev236}/src/dhisana/utils/google_oauth_tools.py

@@ -194,46 +194,62 @@ async def list_emails_in_time_range_google_oauth_async(
         q_parts.extend([f"label:{lbl}" for lbl in context.labels])
     query = " ".join(q_parts)
 
-    params = {"q": query}
+    params = {"q": query, "maxResults": 100}
 
     items: List[MessageItem] = []
+    max_fetch = 500  # defensive cap to avoid excessive paging
     async with httpx.AsyncClient(timeout=30) as client:
         try:
-            list_resp = await client.get(base_url, headers=headers, params=params)
-            list_resp.raise_for_status()
-            list_data = list_resp.json() or {}
-            for m in list_data.get("messages", []) or []:
-                mid = m.get("id")
-                tid = m.get("threadId")
-                if not mid:
-                    continue
-                get_url = f"{base_url}/{mid}"
-                get_resp = await client.get(get_url, headers=headers)
-                get_resp.raise_for_status()
-                mdata = get_resp.json() or {}
-
-                headers_list = (mdata.get("payload") or {}).get("headers", [])
-                from_header = find_header(headers_list, "From") or ""
-                subject_header = find_header(headers_list, "Subject") or ""
-                date_header = find_header(headers_list, "Date") or ""
-
-                iso_dt = convert_date_to_iso(date_header)
-                s_name, s_email = parse_single_address(from_header)
-                r_name, r_email = find_all_recipients_in_headers(headers_list)
-
-                items.append(
-                    MessageItem(
-                        message_id=mdata.get("id", ""),
-                        thread_id=tid or "",
-                        sender_name=s_name,
-                        sender_email=s_email,
-                        receiver_name=r_name,
-                        receiver_email=r_email,
-                        iso_datetime=iso_dt,
-                        subject=subject_header,
-                        body=extract_email_body_in_plain_text(mdata),
+            next_page_token = None
+            while True:
+                page_params = dict(params)
+                if next_page_token:
+                    page_params["pageToken"] = next_page_token
+
+                list_resp = await client.get(base_url, headers=headers, params=page_params)
+                list_resp.raise_for_status()
+                list_data = list_resp.json() or {}
+                for m in list_data.get("messages", []) or []:
+                    if len(items) >= max_fetch:
+                        break
+                    mid = m.get("id")
+                    tid = m.get("threadId")
+                    if not mid:
+                        continue
+                    get_url = f"{base_url}/{mid}"
+                    get_resp = await client.get(get_url, headers=headers)
+                    get_resp.raise_for_status()
+                    mdata = get_resp.json() or {}
+
+                    headers_list = (mdata.get("payload") or {}).get("headers", [])
+                    from_header = find_header(headers_list, "From") or ""
+                    subject_header = find_header(headers_list, "Subject") or ""
+                    date_header = find_header(headers_list, "Date") or ""
+
+                    iso_dt = convert_date_to_iso(date_header)
+                    s_name, s_email = parse_single_address(from_header)
+                    r_name, r_email = find_all_recipients_in_headers(headers_list)
+
+                    items.append(
+                        MessageItem(
+                            message_id=mdata.get("id", ""),
+                            thread_id=tid or "",
+                            sender_name=s_name,
+                            sender_email=s_email,
+                            receiver_name=r_name,
+                            receiver_email=r_email,
+                            iso_datetime=iso_dt,
+                            subject=subject_header,
+                            body=extract_email_body_in_plain_text(mdata),
+                        )
                     )
-                )
+
+                if len(items) >= max_fetch:
+                    break
+
+                next_page_token = list_data.get("nextPageToken")
+                if not next_page_token:
+                    break
         except httpx.HTTPStatusError as exc:
             _rethrow_with_google_message(exc, "Gmail List OAuth")
 
@@ -267,15 +283,45 @@ async def reply_to_email_google_oauth_async(
             _rethrow_with_google_message(exc, "Gmail Fetch Message OAuth")
 
     headers_list = (original.get("payload") or {}).get("headers", [])
-    headers_map = {h.get("name"): h.get("value") for h in headers_list if isinstance(h, dict)}
-    thread_id = original.get("threadId")
-
-    subject = headers_map.get("Subject", "") or ""
+    # Use case-insensitive lookups via find_header to avoid missing values on header casing differences.
+    subject = find_header(headers_list, "Subject") or ""
     if not subject.startswith("Re:"):
         subject = f"Re: {subject}"
-    to_addresses = headers_map.get("From", "") or ""
-    cc_addresses = headers_map.get("Cc", "") or ""
-    message_id_header = headers_map.get("Message-ID", "") or ""
+    reply_to_header = find_header(headers_list, "Reply-To") or ""
+    from_header = find_header(headers_list, "From") or ""
+    to_header = find_header(headers_list, "To") or ""
+    cc_header = find_header(headers_list, "Cc") or ""
+    message_id_header = find_header(headers_list, "Message-ID") or ""
+    thread_id = original.get("threadId")
+
+    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()
+
+    cc_addresses = cc_header or ""
+    # Prefer Reply-To unless it points back to the sender. If the original was SENT mail,
+    # From will equal the sender, so we should reply to the original To/CC instead.
+    if reply_to_header and not _is_self(reply_to_header):
+        to_addresses = reply_to_header
+    elif from_header and not _is_self(from_header):
+        to_addresses = from_header
+    elif to_header and not _is_self(to_header):
+        to_addresses = to_header
+    else:
+        combined = ", ".join([v for v in (to_header, cc_header, from_header) if v])
+        to_addresses = combined
+        cc_addresses = ""
+
+    if (not to_addresses or _is_self(to_addresses)) and reply_email_context.fallback_recipient:
+        if not _is_self(reply_email_context.fallback_recipient):
+            to_addresses = reply_email_context.fallback_recipient
+            cc_addresses = ""
+
+    if not to_addresses or _is_self(to_addresses):
+        raise ValueError(
+            "No valid recipient found in the original message; refusing to reply to sender."
+        )
 
     # 2) Build reply MIME
     plain_reply, html_reply, resolved_reply_fmt = body_variants(

{dhisana-0.0.1.dev234 → dhisana-0.0.1.dev236}/src/dhisana/utils/google_workspace_tools.py

@@ -241,47 +241,64 @@ async def list_emails_in_time_range_async(
         query += f' {label_query}'
 
     headers = {'Authorization': f'Bearer {access_token}'}
-    params = {'q': query}
+    params = {'q': query, 'maxResults': 100}
 
     message_items: List[MessageItem] = []
+    max_fetch = 500  # defensive cap
     async with httpx.AsyncClient() as client:
-        response = await client.get(gmail_api_url, headers=headers, params=params)
-        response.raise_for_status()
-        messages = response.json().get('messages', [])
-
-        for msg in messages:
-            message_id = msg['id']
-            thread_id = msg['threadId']
-            message_url = f'{gmail_api_url}/{message_id}'
-            message_response = await client.get(message_url, headers=headers)
-            message_response.raise_for_status()
-            message_data = message_response.json()
+        next_page_token = None
+        while True:
+            page_params = dict(params)
+            if next_page_token:
+                page_params["pageToken"] = next_page_token
 
-            headers_list = message_data['payload']['headers']
-            from_header = find_header(headers_list, 'From') or ""
-            subject_header = find_header(headers_list, 'Subject') or ""
-            date_header = find_header(headers_list, 'Date') or ""
-
-            iso_datetime_str = convert_date_to_iso(date_header)
+            response = await client.get(gmail_api_url, headers=headers, params=page_params)
+            response.raise_for_status()
+            resp_json = response.json() or {}
+            messages = resp_json.get('messages', [])
+
+            for msg in messages:
+                if len(message_items) >= max_fetch:
+                    break
+                message_id = msg['id']
+                thread_id = msg.get('threadId', "")
+                message_url = f'{gmail_api_url}/{message_id}'
+                message_response = await client.get(message_url, headers=headers)
+                message_response.raise_for_status()
+                message_data = message_response.json()
+
+                headers_list = message_data['payload']['headers']
+                from_header = find_header(headers_list, 'From') or ""
+                subject_header = find_header(headers_list, 'Subject') or ""
+                date_header = find_header(headers_list, 'Date') or ""
+
+                iso_datetime_str = convert_date_to_iso(date_header)
+
+                # Parse the "From" into (sender_name, sender_email)
+                s_name, s_email = parse_single_address(from_header)
+
+                # Parse the recipients
+                r_name, r_email = find_all_recipients_in_headers(headers_list)
+
+                msg_item = MessageItem(
+                    message_id=message_data['id'],                
+                    thread_id=thread_id,
+                    sender_name=s_name,
+                    sender_email=s_email,
+                    receiver_name=r_name,
+                    receiver_email=r_email,
+                    iso_datetime=iso_datetime_str,
+                    subject=subject_header,
+                    body=extract_email_body_in_plain_text(message_data)
+                )
+                message_items.append(msg_item)
 
-            # Parse the "From" into (sender_name, sender_email)
-            s_name, s_email = parse_single_address(from_header)
+            if len(message_items) >= max_fetch:
+                break
 
-            # Parse the recipients
-            r_name, r_email = find_all_recipients_in_headers(headers_list)
-
-            msg_item = MessageItem(
-                message_id=message_data['id'],                
-                thread_id=thread_id,
-                sender_name=s_name,
-                sender_email=s_email,
-                receiver_name=r_name,
-                receiver_email=r_email,
-                iso_datetime=iso_datetime_str,
-                subject=subject_header,
-                body=extract_email_body_in_plain_text(message_data)
-            )
-            message_items.append(msg_item)
+            next_page_token = resp_json.get("nextPageToken")
+            if not next_page_token:
+                break
 
     return message_items
 
@@ -895,17 +912,43 @@ async def reply_to_email_async(
         original_message = response.json()
 
     headers_list = original_message.get('payload', {}).get('headers', [])
-    headers_dict = {h['name']: h['value'] for h in headers_list}
-    thread_id = original_message.get('threadId')
-
-    # 2. Prepare reply headers
-    subject = headers_dict.get('Subject', '')
+    # Case-insensitive header lookup and resilient recipient fallback to avoid Gmail 400s.
+    subject = find_header(headers_list, 'Subject') or ''
     if not subject.startswith('Re:'):
         subject = f'Re: {subject}'
+    reply_to_header = find_header(headers_list, 'Reply-To') or ''
+    from_header = find_header(headers_list, 'From') or ''
+    to_header = find_header(headers_list, 'To') or ''
+    cc_header = find_header(headers_list, 'Cc') or ''
+    message_id_header = find_header(headers_list, 'Message-ID') or ''
+    thread_id = original_message.get('threadId')
+
+    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()
 
-    to_addresses = headers_dict.get('From', '')
-    cc_addresses = headers_dict.get('Cc', '')
-    message_id_header = headers_dict.get('Message-ID', '')
+    cc_addresses = cc_header or ''
+    if reply_to_header and not _is_self(reply_to_header):
+        to_addresses = reply_to_header
+    elif from_header and not _is_self(from_header):
+        to_addresses = from_header
+    elif to_header and not _is_self(to_header):
+        to_addresses = to_header
+    else:
+        combined = ", ".join([v for v in (to_header, cc_header, from_header) if v])
+        to_addresses = combined
+        cc_addresses = ''
+
+    if (not to_addresses or _is_self(to_addresses)) and reply_email_context.fallback_recipient:
+        if not _is_self(reply_email_context.fallback_recipient):
+            to_addresses = reply_email_context.fallback_recipient
+            cc_addresses = ''
+
+    if not to_addresses or _is_self(to_addresses):
+        raise ValueError(
+            "No valid recipient found in the original message; refusing to reply to sender."
+        )
 
     # 3. Create the reply email message
     plain_reply, html_reply, resolved_reply_fmt = body_variants(

{dhisana-0.0.1.dev234 → dhisana-0.0.1.dev236}/src/dhisana/utils/microsoft365_tools.py

@@ -351,10 +351,50 @@ async def reply_to_email_m365_async(
         orig_subject = orig.get("subject", "")
         subject = orig_subject if orig_subject.startswith("Re:") else f"Re: {orig_subject}"
         thread_id = orig.get("conversationId", "")
-        from_addr = orig.get("from", {}).get("emailAddress", {})
-        to_addresses = from_addr.get("address", "")
         cc_list = orig.get("ccRecipients", [])
-        cc_addresses = ", ".join([(r.get("emailAddress", {}) or {}).get("address", "") for r in cc_list if r])
+        to_list = orig.get("toRecipients", [])
+        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
+            ]
+
+        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)]
+        )
+
+        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,
+            )
 
         # 2) Create reply-all draft with comment
         create_reply_url = (

{dhisana-0.0.1.dev234 → dhisana-0.0.1.dev236}/src/dhisana/utils/proxy_curl_tools.py

@@ -273,6 +273,46 @@ def transform_company_data(data: dict) -> dict:
     return transformed
 
 
+def _build_company_profile_params(
+    company_url: str,
+    profile_flags: Dict[str, Optional[str]],
+) -> Dict[str, str]:
+    """
+    Build request params for the Enrichlayer company profile endpoint,
+    ensuring we only forward flags that were explicitly provided.
+    """
+    params: Dict[str, str] = {'url': company_url}
+    for key, value in profile_flags.items():
+        if value is not None:
+            params[key] = value
+    return params
+
+
+def _build_company_cache_key(identifier: str, profile_flags: Dict[str, Optional[str]]) -> str:
+    """
+    Builds a cache key that is unique for the combination of identifier
+    (LinkedIn URL or domain) and the optional enrichment flags.
+    """
+    suffix_bits = [
+        f"{key}={value}"
+        for key, value in sorted(profile_flags.items())
+        if value is not None
+    ]
+    if suffix_bits:
+        return f"{identifier}|{'&'.join(suffix_bits)}"
+    return identifier
+
+
+def _bool_to_include_exclude(value: Optional[bool]) -> Optional[str]:
+    """
+    Convert a boolean flag into the string literals expected by Proxycurl.
+    True -> "include", False -> "exclude", None -> None (omit parameter).
+    """
+    if value is None:
+        return None
+    return "include" if value else "exclude"
+
+
 @backoff.on_exception(
     backoff.expo,
     aiohttp.ClientResponseError,
@@ -283,10 +323,27 @@ def transform_company_data(data: dict) -> dict:
 async def enrich_organization_info_from_proxycurl(
     organization_domain: Optional[str] = None,
     organization_linkedin_url: Optional[str] = None,
-    tool_config: Optional[List[Dict]] = None
+    tool_config: Optional[List[Dict]] = None,
+    categories: Optional[bool] = None,
+    funding_data: Optional[bool] = None,
+    exit_data: Optional[bool] = None,
+    acquisitions: Optional[bool] = None,
+    extra: Optional[bool] = None,
+    use_cache: Optional[str] = "if-present",
+    fallback_to_cache: Optional[str] = "on-error",
 ) -> Dict:
     """
     Fetch an organization's details from Proxycurl using either the organization domain or LinkedIn URL.
+    Additional keyword parameters map directly to the Enrichlayer Company Profile endpoint.
+    
+    Args:
+        organization_domain: Organization's domain name to resolve via Proxycurl.
+        organization_linkedin_url: LinkedIn company profile URL.
+        tool_config: Optional tool configuration metadata for credential lookup.
+        categories/funding_data/exit_data/acquisitions/extra: Set True to request
+            "include", False for "exclude", or None to omit.
+        use_cache: Controls Proxycurl caching behaviour (e.g. "if-present").
+        fallback_to_cache: Controls Proxycurl cache fallback behaviour (e.g. "on-error").
     
     Returns:
         dict: Transformed JSON response containing organization information,
@@ -308,6 +365,16 @@ async def enrich_organization_info_from_proxycurl(
         logger.warning("No organization domain or LinkedIn URL provided.")
         return {}
 
+    profile_flags: Dict[str, Optional[str]] = {
+        "categories": _bool_to_include_exclude(categories),
+        "funding_data": _bool_to_include_exclude(funding_data),
+        "exit_data": _bool_to_include_exclude(exit_data),
+        "acquisitions": _bool_to_include_exclude(acquisitions),
+        "extra": _bool_to_include_exclude(extra),
+        "use_cache": use_cache,
+        "fallback_to_cache": fallback_to_cache,
+    }
+
     # If LinkedIn URL is provided, standardize it and fetch data
     if organization_linkedin_url:
         logger.debug(f"Organization LinkedIn URL provided: {organization_linkedin_url}")
@@ -330,8 +397,9 @@ async def enrich_organization_info_from_proxycurl(
             if standardized_url and not standardized_url.endswith('/'):
                 standardized_url += '/'
 
+        cache_key = _build_company_cache_key(standardized_url, profile_flags)
         # Check cache for standardized LinkedIn URL
-        cached_response = retrieve_output("enrich_organization_info_from_proxycurl", standardized_url)
+        cached_response = retrieve_output("enrich_organization_info_from_proxycurl", cache_key)
         if cached_response is not None:
             logger.info(f"Cache hit for organization LinkedIn URL: {standardized_url}")
             cached_response = transform_company_data(cached_response)
@@ -339,11 +407,7 @@ async def enrich_organization_info_from_proxycurl(
 
         # Fetch details using standardized LinkedIn URL
         url = 'https://enrichlayer.com/api/v2/company'
-        params = {
-            'url': standardized_url,
-            'use_cache': 'if-present',
-            'fallback_to_cache': 'on-error',
-        }
+        params = _build_company_profile_params(standardized_url, profile_flags)
         logger.debug(f"Making request to Proxycurl with params: {params}")
 
         async with aiohttp.ClientSession() as session:
@@ -353,7 +417,7 @@ async def enrich_organization_info_from_proxycurl(
                     if response.status == 200:
                         result = await response.json()
                         transformed_result = transform_company_data(result)
-                        cache_output("enrich_organization_info_from_proxycurl", standardized_url, transformed_result)
+                        cache_output("enrich_organization_info_from_proxycurl", cache_key, transformed_result)
                         logger.info("Successfully retrieved and transformed organization info from Proxycurl by LinkedIn URL.")
                         return transformed_result
                     elif response.status == 429:
@@ -367,7 +431,7 @@ async def enrich_organization_info_from_proxycurl(
                             f"Proxycurl organization profile not found for LinkedIn URL {standardized_url}: {error_text}"
                         )
                         cache_output(
-                            "enrich_organization_info_from_proxycurl", standardized_url, {}
+                            "enrich_organization_info_from_proxycurl", cache_key, {}
                         )
                         return {}
                     else:
@@ -383,7 +447,8 @@ async def enrich_organization_info_from_proxycurl(
     # If organization domain is provided, resolve domain to LinkedIn URL and fetch data
     if organization_domain:
         logger.debug(f"Organization domain provided: {organization_domain}")
-        cached_response = retrieve_output("enrich_organization_info_from_proxycurl", organization_domain)
+        domain_cache_key = _build_company_cache_key(organization_domain, profile_flags)
+        cached_response = retrieve_output("enrich_organization_info_from_proxycurl", domain_cache_key)
         if cached_response is not None:
             logger.info(f"Cache hit for organization domain: {organization_domain}")
             return cached_response
@@ -414,12 +479,13 @@ async def enrich_organization_info_from_proxycurl(
 
                             profile_url = 'https://enrichlayer.com/api/v2/company'
                             try:
-                                async with session.get(profile_url, headers=HEADERS, params={'url': standardized_url}) as profile_response:
+                                profile_params = _build_company_profile_params(standardized_url, profile_flags)
+                                async with session.get(profile_url, headers=HEADERS, params=profile_params) as profile_response:
                                     logger.debug(f"Received profile response status: {profile_response.status}")
                                     if profile_response.status == 200:
                                         result = await profile_response.json()
                                         transformed_result = transform_company_data(result)
-                                        cache_output("enrich_organization_info_from_proxycurl", organization_domain, transformed_result)
+                                        cache_output("enrich_organization_info_from_proxycurl", domain_cache_key, transformed_result)
                                         logger.info("Successfully retrieved and transformed organization info from Proxycurl by domain.")
                                         return transformed_result
                                     elif profile_response.status == 429:
@@ -445,7 +511,7 @@ async def enrich_organization_info_from_proxycurl(
                     elif response.status == 404:
                         msg = "Item not found"
                         logger.warning(msg)
-                        cache_output("enrich_organization_info_from_proxycurl", organization_domain, {})
+                        cache_output("enrich_organization_info_from_proxycurl", domain_cache_key, {})
                         return {}
                     else:
                         error_text = await response.text()

{dhisana-0.0.1.dev234 → dhisana-0.0.1.dev236}/src/dhisana/utils/smtp_email_tools.py

@@ -394,17 +394,99 @@ async def reply_to_email_via_smtp_async(
         )
         try:
             conn.login(username, password)
-            conn.select(mailbox, readonly=False)  # can set flags if needed
-            # Search for the exact Message-ID header
-            status, nums = conn.search(None, "HEADER", "Message-ID", ctx.message_id)
-            if status != "OK" or not nums[0]:
-                logging.warning("IMAP search for %r returned %s", ctx.message_id, nums)
+            # Sent messages usually live outside INBOX; build a candidate list
+            # from the provided mailbox, common sent folders, and any LISTed
+            # mailboxes containing "sent" (case-insensitive).
+            candidate_mailboxes = []
+            if mailbox:
+                candidate_mailboxes.append(mailbox)
+            candidate_mailboxes.extend([
+                "Sent",
+                "Sent Items",
+                "Sent Mail",
+                "[Gmail]/Sent Mail",
+                "[Gmail]/Sent Items",
+                "INBOX.Sent",
+                "INBOX/Sent",
+            ])
+            try:
+                status, mailboxes = conn.list()
+                if status == "OK" and mailboxes:
+                    for mbox in mailboxes:
+                        try:
+                            decoded = mbox.decode(errors="ignore")
+                        except Exception:
+                            decoded = str(mbox)
+                        # Parse flags + name from LIST response:
+                        # e.g., (\\HasNoChildren \\Sent) "/" "Sent Items"
+                        flags = set()
+                        name_part = decoded
+                        if ") " in decoded:
+                            flags_raw, _, remainder = decoded.partition(") ")
+                            flags = {f.lower() for f in flags_raw.strip("(").split() if f}
+                            # remainder is like '"/" "Sent Items"' or '"/" Sent'
+                            pieces = remainder.split(" ", 1)
+                            if len(pieces) == 2:
+                                name_part = pieces[1].strip()
+                            else:
+                                name_part = remainder.strip()
+                        name_part = name_part.strip()
+                        if name_part.startswith('"') and name_part.endswith('"'):
+                            name_part = name_part[1:-1]
+
+                        # Prefer provider-marked \Sent flag; otherwise fall back to substring match.
+                        is_sent_flag = "\\sent" in flags
+                        is_sent_name = "sent" in name_part.lower()
+                        if is_sent_flag or is_sent_name:
+                            candidate_mailboxes.append(name_part)
+            except Exception:
+                logging.exception("IMAP LIST failed; continuing with default sent folders")
+            # Deduplicate while preserving order
+            seen = set()
+            candidate_mailboxes = [m for m in candidate_mailboxes if not (m in seen or seen.add(m))]
+
+            msg_data = None
+            for mb in candidate_mailboxes:
+                def _try_select(name: str) -> bool:
+                    # Quote mailbox names with spaces or special chars; fall back to raw.
+                    for candidate in (f'"{name}"', name):
+                        try:
+                            status, _ = conn.select(candidate, readonly=False)
+                        except imaplib.IMAP4.error as exc:
+                            logging.warning("IMAP select %r failed: %s", candidate, exc)
+                            continue
+                        except Exception as exc:
+                            logging.warning("IMAP select %r failed: %s", candidate, exc)
+                            continue
+                        if status == "OK":
+                            return True
+                    return False
+
+                if not _try_select(mb):
+                    continue
+                # Search for the Message-ID header. Some servers store IDs without angle
+                # brackets or require quoted search terms, so try a few variants.
+                candidates = [ctx.message_id]
+                trimmed = ctx.message_id.strip()
+                if trimmed.startswith("<") and trimmed.endswith(">"):
+                    candidates.append(trimmed[1:-1])
+                for mid in candidates:
+                    status, nums = conn.search(None, "HEADER", "Message-ID", f'"{mid}"')
+                    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":
+                            conn.store(num, "+FLAGS", "\\Seen")
+                        msg_data = data[0][1] if data and data[0] else None
+                        break
+                if msg_data:
+                    break
+
+            if not msg_data:
+                logging.warning("IMAP search for %r returned no matches in any mailbox", ctx.message_id)
                 return None
-            num = nums[0].split()[0]
-            _, data = conn.fetch(num, "(RFC822)")
-            if ctx.mark_as_read.lower() == "true":
-                conn.store(num, "+FLAGS", "\\Seen")
-            return data[0][1] if data and data[0] else None
+
+            return msg_data
         finally:
             try:
                 conn.close()
@@ -422,6 +504,17 @@ async def reply_to_email_via_smtp_async(
     # 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.
+    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}"

{dhisana-0.0.1.dev234 → dhisana-0.0.1.dev236}/src/dhisana.egg-info/PKG-INFO

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