dhisana 0.0.1.dev23__tar.gz → 0.0.1.dev24__tar.gz

{dhisana-0.0.1.dev23 → dhisana-0.0.1.dev24}/PKG-INFO

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

{dhisana-0.0.1.dev23 → dhisana-0.0.1.dev24}/setup.py

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

{dhisana-0.0.1.dev23 → dhisana-0.0.1.dev24}/src/dhisana/utils/compose_cadence.py

@@ -2,6 +2,7 @@ import json
 import logging
 from typing import Any, Dict, List, Optional, Tuple
 
+from pydantic import BaseModel
 
 from dhisana.utils.generate_structured_output_internal import get_structured_output_with_o1
 from dhisana.utils.workflow_code_model import WorkflowPythonCode
@@ -10,7 +11,7 @@ from dhisana.utils.workflow_code_model import WorkflowPythonCode
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-    
+
 async def generate_code_for_campaign_cadence(
     english_description: str,
     tool_config: Optional[List[Dict[str, Any]]] = None
@@ -19,25 +20,25 @@ async def generate_code_for_campaign_cadence(
     Generate a workflow code (Python code) from an English description.
     
     The function produced will be named:
-        async def run_campaing_cadence(input_leads, tool_config) -> str
+        async def run_campaing_cadence(input_leads, campaign_context, tool_config) -> str
     Returns: (response_dict, status_string)
     """
     system_message = (
         "You are a helpful AI assistant and an expert Python coder. "
         "Convert the English description provided by the user into an executable Python function named "
         "'run_campaing_cadence', with the signature:\n"
-        "    async def run_campaing_cadence(input_leads, tool_config) -> str\n"
+        "    async def run_campaing_cadence(input_leads, campaign_context, tool_config) -> str\n"
         "The function should iterate over 'input_leads' and perform the required LinkedIn actions via execute_task. "
         "Valid commands include: "
-        "    view_linked_in_profile, send_connection_request, like_recent_post, send_message, get_current_messages, save_lead.\n"
+        "    view_linked_in_profile, send_connection_request, like_recent_post, send_linkedin_message, get_current_messages, save_lead.\n"
         "Return 'SUCCESS' or 'ERROR' as a string."
     )
 
     example_of_workflow_code = (
         '''
-        async def run_campaing_cadence(input_leads, tool_config):
+        async def run_campaing_cadence(input_leads, campaign_context, tool_config):
             """
-            Example skeleton. Run a linkedin campaign cadence with actions like view_profile, send_message etc.
+            Example skeleton. Run a linkedin campaign cadence with actions like view_profile, send_linkedin_message etc.
             Returns "SUCCESS" or "ERROR".
             """
             
@@ -56,7 +57,7 @@ async def generate_code_for_campaign_cadence(
                 MAX_ACTIONS = {
                     "view_profile": 30,
                     "send_connection_request": 10,
-                    "send_message": 10,
+                    "send_linkedin_message": 10,
                     "like_post": 10
                 }
 
@@ -73,23 +74,23 @@ async def generate_code_for_campaign_cadence(
                 for lead in input_leads[:MAX_ACTIONS["send_connection_request"]]:
                     await execute_task(
                         command_name="send_connection_request",
-                        command_args={"salesnav_url_profile": lead.get("lead_salesnav_url")},
+                        command_args={
+                            "salesnav_url_profile": lead.get("lead_salesnav_url"),
+                            "lead_info": lead,
+                            "context": campaign_context
+                        },
                         tool_config=tool_config
                     )
                     logger.debug("Sent connection request: %s", lead.get("full_name"))
 
                 # Send messages
-                for lead in input_leads[:MAX_ACTIONS["send_message"]]:
-                    message_to_send = await get_personalized_linkedin_message(
-                        lead_info=lead,
-                        outreach_context="Hello from my LinkedIn automation!",
-                        tool_config=tool_config
-                    )
+                for lead in input_leads[:MAX_ACTIONS["send_linkedin_message"]]:
                     await execute_task(
-                        command_name="send_message",
+                        command_name="send_linkedin_message",
                         command_args={
                             "salesnav_url_profile": lead.get("lead_salesnav_url"),
-                            "message": message_to_send
+                            "lead_info": lead,
+                            "context": campaign_context
                         },
                         tool_config=tool_config
                     )
@@ -115,7 +116,7 @@ async def generate_code_for_campaign_cadence(
 
     user_prompt = f"""
     {system_message}
-    "Make sure the imports are present within the function definition itself. Make sure the logging library is imported and logger defined withing the function. "
+    "Make sure the imports are present within the function definition itself. Make sure the logging library is imported and logger defined within the function. "
     The user wants to generate Python code that does this:
 
     \"{english_description}\"
@@ -124,7 +125,7 @@ async def generate_code_for_campaign_cadence(
     {example_of_workflow_code}
 
     The final code must be valid Python, and must produce:
-      async def run_campaing_cadence(input_leads, tool_config) -> str
+      async def run_campaing_cadence(input_leads, campaign_context, tool_config) -> str
 
     Return your final output as valid JSON with:
     {{
@@ -136,8 +137,13 @@ async def generate_code_for_campaign_cadence(
     )
     return response.model_dump(), status
 
+
+class CampaignContext(BaseModel):
+    instructions: str
+
+
 async def generate_campaign_cadence_workflow_and_execute(
-    user_query: str,
+    instructions: str,
     input_leads: List[Dict[str, Any]],
     tool_config: Optional[List[Dict[str, Any]]] = None
 ) -> str:
@@ -149,7 +155,7 @@ async def generate_campaign_cadence_workflow_and_execute(
         JSON string describing success or error.
     """
     response, status = await generate_code_for_campaign_cadence(
-        user_query, tool_config=tool_config
+        instructions, tool_config=tool_config
     )
 
     # Check if we have a successful code generation
@@ -170,12 +176,13 @@ async def generate_campaign_cadence_workflow_and_execute(
             if campaign_fn is None:
                 raise RuntimeError("No 'run_campaing_cadence' function found in generated code.")
 
-            # Now run the async function with the leads
-            async def run_campaign(leads, cfg):
-                return await campaign_fn(leads, cfg)
+            # Helper to call the newly generated async function
+            async def run_campaign(leads, campaign_context, cfg):
+                return await campaign_fn(leads, campaign_context, cfg)
 
             try:
-                result = await run_campaign(input_leads, tool_config)
+                campaign_context = CampaignContext(instructions=instructions)
+                result = await run_campaign(input_leads, campaign_context, tool_config)
             except Exception as e:
                 logger.exception("Error occurred while running run_campaing_cadence.")
                 return json.dumps({"status": "ERROR", "error": str(e)})

{dhisana-0.0.1.dev23 → dhisana-0.0.1.dev24}/src/dhisana/utils/compose_three_step_workflow.py

@@ -196,7 +196,7 @@ async def generate_three_step_workflow_execute(
                 # generate_campaign_cadence_workflow_and_execute might return JSON:
                 # { "status": "SUCCESS", "result": "Campaign done" } or similar
                 result_str = await generate_campaign_cadence_workflow_and_execute(
-                    user_query=step_3_instructions,
+                    instructions=step_3_instructions,
                     input_leads=leads_list,
                     tool_config=tool_config
                 )

{dhisana-0.0.1.dev23 → dhisana-0.0.1.dev24}/src/dhisana/utils/compose_workflow.py

@@ -42,7 +42,7 @@ async def generate_workflow_code(
         "view_linked_in_profile",
         "send_connection_request",
         "like_recent_post",
-        "send_message",
+        "send_linkedin_message",
         "get_current_messages",
     ]
 
@@ -128,7 +128,7 @@ async def custom_workflow(tool_config):
     MAX_ACTIONS = {
         "view_profile": 30,
         "send_connection_request": 10,
-        "send_message": 10,
+        "send_linkedin_message": 10,
         "like_post": 10
     }
     
@@ -146,11 +146,11 @@ async def custom_workflow(tool_config):
             tool_config=tool_config
         )
     
-    for lead in qualified_leads[:MAX_ACTIONS["send_message"]]:
+    for lead in qualified_leads[:MAX_ACTIONS["send_linkedin_message"]]:
         context = "<< Fill in context that can be used to generate message>>"  # Fill in campaign context in which the message is being sent
         message_to_send = await get_personalized_linkedin_message(lead_info=lead, outreach_context=context, tool_config=tool_config)
         await execute_task(
-            command_name="send_message", 
+            command_name="send_linkedin_message", 
             command_args={"salesnav_url_profile": lead.get("lead_salesnav_url"), "message": message_to_send}, 
             tool_config=tool_config
         )

dhisana-0.0.1.dev24/src/dhisana/utils/generate_linkedin_response_message.py

@@ -0,0 +1,160 @@
+from typing import Any, Dict, List, Optional
+from pydantic import BaseModel
+from dhisana.utils.generate_structured_output_internal import (
+    get_structured_output_with_o1
+)
+
+class LinkedInTriageResponse(BaseModel):
+    """
+    Model representing the structured response for a LinkedIn conversation triage.
+    - triage_status: "AUTOMATIC" or "REQUIRES_APPROVAL"
+    - triage_reason: Optional reason text if triage_status == "REQUIRES_APPROVAL"
+    - response_action_to_take: The recommended next action (e.g., SEND_REPLY, WAIT_TO_SEND, STOP_SENDING, etc.)
+    - response_message: The actual message (body) to be sent or used for approval.
+    """
+    triage_status: str  # "AUTOMATIC" or "REQUIRES_APPROVAL"
+    triage_reason: Optional[str]
+    response_action_to_take: str
+    response_message: str
+
+
+def cleanup_reply_linkedin_context(lead_info: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Clone or sanitize the lead info to remove unneeded or sensitive fields.
+    """
+    cleaned_lead_info = dict(lead_info)  # Shallow copy
+
+    # Example of removing or masking unwanted fields
+    cleaned_lead_info.pop("task_ids", None)
+    cleaned_lead_info.pop("research_status", None)
+    # Add more fields you want to remove as needed
+
+    return cleaned_lead_info
+
+
+async def generate_linkedin_response_message(
+    lead_info: Dict[str, Any],
+    outreach_context: str,
+    connect_template: str,
+    current_conversations: str,
+    additional_instructions: str,
+    tool_config: Optional[List[Dict]] = None
+) -> Dict[str, Any]:
+    """
+    Generate a triaged LinkedIn message, deciding if it can be sent automatically
+    or requires human approval. The final JSON structure must conform to
+    LinkedInTriageResponse (triage_status, triage_reason, response_action_to_take, response_message).
+
+    The content should be genuine, authentic, and professional, avoiding clichés
+    and heavy sales pushes. It should be respectful of user preferences (e.g., not
+    spamming a user who has shown disinterest).
+    """
+
+    # Possible actions for spam-avoidance, scheduling, and response
+    allowed_actions = [
+        "SEND_REPLY",        # Normal: send reply
+        "WAIT_TO_SEND",      # Wait because user was recently messaged
+        "STOP_SENDING",      # No more messages to user
+        "SCHEDULE_MEETING",  # If user requests a meeting
+        "FOLLOW_UP_LATER",
+        "NEED_MORE_INFO",
+        "OTHER"
+    ]
+
+    cleaned_lead_info = cleanup_reply_linkedin_context(lead_info)
+
+    # Incorporate the outreach context and guidelines directly in the prompt
+    prompt = f"""
+    You are a specialized LinkedIn assistant.
+
+    Your task:
+      1. Analyze the current LinkedIn conversation.
+      2. Inspect the user (lead) info, outreach campaign context, and any additional instructions.
+      3. Decide whether to automatically send a reply or if human approval is needed (triage).
+      4. If approval is needed, provide the reason.
+      5. Choose one recommended next action from: {allowed_actions}.
+      6. Provide a short LinkedIn message body that addresses the lead's conversation.
+
+    Connect Template (for reference):
+    {connect_template}
+
+    Outreach (Campaign) Context:
+    {outreach_context}
+
+    Additional Instructions (Triage Guidelines):
+    {additional_instructions}
+
+    Current Conversations:
+    {current_conversations}
+
+    Lead Info:
+    {cleaned_lead_info}
+
+    === IMPORTANT ANTI-SPAM AND RESPECT RULES ===
+    1. If we have sent a message to the user within the past 24 hours and the user has not responded,
+       do NOT send another message right now. Instead, triage with "WAIT_TO_SEND".
+    2. If we have sent more than 3 messages in total without any user response, do NOT send another message.
+       Instead, triage with "STOP_SENDING".
+    3. If the user explicitly says "don't reply", "not interested", or any equivalent,
+       do NOT continue the thread. Triage with "STOP_SENDING".
+    4. If the user has requested a meeting, triage as "AUTOMATIC" or "REQUIRES_APPROVAL" 
+       (depending on complexity), and set response_action_to_take to "SCHEDULE_MEETING".
+       Craft a helpful response for scheduling.
+
+    === TONE AND STYLE RULES ===
+    - Your message must be genuine, authentic, and professional.
+    - Avoid clichés and spammy or overly aggressive sales pitches.
+    - Do not push sales in an unnatural way.
+
+    === OUTPUT FORMAT ===
+    Your final output must be valid JSON in this exact format:
+    {{
+      "triage_status": "AUTOMATIC" or "REQUIRES_APPROVAL",
+      "triage_reason": "<reason if REQUIRES_APPROVAL; else empty or null>",
+      "response_action_to_take": "<one of {allowed_actions}>",
+      "response_message": "<the new or reply message>"
+    }}
+    """
+
+    # Decide how to call your structured output function (based on vector store or not).
+    # We'll assume there's no vector store ID for LinkedIn. If you do have one, adapt similarly.
+    response, status = await get_structured_output_with_o1(
+        prompt=prompt,
+        response_format=LinkedInTriageResponse,
+        tool_config=tool_config
+    )
+
+    if status != 'SUCCESS':
+        raise Exception("Error in generating the triaged LinkedIn message.")
+    
+    return response.model_dump()
+
+
+async def get_linkedin_response_message(
+    lead_info: Dict[str, Any],
+    outreach_context: str,
+    current_conversations: str,
+    additional_instructions: str,
+    tool_config: Optional[List[Dict]] = None
+) -> str:
+    """
+    Returns only the 'response_message' from the triaged LinkedIn response.
+    This includes usage of the outreach (campaign) context to better tailor
+    the message to the lead.
+    """
+    connect_template = """
+    Hi <<first_name>>,
+    << message >>
+    Thanks,
+    << sender_name >>
+    """
+
+    triaged_response = await generate_linkedin_response_message(
+        lead_info=lead_info,
+        outreach_context=outreach_context,
+        connect_template=connect_template,
+        current_conversations=current_conversations,
+        additional_instructions=additional_instructions,
+        tool_config=tool_config
+    )
+    return triaged_response.get("response_message", "")

{dhisana-0.0.1.dev23 → dhisana-0.0.1.dev24}/src/dhisana/utils/sales_navigator_crawler.py

@@ -179,7 +179,7 @@ async def find_button_by_name(page: Page, button_name: str) -> Any:
             return b
     return None
 
-async def send_message(page: Page, command_args: Dict[str, Any]) -> Dict[str, Any]:
+async def send_linkedin_message(page: Page, command_args: Dict[str, Any]) -> Dict[str, Any]:
     await goto_url(page, command_args)
 
     if "/sales/lead/" not in page.url:
@@ -787,7 +787,7 @@ command_to_function_mapping = {
     "navigate_to_url": navigate_to_url,
     "view_linked_in_profile": view_linked_in_profile,
     "send_connection_request": send_connection_request,
-    "send_message": send_message,
+    "send_linkedin_message": send_linkedin_message,
     "get_current_messages": get_current_messages,
     "extract_leads_information": extract_leads,
     "extract_lead_information": extract_lead,
@@ -989,7 +989,7 @@ def check_and_update_throttling_limits(task: Dict[str, Any]) -> Dict[str, Any]:
         "view_linked_in_profile": 500,
         "navigate_to_url": 500,
         "like_recent_post": 10,
-        "send_message": 10
+        "send_linkedin_message": 10
     }
     limit = daily_limits.get(cmd_id, 25)
 

{dhisana-0.0.1.dev23 → dhisana-0.0.1.dev24}/src/dhisana.egg-info/PKG-INFO

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

{dhisana-0.0.1.dev23 → dhisana-0.0.1.dev24}/src/dhisana.egg-info/SOURCES.txt

@@ -47,6 +47,7 @@ src/dhisana/utils/generate_email.py
 src/dhisana/utils/generate_email_response.py
 src/dhisana/utils/generate_flow.py
 src/dhisana/utils/generate_linkedin_connect_message.py
+src/dhisana/utils/generate_linkedin_response_message.py
 src/dhisana/utils/generate_structured_output_internal.py
 src/dhisana/utils/google_custom_search.py
 src/dhisana/utils/google_workspace_tools.py