dhisana 0.0.1.dev305__tar.gz → 0.0.1.dev307__tar.gz

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

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

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

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

{dhisana-0.0.1.dev305 → dhisana-0.0.1.dev307}/src/dhisana/schemas/sales.py

@@ -271,6 +271,8 @@ class ChannelType(str, Enum):
     REPLY_EMAIL = "reply_email"
     LINKEDIN_USER_MESSAGE = "linkedin_user_message"
     CUSTOM_MESSAGE = "custom_message"
+    SMS = "sms"
+    WHATSAPP = "whatsapp"
 
 class SenderInfo(BaseModel):
     """

{dhisana-0.0.1.dev305 → dhisana-0.0.1.dev307}/src/dhisana/utils/generate_content.py

@@ -6,6 +6,7 @@ from dhisana.utils.assistant_tool_tag import assistant_tool
 from dhisana.utils.generate_email import generate_personalized_email
 from dhisana.utils.generate_linkedin_response_message import get_linkedin_response_message_variations
 from dhisana.utils.generate_custom_message import generate_custom_message
+from dhisana.utils.generate_sms_whatsapp import generate_sms_whatsapp_message
 
 
 @assistant_tool
@@ -36,6 +37,8 @@ async def generate_content(
         return await generate_inbound_email_response_variations(generation_context, number_of_variations, tool_config)
     elif generation_context.target_channel_type == ChannelType.LINKEDIN_USER_MESSAGE.value:
         return await get_linkedin_response_message_variations(generation_context, number_of_variations, tool_config)
+    elif generation_context.target_channel_type in (ChannelType.SMS.value, ChannelType.WHATSAPP.value):
+        return await generate_sms_whatsapp_message(generation_context, number_of_variations, tool_config)
     else:
         # Default to CUSTOM_MESSAGE for any unrecognized channel type
         return await generate_custom_message(generation_context, number_of_variations, tool_config)

dhisana-0.0.1.dev307/src/dhisana/utils/generate_sms_whatsapp.py

@@ -0,0 +1,260 @@
+import re
+from datetime import datetime, timezone
+from typing import Dict, List, Optional
+
+from pydantic import BaseModel, ConfigDict
+
+from dhisana.schemas.sales import (
+    CampaignContext,
+    ChannelType,
+    ContentGenerationContext,
+    ConversationContext,
+    Lead,
+    MessageGenerationInstructions,
+    MessageItem,
+    SenderInfo,
+)
+from dhisana.utils.generate_email import _sanitize_lead_for_prompt
+from dhisana.utils.generate_structured_output_internal import (
+    get_structured_output_internal,
+    get_structured_output_with_assistant_and_vector_store,
+)
+
+DEFAULT_SMS_GEN_MODEL = "gpt-5.4"
+
+SMS_CHAR_LIMIT = 160
+WHATSAPP_CHAR_LIMIT = 1000
+
+# Standard opt-out suffix appended to every generated message.
+OPT_OUT_SUFFIX_SMS = "\nReply STOP to opt out."
+OPT_OUT_SUFFIX_WHATSAPP = "\nReply STOP to opt out."
+
+
+class SMSWhatsAppCopy(BaseModel):
+    body: str
+
+    model_config = ConfigDict(extra="forbid")
+
+
+def _effective_char_limit(channel_type: ChannelType) -> int:
+    if channel_type == ChannelType.WHATSAPP:
+        return WHATSAPP_CHAR_LIMIT
+    return SMS_CHAR_LIMIT
+
+
+def _opt_out_suffix(channel_type: ChannelType) -> str:
+    if channel_type == ChannelType.WHATSAPP:
+        return OPT_OUT_SUFFIX_WHATSAPP
+    return OPT_OUT_SUFFIX_SMS
+
+
+# Matches explicit opt-out instructions like "Reply STOP", "Text STOP to …",
+# "opt out", or "unsubscribe" — requires an action verb before "stop" so
+# normal prose like "stop wasting time" does not suppress the footer.
+_OPT_OUT_RE = re.compile(
+    r"(?:reply|text|send|message|say)\s+stop\b"
+    r"|\bopt[\s\-]?out\b"
+    r"|\bunsubscribe\b",
+    re.IGNORECASE,
+)
+
+
+def _ensure_opt_out(body: str, channel_type: ChannelType) -> str:
+    suffix = _opt_out_suffix(channel_type)
+    if _OPT_OUT_RE.search(body):
+        return body
+    return body.rstrip() + suffix
+
+
+def _cleanup_context(
+    ctx: ContentGenerationContext,
+) -> ContentGenerationContext:
+    clone = ctx.model_copy(deep=True)
+    if clone.external_known_data:
+        clone.external_known_data.external_openai_vector_store_id = None
+    return clone
+
+
+async def generate_sms_whatsapp_copy(
+    message_context: ContentGenerationContext,
+    message_instructions: MessageGenerationInstructions,
+    variation_text: str,
+    channel_type: ChannelType,
+    tool_config: Optional[List[Dict]] = None,
+) -> dict:
+    cleaned = _cleanup_context(message_context)
+
+    user_instructions = (
+        message_instructions.instructions_to_generate_message or ""
+    ).strip()
+    selected_instructions = user_instructions if user_instructions else variation_text
+
+    lead_data = cleaned.lead_info or Lead()
+    sender_data = cleaned.sender_info or SenderInfo()
+    campaign_data = cleaned.campaign_context or CampaignContext()
+    conversation_data = (
+        cleaned.current_conversation_context or ConversationContext()
+    )
+
+    char_limit = _effective_char_limit(channel_type)
+    opt_out_suffix = _opt_out_suffix(channel_type)
+    usable_chars = char_limit - len(opt_out_suffix)
+    channel_label = "WhatsApp" if channel_type == ChannelType.WHATSAPP else "SMS"
+
+    prompt = f"""You are an AI sales copywriter. Your task is to write exactly one personalized outbound business {channel_label} text message on behalf of the sender to the lead described below.
+
+This is a legitimate B2B sales outreach message. The sender has opted in to sending these messages through our platform.
+
+## Channel Rules — {channel_label}
+
+1. The message body (excluding the compliance footer) MUST be {usable_chars} characters or fewer.
+2. Plain text only — no HTML, no markdown, no emojis unless the instructions ask for them.
+3. No subject line — output only a "body" field.
+4. Be concise and conversational. Lead with value, not a greeting. Avoid filler.
+5. Do NOT include any opt-out / STOP language — the system appends it automatically.
+6. Do NOT include phone numbers, email addresses, or links unless the writing instructions explicitly request a specific provided URL.
+7. Ground every claim in the provided context. When information is missing, omit it — never guess or fabricate.
+8. Do not use em dashes.
+9. The "body" field must contain ONLY the message text. Never append JSON, metadata, or structured data to the body.
+
+## Lead
+
+Name: {lead_data.first_name or ''} {lead_data.last_name or ''}
+Organization: {lead_data.organization_name or ''}
+Title: {lead_data.job_title or ''}
+
+## Sender (closed set — use ONLY these facts)
+
+- Full Name: {sender_data.sender_full_name or ''}
+- First Name: {sender_data.sender_first_name or ''}
+- Last Name: {sender_data.sender_last_name or ''}
+- Bio: {sender_data.sender_bio or ''}
+
+## Campaign
+
+- Product: {campaign_data.product_name or ''}
+- Value Proposition: {campaign_data.value_prop or ''}
+- Call to Action: {campaign_data.call_to_action or ''}
+- Pain Points: {campaign_data.pain_points or []}
+- Proof Points: {campaign_data.proof_points or []}
+
+## Writing Instructions
+
+{selected_instructions}
+
+## Conversation History
+
+{conversation_data.current_email_thread or ''}
+{conversation_data.current_linkedin_thread or ''}
+
+## Output Format
+
+Return JSON with a single field: "body" (string, plain text, max {usable_chars} chars).
+
+## Additional Lead Context (reference only)
+
+{_sanitize_lead_for_prompt(lead_data)}
+"""
+
+    vector_store_id = (
+        message_context.external_known_data.external_openai_vector_store_id
+        if message_context.external_known_data
+        else None
+    )
+    use_cache = (
+        message_context.message_instructions.use_cache
+        if message_context.message_instructions
+        else True
+    )
+
+    if vector_store_id:
+        response, status = (
+            await get_structured_output_with_assistant_and_vector_store(
+                prompt=prompt,
+                response_format=SMSWhatsAppCopy,
+                vector_store_id=vector_store_id,
+                model=DEFAULT_SMS_GEN_MODEL,
+                effort="medium",
+                tool_config=tool_config,
+                use_cache=use_cache,
+            )
+        )
+    else:
+        response, status = await get_structured_output_internal(
+            prompt=prompt,
+            response_format=SMSWhatsAppCopy,
+            model=DEFAULT_SMS_GEN_MODEL,
+            effort="medium",
+            tool_config=tool_config,
+            use_cache=use_cache,
+        )
+
+    if status != "SUCCESS":
+        # Include the refusal/error detail if the model returned text
+        detail = ""
+        if isinstance(response, str) and response:
+            detail = f" Model response: {response[:200]}"
+        raise Exception(
+            f"Error: Could not generate {channel_label} message.{detail}"
+        )
+
+    body = (response.body or "").strip()
+    # Truncate if model exceeded the limit
+    if len(body) > usable_chars:
+        body = body[:usable_chars].rsplit(" ", 1)[0]
+    body = _ensure_opt_out(body, channel_type)
+
+    response_item = MessageItem(
+        message_id="",
+        thread_id="",
+        sender_name=sender_data.sender_full_name or "",
+        sender_email=sender_data.sender_email or "",
+        receiver_name=(message_context.lead_info.full_name or "") if message_context.lead_info else "",
+        receiver_email=(message_context.lead_info.email or "") if message_context.lead_info else "",
+        iso_datetime=datetime.now(timezone.utc).isoformat(),
+        subject="",
+        body=body,
+        html_body=None,
+    )
+    return response_item.model_dump()
+
+
+FRAMEWORK_VARIATIONS_SMS = [
+    "Write a brief, personalized outreach message. Lead with a relevant insight about the prospect's company.",
+    "Write a short value-first message — mention one pain point and how the product helps.",
+    "Write a concise, curiosity-driven message with a clear call to action.",
+]
+
+
+async def generate_sms_whatsapp_message(
+    generation_context: ContentGenerationContext,
+    number_of_variations: int = 3,
+    tool_config: Optional[List[Dict]] = None,
+) -> List[dict]:
+    channel_type = generation_context.target_channel_type or ChannelType.SMS
+    message_instructions = generation_context.message_instructions
+    user_instructions_exist = bool(
+        (message_instructions.instructions_to_generate_message or "").strip()
+    )
+
+    variations: List[dict] = []
+    for i in range(number_of_variations):
+        if user_instructions_exist:
+            variation_text = (
+                message_instructions.instructions_to_generate_message or ""
+            )
+        else:
+            variation_text = FRAMEWORK_VARIATIONS_SMS[
+                i % len(FRAMEWORK_VARIATIONS_SMS)
+            ]
+
+        copy = await generate_sms_whatsapp_copy(
+            message_context=generation_context,
+            message_instructions=message_instructions,
+            variation_text=variation_text,
+            channel_type=channel_type,
+            tool_config=tool_config,
+        )
+        variations.append(copy)
+
+    return variations

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

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

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

@@ -54,6 +54,7 @@ src/dhisana/utils/generate_flow.py
 src/dhisana/utils/generate_leads_salesnav.py
 src/dhisana/utils/generate_linkedin_connect_message.py
 src/dhisana/utils/generate_linkedin_response_message.py
+src/dhisana/utils/generate_sms_whatsapp.py
 src/dhisana/utils/generate_structured_output_internal.py
 src/dhisana/utils/google_custom_search.py
 src/dhisana/utils/google_oauth_tools.py
@@ -110,6 +111,7 @@ tests/test_apollo_lead_search.py
 tests/test_connectivity.py
 tests/test_email_body_utils.py
 tests/test_generate_email.py
+tests/test_generate_sms_whatsapp.py
 tests/test_google_document.py
 tests/test_hubspot_call_logs.py
 tests/test_linkedin_serper.py

dhisana-0.0.1.dev307/tests/test_generate_sms_whatsapp.py

@@ -0,0 +1,260 @@
+import asyncio
+import unittest
+from unittest.mock import AsyncMock, patch
+
+from dhisana.schemas.sales import (
+    CampaignContext,
+    ChannelType,
+    ContentGenerationContext,
+    ConversationContext,
+    Lead,
+    MessageGenerationInstructions,
+    SenderInfo,
+)
+from dhisana.utils.generate_sms_whatsapp import (
+    OPT_OUT_SUFFIX_SMS,
+    OPT_OUT_SUFFIX_WHATSAPP,
+    SMS_CHAR_LIMIT,
+    SMSWhatsAppCopy,
+    WHATSAPP_CHAR_LIMIT,
+    _effective_char_limit,
+    _ensure_opt_out,
+    generate_sms_whatsapp_copy,
+    generate_sms_whatsapp_message,
+)
+
+
+def _build_context(channel: ChannelType = ChannelType.SMS) -> ContentGenerationContext:
+    lead = Lead(
+        full_name="Jane Smith",
+        first_name="Jane",
+        last_name="Smith",
+        email="jane@acmecorp.com",
+        job_title="VP of Engineering",
+        organization_name="Acme Corp",
+        phone="404-555-1234",
+    )
+    sender = SenderInfo(
+        sender_full_name="John Doe",
+        sender_first_name="John",
+        sender_last_name="Doe",
+        sender_email="john@dhisana.ai",
+        sender_bio="Co-founder at Dhisana",
+    )
+    campaign = CampaignContext(
+        product_name="Dhisana AI",
+        value_prop="AI-powered sales outreach",
+        call_to_action="Book a demo",
+    )
+    instructions = MessageGenerationInstructions(
+        instructions_to_generate_message="Write a brief intro message.",
+        use_cache=False,
+        allow_html=False,
+    )
+    return ContentGenerationContext(
+        lead_info=lead,
+        sender_info=sender,
+        campaign_context=campaign,
+        current_conversation_context=ConversationContext(),
+        target_channel_type=channel,
+        message_instructions=instructions,
+    )
+
+
+class TestCharLimits(unittest.TestCase):
+    def test_sms_limit(self):
+        self.assertEqual(_effective_char_limit(ChannelType.SMS), SMS_CHAR_LIMIT)
+
+    def test_whatsapp_limit(self):
+        self.assertEqual(_effective_char_limit(ChannelType.WHATSAPP), WHATSAPP_CHAR_LIMIT)
+
+
+class TestOptOut(unittest.TestCase):
+    def test_appends_opt_out_to_sms(self):
+        result = _ensure_opt_out("Hi there!", ChannelType.SMS)
+        self.assertTrue(result.endswith(OPT_OUT_SUFFIX_SMS))
+
+    def test_appends_opt_out_to_whatsapp(self):
+        result = _ensure_opt_out("Hi there!", ChannelType.WHATSAPP)
+        self.assertTrue(result.endswith(OPT_OUT_SUFFIX_WHATSAPP))
+
+    def test_skips_when_reply_stop_present(self):
+        msg = "Reply STOP to unsubscribe."
+        result = _ensure_opt_out(msg, ChannelType.SMS)
+        self.assertEqual(result, msg)
+
+    def test_skips_when_text_stop_present(self):
+        msg = "Text STOP to cancel."
+        result = _ensure_opt_out(msg, ChannelType.SMS)
+        self.assertEqual(result, msg)
+
+    def test_skips_when_opt_out_present(self):
+        msg = "You may opt out at any time."
+        result = _ensure_opt_out(msg, ChannelType.SMS)
+        self.assertEqual(result, msg)
+
+    def test_skips_when_opt_hyphen_out_present(self):
+        msg = "Text opt-out to stop receiving messages."
+        result = _ensure_opt_out(msg, ChannelType.SMS)
+        self.assertEqual(result, msg)
+
+    def test_skips_when_unsubscribe_present(self):
+        msg = "Reply unsubscribe to stop."
+        result = _ensure_opt_out(msg, ChannelType.WHATSAPP)
+        self.assertEqual(result, msg)
+
+    def test_does_not_skip_for_stop_in_normal_prose(self):
+        msg = "Stop wasting hours on manual outreach."
+        result = _ensure_opt_out(msg, ChannelType.SMS)
+        self.assertTrue(result.endswith(OPT_OUT_SUFFIX_SMS))
+
+    def test_does_not_skip_for_stop_mid_sentence(self):
+        msg = "Let us help you stop losing deals."
+        result = _ensure_opt_out(msg, ChannelType.WHATSAPP)
+        self.assertTrue(result.endswith(OPT_OUT_SUFFIX_WHATSAPP))
+
+
+class TestGenerateSMSWhatsAppCopy(unittest.TestCase):
+    def test_sms_generation_single_copy(self):
+        ctx = _build_context(ChannelType.SMS)
+        mock_response = SMSWhatsAppCopy(body="Hey Jane, quick question about Acme's outreach.")
+
+        with patch(
+            "dhisana.utils.generate_sms_whatsapp.get_structured_output_internal",
+            new_callable=AsyncMock,
+            return_value=(mock_response, "SUCCESS"),
+        ):
+            result = asyncio.get_event_loop().run_until_complete(
+                generate_sms_whatsapp_copy(
+                    message_context=ctx,
+                    message_instructions=ctx.message_instructions,
+                    variation_text="Write a brief message.",
+                    channel_type=ChannelType.SMS,
+                )
+            )
+        self.assertIn("body", result)
+        self.assertEqual(result["subject"], "")
+        self.assertIn("STOP", result["body"])
+
+    def test_whatsapp_generation_single_copy(self):
+        ctx = _build_context(ChannelType.WHATSAPP)
+        mock_response = SMSWhatsAppCopy(body="Hi Jane, Dhisana AI can help Acme automate outreach.")
+
+        with patch(
+            "dhisana.utils.generate_sms_whatsapp.get_structured_output_internal",
+            new_callable=AsyncMock,
+            return_value=(mock_response, "SUCCESS"),
+        ):
+            result = asyncio.get_event_loop().run_until_complete(
+                generate_sms_whatsapp_copy(
+                    message_context=ctx,
+                    message_instructions=ctx.message_instructions,
+                    variation_text="Write a brief message.",
+                    channel_type=ChannelType.WHATSAPP,
+                )
+            )
+        self.assertIn("body", result)
+        self.assertIn("STOP", result["body"])
+
+    def test_truncation_when_body_exceeds_limit(self):
+        ctx = _build_context(ChannelType.SMS)
+        long_body = "A" * 200
+        mock_response = SMSWhatsAppCopy(body=long_body)
+
+        with patch(
+            "dhisana.utils.generate_sms_whatsapp.get_structured_output_internal",
+            new_callable=AsyncMock,
+            return_value=(mock_response, "SUCCESS"),
+        ):
+            result = asyncio.get_event_loop().run_until_complete(
+                generate_sms_whatsapp_copy(
+                    message_context=ctx,
+                    message_instructions=ctx.message_instructions,
+                    variation_text="Write a brief message.",
+                    channel_type=ChannelType.SMS,
+                )
+            )
+        self.assertLessEqual(len(result["body"]), SMS_CHAR_LIMIT)
+
+    def test_raises_on_llm_failure(self):
+        ctx = _build_context(ChannelType.SMS)
+
+        with patch(
+            "dhisana.utils.generate_sms_whatsapp.get_structured_output_internal",
+            new_callable=AsyncMock,
+            return_value=(None, "ERROR"),
+        ):
+            with self.assertRaises(Exception) as exc_ctx:
+                asyncio.get_event_loop().run_until_complete(
+                    generate_sms_whatsapp_copy(
+                        message_context=ctx,
+                        message_instructions=ctx.message_instructions,
+                        variation_text="Write a brief message.",
+                        channel_type=ChannelType.SMS,
+                    )
+                )
+            self.assertIn("SMS", str(exc_ctx.exception))
+
+    def test_no_html_in_body(self):
+        ctx = _build_context(ChannelType.SMS)
+        mock_response = SMSWhatsAppCopy(body="Hi Jane")
+
+        with patch(
+            "dhisana.utils.generate_sms_whatsapp.get_structured_output_internal",
+            new_callable=AsyncMock,
+            return_value=(mock_response, "SUCCESS"),
+        ):
+            result = asyncio.get_event_loop().run_until_complete(
+                generate_sms_whatsapp_copy(
+                    message_context=ctx,
+                    message_instructions=ctx.message_instructions,
+                    variation_text="Test",
+                    channel_type=ChannelType.SMS,
+                )
+            )
+        self.assertIsNone(result.get("html_body"))
+
+
+class TestGenerateSMSWhatsAppMessage(unittest.TestCase):
+    def test_generates_requested_number_of_variations(self):
+        ctx = _build_context(ChannelType.SMS)
+        mock_response = SMSWhatsAppCopy(body="Hey Jane, quick q about Acme.")
+
+        with patch(
+            "dhisana.utils.generate_sms_whatsapp.get_structured_output_internal",
+            new_callable=AsyncMock,
+            return_value=(mock_response, "SUCCESS"),
+        ):
+            results = asyncio.get_event_loop().run_until_complete(
+                generate_sms_whatsapp_message(ctx, number_of_variations=2)
+            )
+        self.assertEqual(len(results), 2)
+        for r in results:
+            self.assertIn("body", r)
+
+    def test_uses_framework_variations_when_no_user_instructions(self):
+        ctx = _build_context(ChannelType.WHATSAPP)
+        ctx.message_instructions.instructions_to_generate_message = None
+        mock_response = SMSWhatsAppCopy(body="Hi Jane, value-first msg.")
+
+        with patch(
+            "dhisana.utils.generate_sms_whatsapp.get_structured_output_internal",
+            new_callable=AsyncMock,
+            return_value=(mock_response, "SUCCESS"),
+        ) as mock_llm:
+            asyncio.get_event_loop().run_until_complete(
+                generate_sms_whatsapp_message(ctx, number_of_variations=3)
+            )
+        self.assertEqual(mock_llm.call_count, 3)
+
+
+class TestChannelTypeEnum(unittest.TestCase):
+    def test_sms_in_channel_type(self):
+        self.assertEqual(ChannelType.SMS.value, "sms")
+
+    def test_whatsapp_in_channel_type(self):
+        self.assertEqual(ChannelType.WHATSAPP.value, "whatsapp")
+
+
+if __name__ == "__main__":
+    unittest.main()