dhisana 0.0.1.dev265__tar.gz → 0.0.1.dev267__tar.gz

{dhisana-0.0.1.dev265 → dhisana-0.0.1.dev267}/PKG-INFO

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

{dhisana-0.0.1.dev265 → dhisana-0.0.1.dev267}/setup.py

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

{dhisana-0.0.1.dev265 → dhisana-0.0.1.dev267}/src/dhisana/utils/email_provider.py

@@ -124,9 +124,12 @@ async def send_email_async(
 
     Returns whatever the underlying provider helper returns:
 
+        * Mailgun           → str                (message-id from Mailgun)
+        * SendGrid          → str                (X-Message-Id from SendGrid)
         * SMTP              → str                (Message-ID)
         * Microsoft 365     → str                (message-id)
         * Google Workspace  → str                (message-id)
+        * Google OAuth      → str                (message-id)
     """
     # ------------------------------------------------------------------ #
     # 1) Try the preferred providers in order

{dhisana-0.0.1.dev265 → dhisana-0.0.1.dev267}/src/dhisana/utils/generate_structured_output_internal.py

@@ -19,6 +19,126 @@ from dhisana.utils.fetch_openai_config import (
     create_async_openai_client,
 )
 
+# Import search and scrape utilities for web search tools
+try:
+    from dhisana.utils.search_router import search_google_with_tools
+except Exception:
+    async def search_google_with_tools(*a, **k):
+        return []
+
+try:
+    from dhisana.utils.web_download_parse_tools import get_text_content_from_url
+except Exception:
+    async def get_text_content_from_url(url: str) -> str:
+        return ""
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Web search tool definitions for the Responses API
+# ──────────────────────────────────────────────────────────────────────────────
+
+SEARCH_GOOGLE_TOOL = {
+    "type": "function",
+    "name": "search_google",
+    "description": "Search Google for information. Returns a list of search results with titles, links, and snippets.",
+    "parameters": {
+        "type": "object",
+        "properties": {
+            "query": {
+                "type": "string",
+                "description": "The search query to look up on Google"
+            },
+            "num_results": {
+                "type": "integer",
+                "description": "Number of results to return (default: 5, max: 10)"
+            }
+        },
+        "required": ["query"],
+        "additionalProperties": False
+    }
+}
+
+FETCH_URL_CONTENT_TOOL = {
+    "type": "function",
+    "name": "fetch_url_content",
+    "description": "Fetch and extract text content from a URL. Use this to read the full content of a webpage.",
+    "parameters": {
+        "type": "object",
+        "properties": {
+            "url": {
+                "type": "string",
+                "description": "The URL to fetch content from"
+            }
+        },
+        "required": ["url"],
+        "additionalProperties": False
+    }
+}
+
+
+async def _execute_search_google(
+    query: str, num_results: int, tool_config: Optional[List[Dict]]
+) -> str:
+    """Execute Google search and return results as JSON string."""
+    try:
+        num_results = min(max(num_results, 1), 10)
+        raw = await search_google_with_tools(
+            query, number_of_results=num_results, offset=0, tool_config=tool_config
+        )
+        results = []
+        if isinstance(raw, list):
+            for item in raw:
+                try:
+                    data = json.loads(item) if isinstance(item, str) else item
+                    results.append({
+                        "title": data.get("title", ""),
+                        "link": data.get("link", ""),
+                        "snippet": data.get("snippet", "")
+                    })
+                except Exception:
+                    continue
+        return json.dumps(results, default=str)
+    except Exception as e:
+        logging.warning("search_google tool failed: %s", e)
+        return json.dumps({"error": str(e)})
+
+
+async def _execute_fetch_url_content(url: str) -> str:
+    """Fetch URL content and return as string."""
+    try:
+        content = await get_text_content_from_url(url)
+        if content:
+            max_len = 15000
+            if len(content) > max_len:
+                content = content[:max_len] + "\n... [content truncated]"
+            return content
+        return "Failed to fetch content from URL"
+    except Exception as e:
+        logging.warning("fetch_url_content tool failed for %s: %s", url, e)
+        return f"Error fetching URL: {str(e)}"
+
+
+async def _execute_web_search_tool(
+    tool_name: str, args: dict, tool_config: Optional[List[Dict]]
+) -> str:
+    """Execute a web search tool and return the result as a string."""
+    if tool_name == "search_google":
+        query = args.get("query", "")
+        num_results = args.get("num_results", 5)
+        if not query:
+            return json.dumps({"error": "Missing required parameter: query"})
+        return await _execute_search_google(query, num_results, tool_config)
+
+    elif tool_name == "fetch_url_content":
+        url = args.get("url", "")
+        if not url:
+            return json.dumps({"error": "Missing required parameter: url"})
+        return await _execute_fetch_url_content(url)
+
+    else:
+        logging.warning(f"Unknown tool requested: {tool_name}")
+        return json.dumps({"error": f"Unknown tool: {tool_name}"})
+
 
 # ──────────────────────────────────────────────────────────────────────────────
 # 1.  Helper functions
@@ -71,6 +191,9 @@ async def get_structured_output_internal(
 
     On a 429 (rate-limit) error the call is retried once after
     20 s + random exponential back-off.
+    
+    If use_web_search=True, uses Google search and URL scraping tools
+    to enable web research (works with both OpenAI and Azure OpenAI).
     """
     try:
         # ─── caching bookkeeping ────────────────────────────────────────────
@@ -95,30 +218,24 @@ async def get_structured_output_internal(
             "schema": schema["json_schema"]["schema"],
         }
 
-        # ─── client initialisation (NEW) ────────────────────────────────────
+        # ─── client initialisation ──────────────────────────────────────────
         client_async = create_async_openai_client(tool_config)
 
-        openai_cfg = _extract_config(tool_config, "openai")
-        # TODO: Azure OpenAI does not support web_search yet
-        if not openai_cfg:
-            use_web_search = False
+        # ─── Web search path (uses Google search + URL scraping tools) ──────
+        if use_web_search:
+            return await _get_structured_output_with_web_search(
+                client_async=client_async,
+                prompt=prompt,
+                response_format=response_format,
+                json_schema_format=json_schema_format,
+                model=model,
+                effort=effort,
+                tool_config=tool_config,
+                cache_key=cache_key,
+            )
 
-        # -------------------------------------------------------------------
-        # Internal helper to perform ONE attempt
-        # -------------------------------------------------------------------
+        # ─── Standard path (no web search) ──────────────────────────────────
         async def _make_request():
-            if use_web_search and model.startswith("gpt-"):
-                return await client_async.responses.create(
-                    input=[
-                        {"role": "system", "content": "You are a helpful AI. Output JSON only."},
-                        {"role": "user", "content": prompt},
-                    ],
-                    model=model,
-                    text={"format": json_schema_format},
-                    tool_choice="required",
-                    tools=[{"type": "web_search_preview"}],
-                    store=False,
-                )
             if model.startswith("o"):  # reasoning param only for "o" family
                 return await client_async.responses.create(
                     input=[
@@ -175,45 +292,8 @@ async def get_structured_output_internal(
                 logging.error(f"OpenAI API error: {e}")
                 return f"OpenAI API error: {str(e)}", "API_ERROR"
 
-        # ─── handle model output (unchanged) ────────────────────────────────
-        if completion and completion.output and len(completion.output) > 0:
-            raw_text = None
-            for out in completion.output:
-                if out.type == "message" and out.content:
-                    for content_item in out.content:
-                        if hasattr(content_item, "text"):
-                            raw_text = content_item.text
-                            break
-                        else:
-                            logging.warning("request refused: %s", str(content_item))
-                            return "Request refused.", "FAIL"
-                    if raw_text:
-                        break
-
-            if not raw_text or not raw_text.strip():
-                return "No text returned (possibly refusal or empty response)", "FAIL"
-
-            try:
-                parsed_obj = response_format.parse_raw(raw_text)
-                cache_output_tools.cache_output(
-                    "get_structured_output_internal", cache_key, parsed_obj.json()
-                )
-                return parsed_obj, "SUCCESS"
-
-            except Exception:
-                logging.warning("ERROR: Could not parse JSON from model output.")
-                try:
-                    fixed_json = repair_json(raw_text)
-                    parsed_obj = response_format.parse_raw(fixed_json)
-                    cache_output_tools.cache_output(
-                        "get_structured_output_internal", cache_key, parsed_obj.json()
-                    )
-                    return parsed_obj, "SUCCESS"
-                except Exception as e2:
-                    logging.warning("JSON repair failed: %s", str(e2))
-                    return raw_text, "FAIL"
-        else:
-            return "No output returned", "FAIL"
+        # ─── handle model output ────────────────────────────────────────────
+        return _parse_completion_response(completion, response_format, cache_key)
 
     # Safety fallback: catch any OpenAI errors not caught by inner retry loop
     except OpenAIError as e:
@@ -226,6 +306,173 @@ async def get_structured_output_internal(
         return f"Unexpected error: {str(e)}", "ERROR"
 
 
+async def _get_structured_output_with_web_search(
+    client_async,
+    prompt: str,
+    response_format: BaseModel,
+    json_schema_format: Dict,
+    model: str,
+    effort: str,
+    tool_config: Optional[List[Dict]],
+    cache_key: str,
+):
+    """
+    Handles structured output with web search using Google search and URL scraping tools.
+    Works with both OpenAI and Azure OpenAI.
+    """
+    tools = [SEARCH_GOOGLE_TOOL, FETCH_URL_CONTENT_TOOL]
+    
+    system_content = (
+        "You are a helpful AI. Output JSON only.\n\n"
+        "Web Search Instructions:\n"
+        "- Use search_google to find relevant information on the web.\n"
+        "- Use fetch_url_content to read the full content of relevant URLs.\n"
+        "- After gathering information, provide your response in the required JSON format."
+    )
+    
+    input_messages = [
+        {"role": "system", "content": system_content},
+        {"role": "user", "content": prompt},
+    ]
+    
+    base_request = {
+        "input": input_messages,
+        "model": model,
+        "text": {"format": json_schema_format},
+        "tools": tools,
+        "store": False,
+    }
+    
+    if model.startswith("o"):
+        base_request["reasoning"] = {"effort": effort}
+    
+    max_tool_iterations = 10
+    tool_iteration = 0
+    completion = None
+    
+    while tool_iteration < max_tool_iterations:
+        tool_iteration += 1
+        
+        # Retry logic for rate limits
+        for attempt in range(2):
+            try:
+                completion = await client_async.responses.create(**base_request)
+                break
+            except (RateLimitError, OpenAIError) as e:
+                is_rl = (
+                    isinstance(e, RateLimitError)
+                    or getattr(e, "status_code", None) == 429
+                    or "rate_limit" in str(e).lower()
+                )
+                if attempt == 0 and is_rl:
+                    wait_time = 20 + random.uniform(0, 2.0)
+                    logging.warning(f"Rate-limit hit (429). Waiting {wait_time:.2f}s then retrying.")
+                    await asyncio.sleep(wait_time)
+                    continue
+                logging.error(f"OpenAI API error: {e}")
+                raise HTTPException(status_code=502, detail="Error communicating with the OpenAI API.")
+        
+        if not completion:
+            raise HTTPException(status_code=502, detail="OpenAI request failed.")
+        
+        # Check for function tool calls in the response
+        tool_calls = []
+        for item in (completion.output or []):
+            item_type = getattr(item, "type", None)
+            if item_type == "function_call":
+                tool_calls.append(item)
+        
+        if not tool_calls:
+            # No tool calls, we have the final response
+            break
+        
+        # Execute tool calls and prepare for next iteration
+        logging.info(f"Processing {len(tool_calls)} web search tool call(s) in iteration {tool_iteration}")
+        
+        # Use previous_response_id for conversation threading
+        if hasattr(completion, "id") and completion.id:
+            base_request = {
+                "model": model,
+                "text": {"format": json_schema_format},
+                "tools": tools,
+                "store": False,
+                "previous_response_id": completion.id,
+                "input": [],
+            }
+            if model.startswith("o"):
+                base_request["reasoning"] = {"effort": effort}
+            
+            for tc in tool_calls:
+                func_name = getattr(tc, "name", "")
+                call_id = getattr(tc, "call_id", "")
+                args_str = getattr(tc, "arguments", "{}")
+                
+                try:
+                    args = json.loads(args_str) if args_str else {}
+                except json.JSONDecodeError:
+                    args = {}
+                
+                # Execute the tool
+                tool_result = await _execute_web_search_tool(func_name, args, tool_config)
+                
+                # Add tool result to input
+                base_request["input"].append({
+                    "type": "function_call_output",
+                    "call_id": call_id,
+                    "output": tool_result
+                })
+                
+                logging.info(f"Executed web search tool {func_name}, result length: {len(tool_result)}")
+        else:
+            logging.warning("No response ID available, breaking tool call loop")
+            break
+    
+    # Parse and return the final response
+    return _parse_completion_response(completion, response_format, cache_key)
+
+
+def _parse_completion_response(completion, response_format: BaseModel, cache_key: str):
+    """Parse completion response and return structured output."""
+    if completion and completion.output and len(completion.output) > 0:
+        raw_text = None
+        for out in completion.output:
+            if out.type == "message" and out.content:
+                for content_item in out.content:
+                    if hasattr(content_item, "text"):
+                        raw_text = content_item.text
+                        break
+                    else:
+                        logging.warning("request refused: %s", str(content_item))
+                        return "Request refused.", "FAIL"
+                if raw_text:
+                    break
+
+        if not raw_text or not raw_text.strip():
+            return "No text returned (possibly refusal or empty response)", "FAIL"
+
+        try:
+            parsed_obj = response_format.parse_raw(raw_text)
+            cache_output_tools.cache_output(
+                "get_structured_output_internal", cache_key, parsed_obj.json()
+            )
+            return parsed_obj, "SUCCESS"
+
+        except Exception:
+            logging.warning("ERROR: Could not parse JSON from model output.")
+            try:
+                fixed_json = repair_json(raw_text)
+                parsed_obj = response_format.parse_raw(fixed_json)
+                cache_output_tools.cache_output(
+                    "get_structured_output_internal", cache_key, parsed_obj.json()
+                )
+                return parsed_obj, "SUCCESS"
+            except Exception as e2:
+                logging.warning("JSON repair failed: %s", str(e2))
+                return raw_text, "FAIL"
+    else:
+        return "No output returned", "FAIL"
+
+
 
 async def get_structured_output_with_mcp(
     prompt: str,

{dhisana-0.0.1.dev265 → dhisana-0.0.1.dev267}/src/dhisana/utils/mailgun_tools.py

@@ -1,4 +1,3 @@
-import asyncio
 import logging
 import os
 from typing import Optional, List, Dict
@@ -21,7 +20,7 @@ def get_mailgun_notify_key(tool_config: Optional[List[Dict]] = None) -> str:
     if tool_config:
         cfg = next((item for item in tool_config if item.get("name") == "mailgun"), None)
         if cfg:
-            cfg_map = {i["name"]: i["value"] for i in cfg.get("configuration", []) if i}
+            cfg_map = {i.get("name"): i.get("value") for i in cfg.get("configuration", []) if i}
             key = cfg_map.get("apiKey")
     key = key or os.getenv("MAILGUN_NOTIFY_KEY")
     if not key:
@@ -43,7 +42,7 @@ def get_mailgun_notify_domain(tool_config: Optional[List[Dict]] = None) -> str:
     if tool_config:
         cfg = next((item for item in tool_config if item.get("name") == "mailgun"), None)
         if cfg:
-            cfg_map = {i["name"]: i["value"] for i in cfg.get("configuration", []) if i}
+            cfg_map = {i.get("name"): i.get("value") for i in cfg.get("configuration", []) if i}
             domain = cfg_map.get("domain") or cfg_map.get("notifyDomain")
     domain = domain or os.getenv("MAILGUN_DOMAIN") or os.getenv("MAILGUN_NOTIFY_DOMAIN")
     if not domain:
@@ -96,11 +95,15 @@ async def send_email_with_mailgun(
                 # Try to return JSON payload if available
                 try:
                     return await response.json()
-                except Exception:
+                except Exception as parse_ex:
+                    logging.debug(f"Could not parse Mailgun response as JSON: {parse_ex}")
                     return await response.text()
-    except Exception as ex:
+    except (aiohttp.ClientError, ValueError) as ex:
         logging.warning(f"Error sending email via Mailgun: {ex}")
         return {"error": str(ex)}
+    except Exception as ex:
+        logging.exception(f"Unexpected error sending email via Mailgun: {ex}")
+        raise
 
 
 async def send_email_using_mailgun_async(
@@ -147,10 +150,10 @@ async def send_email_using_mailgun_async(
                 raise RuntimeError(f"Mailgun send failed: {detail}")
             try:
                 payload = await response.json()
-            except Exception:
+            except Exception as parse_ex:
+                logging.debug(f"Could not parse Mailgun response as JSON: {parse_ex}")
                 payload = {"message": await response.text()}
 
     # Normalise return value akin to other providers
     msg_id = payload.get("id") if isinstance(payload, dict) else None
-    await asyncio.sleep(20)
     return msg_id or str(payload)

{dhisana-0.0.1.dev265 → dhisana-0.0.1.dev267}/src/dhisana/utils/sendgrid_tools.py

@@ -119,13 +119,17 @@ async def send_email_with_sendgrid(
                 headers=headers,
                 json=payload,
             ) as response:
-                # SendGrid returns 202 Accepted on success with empty body
+                # SendGrid returns 202 Accepted on success with empty body but includes X-Message-Id header
                 if response.status == 202:
-                    return {"status": 202, "message": "accepted"}
+                    message_id = response.headers.get("X-Message-Id")
+                    if not message_id:
+                        logging.warning("SendGrid did not return X-Message-Id header")
+                    return {"status": 202, "message": "accepted", "message_id": message_id}
                 # On error, try to parse JSON for helpful message
                 try:
                     err = await response.json()
-                except Exception:
+                except Exception as parse_ex:
+                    logging.debug(f"Could not parse SendGrid error as JSON: {parse_ex}")
                     err = {"text": await response.text()}
                 return {"error": err, "status": response.status}
     except Exception as ex:
@@ -139,12 +143,8 @@ async def send_email_using_sendgrid_async(
 ) -> str:
     """
     Provider-style wrapper for SendGrid using SendEmailContext.
-    Returns an opaque token since SendGrid does not return a message id.
+    Returns the message ID from SendGrid's X-Message-Id response header.
     """
-    plain_body, html_body, _ = body_variants(
-        ctx.body,
-        getattr(ctx, "body_format", None),
-    )
     result = await send_email_with_sendgrid(
         sender=f"{ctx.sender_name} <{ctx.sender_email}>",
         recipients=[ctx.recipient],
@@ -156,6 +156,10 @@ async def send_email_using_sendgrid_async(
     )
     # Normalise output to a string id-like value
     if isinstance(result, dict) and result.get("status") == 202:
+        message_id = result.get("message_id")
+        if message_id:
+            return message_id
+        # Fallback if header wasn't present (shouldn't happen)
         return f"sent:{ctx.sender_email}:{ctx.recipient}:{ctx.subject}"
     if isinstance(result, dict) and "error" in result:
         raise RuntimeError(f"SendGrid send failed: {result['error']}")

{dhisana-0.0.1.dev265 → dhisana-0.0.1.dev267}/src/dhisana.egg-info/PKG-INFO

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