dhisana 0.0.1.dev207__py3-none-any.whl → 0.0.1.dev209__py3-none-any.whl

dhisana/utils/email_provider.py

@@ -17,6 +17,11 @@ from dhisana.utils.google_workspace_tools import (
     list_emails_in_time_range_async,
     reply_to_email_async as gw_reply_to_email_async,
 )
+from dhisana.utils.google_oauth_tools import (
+    send_email_using_google_oauth_async,
+    list_emails_in_time_range_google_oauth_async,
+    reply_to_email_google_oauth_async,
+)
 from dhisana.utils.microsoft365_tools import (
     send_email_using_microsoft_graph_async,
     list_emails_in_time_range_m365_async,
@@ -105,7 +110,14 @@ async def send_email_async(
     send_email_context: SendEmailContext,
     tool_config: Optional[List[Dict]] = None,
     *,
-    provider_order: Sequence[str] = ("mailgun", "sendgrid", "smtpEmail", "googleworkspace", "microsoft365"),
+    provider_order: Sequence[str] = (
+        "mailgun",
+        "sendgrid",
+        "google",          # Google OAuth (per-user token)
+        "smtpEmail",
+        "googleworkspace", # Google Workspace service account (DWD)
+        "microsoft365",
+    ),
 ):
     """
     Send an e-mail using the first *configured* provider in *provider_order*.
@@ -154,15 +166,12 @@ async def send_email_async(
                 continue
             return await send_email_using_sendgrid_async(send_email_context, tool_config)
 
-        # 1d) Microsoft 365 (Graph API)
-        elif provider == "microsoft365":
-            ms_cfg = _find_provider_cfg(tool_config, "microsoft365")
-            if not ms_cfg:
+        # 1d) Google (Gmail API via per-user OAuth)
+        elif provider == "google":
+            g_cfg = _find_provider_cfg(tool_config, "google")
+            if not g_cfg:
                 continue
-
-            return await send_email_using_microsoft_graph_async(
-                send_email_context, tool_config
-            )
+            return await send_email_using_google_oauth_async(send_email_context, tool_config)
 
         # 1e) Google Workspace
         elif provider == "googleworkspace":
@@ -174,6 +183,16 @@ async def send_email_async(
                 send_email_context, tool_config
             )
 
+        # 1f) Microsoft 365 (Graph API)
+        elif provider == "microsoft365":
+            ms_cfg = _find_provider_cfg(tool_config, "microsoft365")
+            if not ms_cfg:
+                continue
+
+            return await send_email_using_microsoft_graph_async(
+                send_email_context, tool_config
+            )
+
         # -- future providers slot --------------------------------------
 
     # ------------------------------------------------------------------ #
@@ -230,7 +249,7 @@ async def list_emails_async(
     query_email_context: QueryEmailContext,
     tool_config: Optional[List[Dict]] = None,
     *,
-    provider_order: Sequence[str] = ("smtpEmail", "googleworkspace", "microsoft365"),
+    provider_order: Sequence[str] = ("google", "smtpEmail", "googleworkspace", "microsoft365"),
 ) -> List[MessageItem]:
     """
     List e-mails (see ``QueryEmailContext``) using the first configured provider.
@@ -255,6 +274,12 @@ async def list_emails_async(
                 password=creds["password"],
             )
 
+        elif provider == "google":
+            g_cfg = _find_provider_cfg(tool_config, "google")
+            if not g_cfg:
+                continue
+            return await list_emails_in_time_range_google_oauth_async(query_email_context, tool_config)
+
         elif provider == "googleworkspace":
             gw_cfg = _find_provider_cfg(tool_config, "googleworkspace")
             if not gw_cfg:
@@ -279,7 +304,7 @@ async def reply_email_async(
     reply_email_context: ReplyEmailContext,
     tool_config: Optional[List[Dict]] = None,
     *,
-    provider_order: Sequence[str] = ("smtpEmail", "googleworkspace", "microsoft365"),
+    provider_order: Sequence[str] = ("google", "smtpEmail", "googleworkspace", "microsoft365"),
 ) -> Dict[str, Any]:
     """
     Reply (reply-all) to an e-mail using the first *configured* provider
@@ -312,7 +337,17 @@ async def reply_email_async(
             )
 
         # ------------------------------------------------------------------
-        # 2) Google Workspace service-account
+        # 2) Google OAuth (per-user)
+        # ------------------------------------------------------------------
+        elif provider == "google":
+            g_cfg = _find_provider_cfg(tool_config, "google")
+            if not g_cfg:
+                continue
+
+            return await reply_to_email_google_oauth_async(reply_email_context, tool_config)
+
+        # ------------------------------------------------------------------
+        # 3) Google Workspace service-account
         # ------------------------------------------------------------------
         elif provider == "googleworkspace":
             gw_cfg = _find_provider_cfg(tool_config, "googleworkspace")
@@ -322,7 +357,7 @@ async def reply_email_async(
             return await gw_reply_to_email_async(reply_email_context, tool_config)
 
         # ------------------------------------------------------------------
-        # 3) Microsoft 365 (Graph)
+        # 4) Microsoft 365 (Graph)
         # ------------------------------------------------------------------
         elif provider == "microsoft365":
             ms_cfg = _find_provider_cfg(tool_config, "microsoft365")

dhisana/utils/google_oauth_tools.py

@@ -0,0 +1,455 @@
+import base64
+import json
+import logging
+import re
+from email.mime.text import MIMEText
+from typing import Any, Dict, List, Optional
+
+import httpx
+
+from dhisana.schemas.common import (
+    SendEmailContext,
+    QueryEmailContext,
+    ReplyEmailContext,
+)
+from dhisana.schemas.sales import MessageItem
+from dhisana.utils.email_parse_helpers import (
+    find_header,
+    parse_single_address,
+    find_all_recipients_in_headers,
+    convert_date_to_iso,
+    extract_email_body_in_plain_text,
+)
+from dhisana.utils.assistant_tool_tag import assistant_tool
+from dhisana.utils.cache_output_tools import retrieve_output, cache_output
+from typing import Optional as _Optional  # avoid name clash in wrappers
+
+
+def get_google_access_token(tool_config: Optional[List[Dict]] = None) -> str:
+    """
+    Retrieve a Google OAuth2 access token from the 'google' integration config.
+
+    Expected tool_config shape:
+        {
+          "name": "google",
+          "configuration": [
+            {"name": "oauth_tokens", "value": {"access_token": "..."} }
+            # or {"name": "access_token", "value": "..."}
+          ]
+        }
+
+    If provided as a JSON string under oauth_tokens, it is parsed.
+    """
+    access_token: Optional[str] = None
+
+    if tool_config:
+        g_cfg = next((c for c in tool_config if c.get("name") == "google"), None)
+        if g_cfg:
+            cfg_map = {f["name"]: f.get("value") for f in g_cfg.get("configuration", []) if f}
+            raw_oauth = cfg_map.get("oauth_tokens")
+            # oauth_tokens might be a JSON string or a dict
+            if isinstance(raw_oauth, str):
+                try:
+                    raw_oauth = json.loads(raw_oauth)
+                except Exception:
+                    raw_oauth = None
+            if isinstance(raw_oauth, dict):
+                access_token = raw_oauth.get("access_token") or raw_oauth.get("token")
+            if not access_token:
+                access_token = cfg_map.get("access_token")
+
+    if not access_token:
+        raise ValueError(
+            "Google integration is not configured. Please connect Google and supply an OAuth access token."
+        )
+    return access_token
+
+
+async def send_email_using_google_oauth_async(
+    send_email_context: SendEmailContext,
+    tool_config: Optional[List[Dict]] = None,
+) -> str:
+    """
+    Send an email using Gmail API with a per-user OAuth2 token.
+
+    Returns the Gmail message id of the sent message when available.
+    """
+    token = get_google_access_token(tool_config)
+
+    message = MIMEText(send_email_context.body, _subtype="html")
+    message["to"] = send_email_context.recipient
+    message["from"] = f"{send_email_context.sender_name} <{send_email_context.sender_email}>"
+    message["subject"] = send_email_context.subject
+
+    raw_message = base64.urlsafe_b64encode(message.as_bytes()).decode()
+
+    payload: Dict[str, Any] = {"raw": raw_message}
+    if send_email_context.labels:
+        payload["labelIds"] = send_email_context.labels
+
+    headers = {"Authorization": f"Bearer {token}", "Content-Type": "application/json"}
+    url = "https://gmail.googleapis.com/gmail/v1/users/me/messages/send"
+
+    async with httpx.AsyncClient(timeout=30) as client:
+        resp = await client.post(url, headers=headers, json=payload)
+        resp.raise_for_status()
+        data = resp.json() or {}
+        return data.get("id", "")
+
+
+async def list_emails_in_time_range_google_oauth_async(
+    context: QueryEmailContext,
+    tool_config: Optional[List[Dict]] = None,
+) -> List[MessageItem]:
+    """
+    List Gmail messages for the connected user in a time range using OAuth2.
+    Returns a list of MessageItem.
+    """
+    if context.labels is None:
+        context.labels = []
+
+    token = get_google_access_token(tool_config)
+    base_url = "https://gmail.googleapis.com/gmail/v1/users/me/messages"
+    headers = {"Authorization": f"Bearer {token}"}
+
+    # Convert RFC3339 times to unix timestamps for Gmail search query
+    # Expecting context.start_time and context.end_time as ISO 8601; Gmail q uses epoch seconds
+    from datetime import datetime
+    start_dt = datetime.fromisoformat(context.start_time.replace("Z", "+00:00"))
+    end_dt = datetime.fromisoformat(context.end_time.replace("Z", "+00:00"))
+    after_ts = int(start_dt.timestamp())
+    before_ts = int(end_dt.timestamp())
+
+    q_parts: List[str] = [f"after:{after_ts}", f"before:{before_ts}"]
+    if context.unread_only:
+        q_parts.append("is:unread")
+    if context.labels:
+        q_parts.extend([f"label:{lbl}" for lbl in context.labels])
+    query = " ".join(q_parts)
+
+    params = {"q": query}
+
+    items: List[MessageItem] = []
+    async with httpx.AsyncClient(timeout=30) as client:
+        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),
+                )
+            )
+
+    return items
+
+
+async def reply_to_email_google_oauth_async(
+    reply_email_context: ReplyEmailContext,
+    tool_config: Optional[List[Dict]] = None,
+) -> Dict[str, Any]:
+    """
+    Reply-all to a Gmail message for the connected user using OAuth2.
+    Returns a metadata dictionary similar to other providers.
+    """
+    if reply_email_context.add_labels is None:
+        reply_email_context.add_labels = []
+
+    token = get_google_access_token(tool_config)
+    headers = {"Authorization": f"Bearer {token}", "Content-Type": "application/json"}
+    base = "https://gmail.googleapis.com/gmail/v1/users/me"
+
+    # 1) Fetch original message
+    get_url = f"{base}/messages/{reply_email_context.message_id}"
+    params = {"format": "full"}
+    async with httpx.AsyncClient(timeout=30) as client:
+        get_resp = await client.get(get_url, headers=headers, params=params)
+        get_resp.raise_for_status()
+        original = get_resp.json() or {}
+
+    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 ""
+    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 ""
+
+    # 2) Build reply MIME
+    msg = MIMEText(reply_email_context.reply_body, _subtype="html")
+    msg["To"] = to_addresses
+    if cc_addresses:
+        msg["Cc"] = cc_addresses
+    msg["From"] = f"{reply_email_context.sender_name} <{reply_email_context.sender_email}>"
+    msg["Subject"] = subject
+    if message_id_header:
+        msg["In-Reply-To"] = message_id_header
+        msg["References"] = message_id_header
+
+    raw_message = base64.urlsafe_b64encode(msg.as_bytes()).decode()
+    payload = {"raw": raw_message}
+    if thread_id:
+        payload["threadId"] = thread_id
+
+    # 3) Send the reply
+    send_url = f"{base}/messages/send"
+    async with httpx.AsyncClient(timeout=30) as client:
+        send_resp = await client.post(send_url, headers=headers, json=payload)
+        send_resp.raise_for_status()
+        sent = send_resp.json() or {}
+
+    # 4) Optional: mark as read
+    if str(reply_email_context.mark_as_read).lower() == "true" and thread_id:
+        modify_url = f"{base}/threads/{thread_id}/modify"
+        modify_payload = {"removeLabelIds": ["UNREAD"]}
+        try:
+            async with httpx.AsyncClient(timeout=30) as client:
+                await client.post(modify_url, headers=headers, json=modify_payload)
+        except Exception:
+            logging.exception("Gmail: failed to mark thread as read (best-effort)")
+
+    # 5) Optional: add labels
+    if reply_email_context.add_labels and thread_id:
+        modify_url = f"{base}/threads/{thread_id}/modify"
+        modify_payload = {"addLabelIds": reply_email_context.add_labels}
+        try:
+            async with httpx.AsyncClient(timeout=30) as client:
+                await client.post(modify_url, headers=headers, json=modify_payload)
+        except Exception:
+            logging.exception("Gmail: failed to add labels to thread (best-effort)")
+
+    return {
+        "mailbox_email_id": sent.get("id"),
+        "message_id": (sent.get("threadId") or thread_id or ""),
+        "email_subject": subject,
+        "email_sender": reply_email_context.sender_email,
+        "email_recipients": [to_addresses] + ([cc_addresses] if cc_addresses else []),
+        "read_email_status": "READ" if str(reply_email_context.mark_as_read).lower() == "true" else "UNREAD",
+        "email_labels": sent.get("labelIds", []),
+    }
+
+
+# ---------------------------------------------------------------------------
+# Google Calendar (OAuth per-user)
+# ---------------------------------------------------------------------------
+
+@assistant_tool
+async def get_calendar_events_using_google_oauth_async(
+    start_date: str,
+    end_date: str,
+    tool_config: Optional[List[Dict]] = None,
+) -> List[Dict[str, Any]]:
+    """
+    Retrieve events from the user's primary Google Calendar using a per-user OAuth token.
+
+    start_date, end_date: 'YYYY-MM-DD' strings (inclusive start, inclusive end day as 23:59:59Z).
+    Returns a list of event dicts from the Calendar API.
+    """
+    token = get_google_access_token(tool_config)
+    headers = {"Authorization": f"Bearer {token}"}
+    url = "https://www.googleapis.com/calendar/v3/calendars/primary/events"
+
+    time_min = f"{start_date}T00:00:00Z"
+    time_max = f"{end_date}T23:59:59Z"
+    params = {
+        "timeMin": time_min,
+        "timeMax": time_max,
+        "maxResults": 10,
+        "singleEvents": True,
+        "orderBy": "startTime",
+    }
+
+    async with httpx.AsyncClient(timeout=30) as client:
+        resp = await client.get(url, headers=headers, params=params)
+        resp.raise_for_status()
+        data = resp.json() or {}
+        events = data.get("items", [])
+        if not events:
+            logging.info("No upcoming events found within the specified range (OAuth).")
+        return events
+
+
+# ---------------------------------------------------------------------------
+# Google Sheets and Docs (OAuth per-user)
+# ---------------------------------------------------------------------------
+
+def _get_sheet_id_from_url(sheet_url: str) -> str:
+    match = re.search(r"/d/([a-zA-Z0-9-_]+)/", sheet_url)
+    if not match:
+        raise ValueError("Could not extract spreadsheet ID from the provided URL.")
+    return match.group(1)
+
+
+def _get_document_id_from_url(doc_url: str) -> str:
+    match = re.search(r"/d/([a-zA-Z0-9-_]+)/", doc_url)
+    if not match:
+        raise ValueError("Could not extract document ID from the provided URL.")
+    return match.group(1)
+
+
+@assistant_tool
+async def read_google_sheet_using_google_oauth(
+    sheet_url: str,
+    range_name: str,
+    tool_config: Optional[List[Dict]] = None,
+) -> List[List[str]]:
+    """
+    Read data from a Google Sheet using the connected user's OAuth token.
+
+    If range_name is empty, reads the first sheet tab by fetching spreadsheet metadata.
+    """
+    token = get_google_access_token(tool_config)
+    headers = {"Authorization": f"Bearer {token}"}
+
+    spreadsheet_id = _get_sheet_id_from_url(sheet_url)
+
+    # Default range to first sheet title if not supplied
+    if not range_name:
+        meta_url = f"https://sheets.googleapis.com/v4/spreadsheets/{spreadsheet_id}"
+        async with httpx.AsyncClient(timeout=30) as client:
+            meta_resp = await client.get(meta_url, headers=headers)
+            meta_resp.raise_for_status()
+            meta = meta_resp.json() or {}
+            sheets = meta.get("sheets", [])
+            if not sheets:
+                return []
+            range_name = (sheets[0].get("properties") or {}).get("title") or "Sheet1"
+
+    values_url = f"https://sheets.googleapis.com/v4/spreadsheets/{spreadsheet_id}/values/{range_name}"
+    async with httpx.AsyncClient(timeout=30) as client:
+        val_resp = await client.get(values_url, headers=headers)
+        val_resp.raise_for_status()
+        data = val_resp.json() or {}
+        return data.get("values", [])
+
+
+@assistant_tool
+async def read_google_document_using_google_oauth(
+    doc_url: str,
+    tool_config: Optional[List[Dict]] = None,
+) -> str:
+    """
+    Read text content from a Google Doc using the connected user's OAuth token.
+    Concatenates all text runs in the document body.
+    """
+    token = get_google_access_token(tool_config)
+    headers = {"Authorization": f"Bearer {token}"}
+
+    document_id = _get_document_id_from_url(doc_url)
+    url = f"https://docs.googleapis.com/v1/documents/{document_id}"
+
+    async with httpx.AsyncClient(timeout=30) as client:
+        resp = await client.get(url, headers=headers)
+        resp.raise_for_status()
+        doc = resp.json() or {}
+
+    content = (doc.get("body") or {}).get("content", [])
+    parts: List[str] = []
+    for element in content:
+        paragraph = element.get("paragraph")
+        if not paragraph:
+            continue
+        for elem in paragraph.get("elements", []) or []:
+            text_run = elem.get("textRun")
+            if text_run:
+                parts.append(text_run.get("content", ""))
+
+    return "".join(parts)
+
+
+@assistant_tool
+async def search_google_places_using_google_oauth(
+    query: str,
+    location_bias: dict = None,
+    number_of_results: int = 3,
+    tool_config: _Optional[List[Dict]] = None,
+) -> List[str]:
+    """
+    Search Google Places (New) with a per-user OAuth token.
+
+    - Requires that the OAuth token has Maps/Places access enabled for the project.
+    - Returns a list of JSON strings, each being a place object.
+    """
+    
+
+    token = get_google_access_token(tool_config)
+    url = "https://places.googleapis.com/v1/places:searchText"
+    headers = {
+        "Content-Type": "application/json",
+        "Authorization": f"Bearer {token}",
+        # Field mask is required to limit returned fields
+        "X-Goog-FieldMask": (
+            "places.displayName,places.formattedAddress,places.location,"
+            "places.websiteUri,places.rating,places.reviews"
+        ),
+    }
+
+    body: Dict[str, Any] = {"textQuery": query}
+    if location_bias:
+        body["locationBias"] = {
+            "circle": {
+                "center": {
+                    "latitude": location_bias.get("latitude"),
+                    "longitude": location_bias.get("longitude"),
+                },
+                "radius": location_bias.get("radius", 5000),
+            }
+        }
+
+    # Cache key based on query, count and bias
+    bias_str = json.dumps(location_bias, sort_keys=True) if location_bias else "None"
+    cache_key = f"oauth_places:{query}:{number_of_results}:{bias_str}"
+    cached = retrieve_output("search_google_places_oauth", cache_key)
+    if cached is not None:
+        return cached
+
+    async with httpx.AsyncClient(timeout=30) as client:
+        try:
+            resp = await client.post(url, headers=headers, json=body)
+            if resp.status_code == 429:
+                return [json.dumps({"error": "Rate limit exceeded (429)"})]
+            resp.raise_for_status()
+            data = resp.json() or {}
+            places = (data.get("places") or [])[: max(0, int(number_of_results))]
+            out = [json.dumps(p) for p in places]
+            cache_output("search_google_places_oauth", cache_key, out)
+            return out
+        except httpx.HTTPStatusError as exc:
+            try:
+                err_json = exc.response.json()
+            except Exception:
+                err_json = {"status": exc.response.status_code, "text": exc.response.text}
+            logging.warning(f"Places OAuth request failed: {err_json}")
+            return [json.dumps({"error": err_json})]
+        except Exception as e:
+            logging.exception("Places OAuth request failed")
+            return [json.dumps({"error": str(e)})]

{dhisana-0.0.1.dev207.dist-info → dhisana-0.0.1.dev209.dist-info}/METADATA

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

{dhisana-0.0.1.dev207.dist-info → dhisana-0.0.1.dev209.dist-info}/RECORD

@@ -30,7 +30,7 @@ dhisana/utils/composite_tools.py,sha256=ZlwHCp7PXjYFUWUEeR_fTF0Z4Wg-4F6eBi1reE3F
 dhisana/utils/dataframe_tools.py,sha256=jxyvyXAMKxccST_W6o6FnBqAsvp7mGNOD6HV5V6xgeA,9242
 dhisana/utils/domain_parser.py,sha256=Kw5MPP06wK2azWQzuSiOE-DffOezLqDyF-L9JEBsMSU,1206
 dhisana/utils/email_parse_helpers.py,sha256=LIdm1B1IyGSW50y8EkxOk6YRjvxO2SJTgTKPLxYls_o,4613
-dhisana/utils/email_provider.py,sha256=8V-hqBDStRl0Ui73pOYxPxtkJ2JzvpHSZ88Y21QC2xM,12936
+dhisana/utils/email_provider.py,sha256=oYjk-9yIgRzcPoPwnYjPvChPn0J78T5p6CoqXFPI-zk,14264
 dhisana/utils/enrich_lead_information.py,sha256=hZxSstIErqxXG40j5YyzTYTCSsTEf8YxRF25DU5-s2k,37302
 dhisana/utils/extract_email_content_for_llm.py,sha256=SQmMZ3YJtm3ZI44XiWEVAItcAwrsSSy1QzDne7LTu_Q,3713
 dhisana/utils/fetch_openai_config.py,sha256=LjWdFuUeTNeAW106pb7DLXZNElos2PlmXRe6bHZJ2hw,5159
@@ -45,6 +45,7 @@ dhisana/utils/generate_linkedin_connect_message.py,sha256=eL4RV2B1ByyMnjoGohdTA0
 dhisana/utils/generate_linkedin_response_message.py,sha256=udAt4V_vNuieyyfhrtTFWA1CiBx63jfac9E35wunS5k,14404
 dhisana/utils/generate_structured_output_internal.py,sha256=83SaThDAa_fANJEZ5CSCMcPpD_MN5zMI9NU1uEtQO2E,20705
 dhisana/utils/google_custom_search.py,sha256=5rQ4uAF-hjFpd9ooJkd6CjRvSmhZHhqM0jfHItsbpzk,10071
+dhisana/utils/google_oauth_tools.py,sha256=KoiNiC8iLh2CGslgQi5drHgjjO-lswLkZmkPfmtJL2U,17238
 dhisana/utils/google_workspace_tools.py,sha256=22mmJ2KyJAx4Ewo_AK2qDLF5veYcB7sWcb00vw21qhM,44727
 dhisana/utils/hubspot_clearbit.py,sha256=keNX1F_RnDl9AOPxYEOTMdukV_A9g8v9j1fZyT4tuP4,3440
 dhisana/utils/hubspot_crm_tools.py,sha256=lbXFCeq690_TDLjDG8Gm5E-2f1P5EuDqNf5j8PYpMm8,99298
@@ -91,8 +92,8 @@ dhisana/workflow/agent.py,sha256=esv7_i_XuMkV2j1nz_UlsHov_m6X5WZZiZm_tG4OBHU,565
 dhisana/workflow/flow.py,sha256=xWE3qQbM7j2B3FH8XnY3zOL_QXX4LbTW4ArndnEYJE0,1638
 dhisana/workflow/task.py,sha256=HlWz9mtrwLYByoSnePOemBUBrMEcj7KbgNjEE1oF5wo,1830
 dhisana/workflow/test.py,sha256=kwW8jWqSBNcRmoyaxlTuZCMOpGJpTbJQgHI7gSjwdzM,3399
-dhisana-0.0.1.dev207.dist-info/METADATA,sha256=-mLeUCfVXuCVO85-0ixPwHSWJlbOYpW-NVu780s3A2w,1190
-dhisana-0.0.1.dev207.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-dhisana-0.0.1.dev207.dist-info/entry_points.txt,sha256=jujxteZmNI9EkEaK-pOCoWuBujU8TCevdkfl9ZcKHek,49
-dhisana-0.0.1.dev207.dist-info/top_level.txt,sha256=NETTHt6YifG_P7XtRHbQiXZlgSFk9Qh9aR-ng1XTf4s,8
-dhisana-0.0.1.dev207.dist-info/RECORD,,
+dhisana-0.0.1.dev209.dist-info/METADATA,sha256=RLMggAC3XyqdtE58kUr7gC1pBpv2TEN_RGTXfOjRUh4,1190
+dhisana-0.0.1.dev209.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+dhisana-0.0.1.dev209.dist-info/entry_points.txt,sha256=jujxteZmNI9EkEaK-pOCoWuBujU8TCevdkfl9ZcKHek,49
+dhisana-0.0.1.dev209.dist-info/top_level.txt,sha256=NETTHt6YifG_P7XtRHbQiXZlgSFk9Qh9aR-ng1XTf4s,8
+dhisana-0.0.1.dev209.dist-info/RECORD,,