dhisana 0.0.1.dev20__tar.gz → 0.0.1.dev23__tar.gz

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

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

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

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

{dhisana-0.0.1.dev20 → dhisana-0.0.1.dev23}/src/dhisana/utils/agent_task.py

@@ -13,7 +13,7 @@ def get_task_agent_access_token(tool_config: Optional[List[Dict]] = None) -> str
     """
     if tool_config:
         task_agent_config = next(
-            (item for item in tool_config if item.get("name") == "dhisana_task_api_key"), None
+            (item for item in tool_config if item.get("name") == "dhisana_workflow_tools"), None
         )
         if task_agent_config:
             config_map = {
@@ -32,38 +32,11 @@ def get_task_agent_access_token(tool_config: Optional[List[Dict]] = None) -> str
         raise ValueError("TASK_AGENT_API_KEY not found in config or env.")
     return TASK_AGENT_API_KEY
 
-def get_agent_id(tool_config: Optional[List[Dict]] = None) -> str:
-    """
-    Retrieves the AGENT_ID from the provided tool configuration or environment.
-
-    Raises:
-        ValueError: If the AGENT_ID is not found.
-    """
-    if tool_config:
-        agent_id_config = next(
-            (item for item in tool_config if item.get("name") == "agent_id"), None
-        )
-        if agent_id_config:
-            config_map = {
-                c["name"]: c["value"]
-                for c in agent_id_config.get("configuration", [])
-                if c
-            }
-            AGENT_ID = config_map.get("id")
-        else:
-            AGENT_ID = None
-    else:
-        AGENT_ID = None
-
-    AGENT_ID = AGENT_ID or os.getenv("AGENT_ID", "agent_123")
-    if not AGENT_ID:
-        raise ValueError("AGENT_ID not found in config or env.")
-    return AGENT_ID
 
 async def execute_task(
     command_name: str,
     command_args: Dict[str, Any],
-    max_timeout: float = 300,
+    max_timeout: float = 2400,
     tool_config: Optional[List[Dict]] = None
 ) -> Dict[str, Any]:
     """
@@ -71,13 +44,14 @@ async def execute_task(
     2. Polls /get_agent_task_result until completion or until max_timeout has passed.
     3. Removes task from status queue and pending queue.
     4. Returns the command result.
+
+    This function is asynchronous and will yield control during sleep intervals,
+    allowing other tasks to run concurrently.
     """
     # ----------------------------------------------------------------
     # CONFIG & PREP
     # ----------------------------------------------------------------
     TASK_AGENT_API_KEY = get_task_agent_access_token(tool_config)
-    # Hardcode or load from environment if desired
-    agent_id = get_agent_id(tool_config)
 
     # Unique ID for this request
     request_id = str(uuid.uuid4())
@@ -96,18 +70,21 @@ async def execute_task(
     remove_task_url = f"{api_base_url}/remove_agent_task"
     remove_task_result_url = f"{api_base_url}/remove_agent_task_result"
 
-    # This will hold the final result
+    headers = {
+        "Authorization": f"Bearer {TASK_AGENT_API_KEY}",
+        "Content-Type": "application/json"
+    }
+
     final_result: Dict[str, Any] = {}
 
-    # ----------------------------------------------------------------
-    # 1) ENQUEUE THE TASK
-    # ----------------------------------------------------------------
     async with aiohttp.ClientSession() as session:
-        # Add the task
+        # ----------------------------------------------------------------
+        # 1) ENQUEUE THE TASK
+        # ----------------------------------------------------------------
         async with session.post(
             add_task_url,
-            params={"agent_id": agent_id, "api_key": TASK_AGENT_API_KEY},
-            json=payload
+            json=payload,
+            headers=headers
         ) as response:
             if response.status != 200:
                 raise Exception(f"Failed to add task. Status code: {response.status}")
@@ -119,17 +96,14 @@ async def execute_task(
         # 2) POLL UNTIL THE TASK IS COMPLETED OR TIMEOUT
         # ----------------------------------------------------------------
         start_time = time.time()
-        while True:
-            if (time.time() - start_time) >= max_timeout:
-                # Timed out
-                raise TimeoutError(
-                    f"Task {request_id} did not complete within {max_timeout} seconds."
-                )
+        end_time = start_time + max_timeout
 
+        while time.time() < end_time:
             # Poll for the result
             async with session.post(
                 get_task_result_url,
-                params={"request_id": request_id, "agent_id": agent_id}
+                params={"request_id": request_id},
+                headers=headers
             ) as poll_response:
                 if poll_response.status != 200:
                     raise Exception(
@@ -149,15 +123,21 @@ async def execute_task(
                 final_result = poll_data.get("result", {})
                 break
 
-            # Task not yet completed; sleep before next poll
+            # Not yet completed; wait a bit before polling again
             await asyncio.sleep(20)
+        else:
+            # If we exit the while-loop normally (no break), it's a timeout
+            raise TimeoutError(
+                f"Task {request_id} did not complete within {max_timeout} seconds."
+            )
 
         # ----------------------------------------------------------------
         # 3) REMOVE THE TASK RESULTS FROM THE STATUS QUEUE
         # ----------------------------------------------------------------
         async with session.delete(
             remove_task_result_url,
-            params={"request_id": request_id, "agent_id": agent_id}
+            params={"request_id": request_id},
+            headers=headers
         ) as remove_res_status:
             if remove_res_status.status != 200:
                 raise Exception(
@@ -166,12 +146,10 @@ async def execute_task(
                 )
             remove_status_resp = await remove_res_status.json()
             if remove_status_resp.get("status") != "OK":
-                # Not a fatal error, but we raise to be safe
+                # Not a fatal error, but raise to be safe
                 raise Exception(f"Error removing task result: {remove_status_resp}")
 
     # ----------------------------------------------------------------
     # 4) RETURN THE RESULT
     # ----------------------------------------------------------------
-    return final_result
-
-
+    return final_result

dhisana-0.0.1.dev23/src/dhisana/utils/check_for_intent_signal.py

@@ -0,0 +1,94 @@
+import logging
+from typing import Any, Dict, List, Optional, cast
+
+from pydantic import BaseModel
+from dhisana.utils.generate_structured_output_internal import get_structured_output_with_o1
+from dhisana.utils.compose_search_query import (
+    generate_google_search_queries,
+    get_search_results_for_insights
+)
+
+logger = logging.getLogger(__name__)
+logging.basicConfig(level=logging.INFO)
+
+
+class IntentSignalScoring(BaseModel):
+    score_based_on_intent_signal: int
+
+
+async def check_for_intent_signal(
+    lead: Dict[str, Any],
+    signal_to_look_for_in_plan_english: str,
+    intent_signal_type: str,
+    add_search_results: Optional[bool] = False,
+    tool_config: Optional[List[Dict[str, Any]]] = None
+) -> int:
+    """
+    Evaluate a 'lead' for a specific intent signal and return an integer score from 0–5.
+    """
+
+    search_results_text = ""
+    if add_search_results:
+        # Correctly call get_search_results_for_insights with intent_signal_type
+        search_results = await get_search_results_for_insights(
+            lead=lead,
+            english_description=signal_to_look_for_in_plan_english,
+            intent_signal_type=intent_signal_type,
+            tool_config=tool_config
+        )
+
+        # Build a readable string from returned queries and results
+        # Each item in 'search_results' is a dict: {"query": str, "results": <json-encoded list of SERP results>}
+        for item in search_results:
+            query_str = item.get("query", "")
+            results_str = item.get("results", "")
+            search_results_text += f"Query: {query_str}\nResults: {results_str}\n\n"
+
+    user_prompt = f"""
+    Hi AI Assistant,
+    You are an expert in scoring leads based on intent signals.
+    You have the following lead and user requirements to provide a  qulifying lead score score between 0 and 5 
+    based on the intent signal the user is looking for.
+    Do the following step by step:
+    1. This about the summary of the lead and the company lead is working for.
+    2. Create a summary of the search results obtained.     
+    3. Think about the signal user is looking for to qualify and score the lead. 
+    4. Use the lead information, summary of search results and signal user is looking for to score the lead.
+    5. Go back and check if the score makes sense. Score between 0-5 based on the confidence of the signal.
+    
+    Lead Data:
+    {lead}
+
+    Description of the signal user is looking for:
+    {signal_to_look_for_in_plan_english}
+    
+    Following is some search results I found online. Use them if they are relevant for scoring:
+    {search_results_text}
+
+    Return your answer in valid JSON with the key 'score_based_on_intent_signal'.
+    Make sure it is an integer between 0 and 5.
+    """
+
+    logger.info("Scoring intent signal '%s' for lead: %s", intent_signal_type, lead.get("full_name", "Unknown"))
+
+    # The helper returns (model_instance or None, status_str)
+    response_any, status = await get_structured_output_with_o1(
+        user_prompt,
+        IntentSignalScoring,
+        tool_config=tool_config
+    )
+
+    if status != "SUCCESS" or response_any is None:
+        raise Exception("Failed to generate an intent signal score from the LLM.")
+
+    # Cast to your specific model so the type checker is satisfied
+    response = cast(IntentSignalScoring, response_any)
+    score = response.score_based_on_intent_signal
+
+    logger.info(
+        "Lead '%s' scored %d for intent signal '%s'.",
+        lead.get("full_name", "Unknown"),
+        score,
+        intent_signal_type
+    )
+    return score

dhisana-0.0.1.dev23/src/dhisana/utils/compose_cadence.py

@@ -0,0 +1,194 @@
+import json
+import logging
+from typing import Any, Dict, List, Optional, Tuple
+
+
+from dhisana.utils.generate_structured_output_internal import get_structured_output_with_o1
+from dhisana.utils.workflow_code_model import WorkflowPythonCode
+
+# Initialize logger
+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
+) -> Tuple[Dict[str, Any], str]:
+    """
+    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
+    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"
+        "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"
+        "Return 'SUCCESS' or 'ERROR' as a string."
+    )
+
+    example_of_workflow_code = (
+        '''
+        async def run_campaing_cadence(input_leads, tool_config):
+            """
+            Example skeleton. Run a linkedin campaign cadence with actions like view_profile, send_message etc.
+            Returns "SUCCESS" or "ERROR".
+            """
+            
+            # Make sure required imports are there within the function definition itself.
+            import asyncio
+            import logging
+            from typing import Any, Dict, List, Optional, Tuple
+            from dhisana.utils.agent_task import execute_task
+            from dhisana.utils.generate_linkedin_connect_message import get_personalized_linkedin_message
+            
+            # Make sure logger is defined and the logging library is imported within the function.
+            logger = logging.getLogger(__name__)
+            logging.basicConfig(level=logging.INFO)
+        
+            try:
+                MAX_ACTIONS = {
+                    "view_profile": 30,
+                    "send_connection_request": 10,
+                    "send_message": 10,
+                    "like_post": 10
+                }
+
+                # View profiles
+                for lead in input_leads[:MAX_ACTIONS["view_profile"]]:
+                    await execute_task(
+                        command_name="view_linked_in_profile",
+                        command_args={"salesnav_url_profile": lead.get("lead_salesnav_url")},
+                        tool_config=tool_config
+                    )
+                    logger.debug("Viewed profile: %s", lead.get("full_name"))
+
+                # Send connection requests
+                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")},
+                        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
+                    )
+                    await execute_task(
+                        command_name="send_message",
+                        command_args={
+                            "salesnav_url_profile": lead.get("lead_salesnav_url"),
+                            "message": message_to_send
+                        },
+                        tool_config=tool_config
+                    )
+                    logger.debug("Sent message to: %s", lead.get("full_name"))
+
+                # Like recent posts
+                for lead in input_leads[:MAX_ACTIONS["like_post"]]:
+                    await execute_task(
+                        command_name="like_recent_post",
+                        command_args={"salesnav_url_profile": lead.get("lead_salesnav_url")},
+                        tool_config=tool_config
+                    )
+                    logger.debug("Liked recent post for lead: %s", lead.get("full_name"))
+
+                logger.info("Completed run_campaing_cadence successfully.")
+                return "SUCCESS"
+
+            except Exception as e:
+                logger.exception("Exception in run_campaing_cadence: %s", e)
+                return "ERROR"
+        '''
+    )
+
+    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. "
+    The user wants to generate Python code that does this:
+
+    \"{english_description}\"
+
+    Here is an example workflow code:
+    {example_of_workflow_code}
+
+    The final code must be valid Python, and must produce:
+      async def run_campaing_cadence(input_leads, tool_config) -> str
+
+    Return your final output as valid JSON with:
+    {{
+      "workflow_python_code": "<the python code here>"
+    }}
+    """
+    response, status = await get_structured_output_with_o1(
+        user_prompt, WorkflowPythonCode, tool_config=tool_config
+    )
+    return response.model_dump(), status
+
+async def generate_campaign_cadence_workflow_and_execute(
+    user_query: str,
+    input_leads: List[Dict[str, Any]],
+    tool_config: Optional[List[Dict[str, Any]]] = None
+) -> str:
+    """
+    Generate the campaign cadence workflow code from the user query, 
+    then execute it on the provided input_leads.
+
+    Returns:
+        JSON string describing success or error.
+    """
+    response, status = await generate_code_for_campaign_cadence(
+        user_query, tool_config=tool_config
+    )
+
+    # Check if we have a successful code generation
+    if status == "SUCCESS" and response and response.get("workflow_python_code"):
+        code = response["workflow_python_code"]
+        if not code:
+            return json.dumps({"error": "No workflow code generated.", "status": status})
+
+        logger.info("Generated workflow code:\n%s", code)
+
+        local_vars = {}
+        global_vars = {}
+
+        try:
+            # Execute the generated code; expect a function named `run_campaing_cadence`
+            exec(code, global_vars, local_vars)
+            campaign_fn = local_vars.get("run_campaing_cadence", None)
+            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)
+
+            try:
+                result = await run_campaign(input_leads, tool_config)
+            except Exception as e:
+                logger.exception("Error occurred while running run_campaing_cadence.")
+                return json.dumps({"status": "ERROR", "error": str(e)})
+
+            # If it's not "SUCCESS", treat it as an error
+            if not result or result != "SUCCESS":
+                return json.dumps({"error": "Error running the workflow code.", "status": "ERROR"})
+
+            return json.dumps({"status": "SUCCESS"})
+
+        except Exception as e:
+            logger.exception("Exception occurred while executing generated code.")
+            return json.dumps({"status": "ERROR", "error": str(e)})
+
+    # If code generation failed or no code snippet was returned
+    return json.dumps({"error": "No valid workflow code generated.", "status": status})