arcade-google 0.1.5__py3-none-any.whl → 1.2.4__py3-none-any.whl

arcade_google/tools/__init__.py

@@ -1 +1,96 @@
-__all__ = ["gmail", "calendar", "drive", "docs"]
+from arcade_google.tools.calendar import (
+    create_event,
+    delete_event,
+    find_time_slots_when_everyone_is_free,
+    list_calendars,
+    list_events,
+    update_event,
+)
+from arcade_google.tools.contacts import (
+    create_contact,
+    search_contacts_by_email,
+    search_contacts_by_name,
+)
+from arcade_google.tools.docs import (
+    create_blank_document,
+    create_document_from_text,
+    get_document_by_id,
+    insert_text_at_end_of_document,
+)
+from arcade_google.tools.drive import (
+    get_file_tree_structure,
+    search_and_retrieve_documents,
+    search_documents,
+)
+from arcade_google.tools.file_picker import generate_google_file_picker_url
+from arcade_google.tools.gmail import (
+    change_email_labels,
+    create_label,
+    delete_draft_email,
+    get_thread,
+    list_draft_emails,
+    list_emails,
+    list_emails_by_header,
+    list_labels,
+    list_threads,
+    reply_to_email,
+    search_threads,
+    send_draft_email,
+    send_email,
+    trash_email,
+    update_draft_email,
+    write_draft_email,
+    write_draft_reply_email,
+)
+from arcade_google.tools.sheets import (
+    create_spreadsheet,
+    get_spreadsheet,
+    write_to_cell,
+)
+
+__all__ = [
+    # Google Calendar
+    create_event,
+    delete_event,
+    find_time_slots_when_everyone_is_free,
+    list_calendars,
+    list_events,
+    update_event,
+    # Google Contacts
+    create_contact,
+    search_contacts_by_email,
+    search_contacts_by_name,
+    # Google Docs
+    create_blank_document,
+    create_document_from_text,
+    get_document_by_id,
+    insert_text_at_end_of_document,
+    # Google Drive
+    "get_file_tree_structure",
+    "search_and_retrieve_documents",
+    "search_documents",
+    # Google File Picker
+    generate_google_file_picker_url,
+    # Google Gmail
+    change_email_labels,
+    create_label,
+    delete_draft_email,
+    get_thread,
+    list_draft_emails,
+    list_emails,
+    list_emails_by_header,
+    list_labels,
+    list_threads,
+    reply_to_email,
+    search_threads,
+    send_draft_email,
+    send_email,
+    trash_email,
+    update_draft_email,
+    write_draft_email,
+    write_draft_reply_email,
+    # Google Sheets
+    create_spreadsheet,
+    get_spreadsheet,
+    write_to_cell,
+]

arcade_google/tools/calendar.py

@@ -1,15 +1,65 @@
+import json
 from datetime import datetime, timedelta
-from typing import Annotated
+from typing import Annotated, Any
+from zoneinfo import ZoneInfo, ZoneInfoNotFoundError
 
-from google.oauth2.credentials import Credentials
-from googleapiclient.discovery import build
+from arcade_tdk import ToolContext, tool
+from arcade_tdk.auth import Google
+from arcade_tdk.errors import RetryableToolError
 from googleapiclient.errors import HttpError
 
-from arcade.sdk import ToolContext, tool
-from arcade.sdk.auth import Google
-from arcade.sdk.errors import RetryableToolError
-from arcade_google.tools.models import EventVisibility, SendUpdatesOptions
-from arcade_google.tools.utils import parse_datetime
+from arcade_google.models import EventVisibility, SendUpdatesOptions
+from arcade_google.utils import (
+    build_calendar_service,
+    build_oauth_service,
+    compute_free_time_intersection,
+    parse_datetime,
+)
+
+
+@tool(
+    requires_auth=Google(
+        scopes=[
+            "https://www.googleapis.com/auth/calendar.readonly",
+            "https://www.googleapis.com/auth/calendar.events",
+        ]
+    )
+)
+async def list_calendars(
+    context: ToolContext,
+    max_results: Annotated[
+        int, "The maximum number of calendars to return. Up to 250 calendars, defaults to 10."
+    ] = 10,
+    show_deleted: Annotated[bool, "Whether to show deleted calendars. Defaults to False"] = False,
+    show_hidden: Annotated[bool, "Whether to show hidden calendars. Defaults to False"] = False,
+    next_page_token: Annotated[
+        str | None, "The token to retrieve the next page of calendars. Optional."
+    ] = None,
+) -> Annotated[dict, "A dictionary containing the calendars accessible by the end user"]:
+    """
+    List all calendars accessible by the user.
+    """
+    max_results = max(1, min(max_results, 250))
+    service = build_calendar_service(context.get_auth_token_or_empty())
+    calendars = (
+        service.calendarList()
+        .list(
+            pageToken=next_page_token,
+            showDeleted=show_deleted,
+            showHidden=show_hidden,
+            maxResults=max_results,
+        )
+        .execute()
+    )
+
+    items = calendars.get("items", [])
+    keys = ["description", "id", "summary", "timeZone"]
+    relevant_items = [{k: i.get(k) for k in keys if i.get(k)} for i in items]
+    return {
+        "next_page_token": calendars.get("nextPageToken"),
+        "num_calendars": len(relevant_items),
+        "calendars": relevant_items,
+    }
 
 
 @tool(
@@ -44,7 +94,7 @@ async def create_event(
 ) -> Annotated[dict, "A dictionary containing the created event details"]:
     """Create a new event/meeting/sync/meetup in the specified calendar."""
 
-    service = build("calendar", "v3", credentials=Credentials(context.authorization.token))
+    service = build_calendar_service(context.get_auth_token_or_empty())
 
     # Get the calendar's time zone
     calendar = service.calendars().get(calendarId=calendar_id).execute()
@@ -54,7 +104,7 @@ async def create_event(
     start_dt = parse_datetime(start_datetime, time_zone)
     end_dt = parse_datetime(end_datetime, time_zone)
 
-    event = {
+    event: dict[str, Any] = {
         "summary": summary,
         "description": description,
         "location": location,
@@ -82,11 +132,13 @@ async def list_events(
     context: ToolContext,
     min_end_datetime: Annotated[
         str,
-        "Filter by events that end on or after this datetime in ISO 8601 format, e.g., '2024-09-15T09:00:00'.",
+        "Filter by events that end on or after this datetime in ISO 8601 format, "
+        "e.g., '2024-09-15T09:00:00'.",
     ],
     max_start_datetime: Annotated[
         str,
-        "Filter by events that start before this datetime in ISO 8601 format, e.g., '2024-09-16T17:00:00'.",
+        "Filter by events that start before this datetime in ISO 8601 format, "
+        "e.g., '2024-09-16T17:00:00'.",
     ],
     calendar_id: Annotated[str, "The ID of the calendar to list events from"] = "primary",
     max_results: Annotated[int, "The maximum number of events to return"] = 10,
@@ -98,14 +150,15 @@ async def list_events(
     max_start_datetime serves as the upper bound (exclusive) for an event's start time.
 
     For example:
-    If min_end_datetime is set to 2024-09-15T09:00:00 and max_start_datetime is set to 2024-09-16T17:00:00,
-    the function will return events that:
+    If min_end_datetime is set to 2024-09-15T09:00:00 and max_start_datetime
+    is set to 2024-09-16T17:00:00, the function will return events that:
     1. End after 09:00 on September 15, 2024 (exclusive)
     2. Start before 17:00 on September 16, 2024 (exclusive)
-    This means an event starting at 08:00 on September 15 and ending at 10:00 on September 15 would be included,
-    but an event starting at 17:00 on September 16 would not be included.
+    This means an event starting at 08:00 on September 15 and
+    ending at 10:00 on September 15 would be included, but an
+    event starting at 17:00 on September 16 would not be included.
     """
-    service = build("calendar", "v3", credentials=Credentials(context.authorization.token))
+    service = build_calendar_service(context.get_auth_token_or_empty())
 
     # Get the calendar's time zone
     calendar = service.calendars().get(calendarId=calendar_id).execute()
@@ -157,7 +210,7 @@ async def list_events(
 
 @tool(
     requires_auth=Google(
-        scopes=["https://www.googleapis.com/auth/calendar"],
+        scopes=["https://www.googleapis.com/auth/calendar.events"],
     )
 )
 async def update_event(
@@ -165,7 +218,8 @@ async def update_event(
     event_id: Annotated[str, "The ID of the event to update"],
     updated_start_datetime: Annotated[
         str | None,
-        "The updated datetime that the event starts in ISO 8601 format, e.g., '2024-12-31T15:30:00'.",
+        "The updated datetime that the event starts in ISO 8601 format, "
+        "e.g., '2024-12-31T15:30:00'.",
     ] = None,
     updated_end_datetime: Annotated[
         str | None,
@@ -180,26 +234,31 @@ async def update_event(
     updated_visibility: Annotated[EventVisibility | None, "The visibility of the event"] = None,
     attendee_emails_to_add: Annotated[
         list[str] | None,
-        "The list of attendee emails to add. Must be valid email addresses e.g., username@domain.com.",
+        "The list of attendee emails to add. Must be valid email addresses "
+        "e.g., username@domain.com.",
     ] = None,
     attendee_emails_to_remove: Annotated[
         list[str] | None,
-        "The list of attendee emails to remove. Must be valid email addresses e.g., username@domain.com.",
+        "The list of attendee emails to remove. Must be valid email addresses "
+        "e.g., username@domain.com.",
     ] = None,
     send_updates: Annotated[
-        SendUpdatesOptions, "Should attendees be notified of the update? (none, all, external_only)"
+        SendUpdatesOptions,
+        "Should attendees be notified of the update? (none, all, external_only)",
     ] = SendUpdatesOptions.ALL,
 ) -> Annotated[
     str,
-    "A string containing the updated event details, including the event ID, update timestamp, and a link to view the updated event.",
+    "A string containing the updated event details, including the event ID, update timestamp, "
+    "and a link to view the updated event.",
 ]:
     """
     Update an existing event in the specified calendar with the provided details.
     Only the provided fields will be updated; others will remain unchanged.
 
-    `updated_start_datetime` and `updated_end_datetime` are independent and can be provided separately.
+    `updated_start_datetime` and `updated_end_datetime` are
+    independent and can be provided separately.
     """
-    service = build("calendar", "v3", credentials=Credentials(context.authorization.token))
+    service = build_calendar_service(context.get_auth_token_or_empty())
 
     calendar = service.calendars().get(calendarId="primary").execute()
     time_zone = calendar["timeZone"]
@@ -221,16 +280,21 @@ async def update_event(
         )
         raise RetryableToolError(
             f"Event with ID {event_id} not found.",
-            additional_prompt_content=f"Here is a list of valid events. The event_id parameter must match one of these: {valid_events_with_id}",
+            additional_prompt_content=(
+                f"Here is a list of valid events. The event_id parameter must match one of these: "
+                f"{valid_events_with_id}"
+            ),
             retry_after_ms=1000,
-            developer_message=f"Event with ID {event_id} not found. Please try again with a valid event ID.",
+            developer_message=(
+                f"Event with ID {event_id} not found. Please try again with a valid event ID."
+            ),
         )
 
     update_fields = {
-        "start": {"dateTime": updated_start_datetime.isoformat(), "timeZone": time_zone}
+        "start": {"dateTime": updated_start_datetime, "timeZone": time_zone}
         if updated_start_datetime
         else None,
-        "end": {"dateTime": updated_end_datetime.isoformat(), "timeZone": time_zone}
+        "end": {"dateTime": updated_end_datetime, "timeZone": time_zone}
         if updated_end_datetime
         else None,
         "calendarId": updated_calendar_id,
@@ -272,7 +336,10 @@ async def update_event(
         )
         .execute()
     )
-    return f"Event with ID {event_id} successfully updated at {updated_event['updated']}. View updated event at {updated_event['htmlLink']}"
+    return (
+        f"Event with ID {event_id} successfully updated at {updated_event['updated']}. "
+        f"View updated event at {updated_event['htmlLink']}"
+    )
 
 
 @tool(
@@ -289,7 +356,7 @@ async def delete_event(
     ] = SendUpdatesOptions.ALL,
 ) -> Annotated[str, "A string containing the deletion confirmation message"]:
     """Delete an event from Google Calendar."""
-    service = build("calendar", "v3", credentials=Credentials(context.authorization.token))
+    service = build_calendar_service(context.get_auth_token_or_empty())
 
     service.events().delete(
         calendarId=calendar_id, eventId=event_id, sendUpdates=send_updates.value
@@ -303,4 +370,141 @@ async def delete_event(
     elif send_updates == SendUpdatesOptions.NONE:
         notification_message = "No notifications were sent to attendees."
 
-    return f"Event with ID '{event_id}' successfully deleted from calendar '{calendar_id}'. {notification_message}"
+    return (
+        f"Event with ID '{event_id}' successfully deleted from calendar '{calendar_id}'. "
+        f"{notification_message}"
+    )
+
+
+# TODO: would be nice to have a "min_slot_duration" parameter
+# TODO: find a way to have "include_weekends" parameter without confusing LLMs
+@tool(
+    requires_auth=Google(
+        scopes=["https://www.googleapis.com/auth/calendar.readonly"],
+    ),
+)
+async def find_time_slots_when_everyone_is_free(
+    context: ToolContext,
+    email_addresses: Annotated[
+        list[str] | None,
+        "The list of email addresses from people in the same organization domain (apart from the "
+        "currently logged in user) to search for free time slots. Defaults to None, which will "
+        "return free time slots for the current user only.",
+    ] = None,
+    start_date: Annotated[
+        str | None,
+        "The start date to search for time slots in the format 'YYYY-MM-DD'. Defaults to today's "
+        "date. It will search starting from this date at the time 00:00:00.",
+    ] = None,
+    end_date: Annotated[
+        str | None,
+        "The end date to search for time slots in the format 'YYYY-MM-DD'. Defaults to seven days "
+        "from the start date. It will search until this date at the time 23:59:59.",
+    ] = None,
+    start_time_boundary: Annotated[
+        str,
+        "Will return free slots in any given day starting from this time in the format 'HH:MM'. "
+        "Defaults to '08:00', which is a usual business hour start time.",
+    ] = "08:00",
+    end_time_boundary: Annotated[
+        str,
+        "Will return free slots in any given day until this time in the format 'HH:MM'. "
+        "Defaults to '18:00', which is a usual business hour end time.",
+    ] = "18:00",
+) -> Annotated[
+    dict,
+    "A dictionary with the free slots and the timezone in which time slots are represented.",
+]:
+    """
+    Provides time slots when everyone is free within a given date range and time boundaries.
+    """
+
+    # Build google api services
+    oauth_service = build_oauth_service(context.get_auth_token_or_empty())
+    calendar_service = build_calendar_service(context.get_auth_token_or_empty())
+
+    email_addresses = email_addresses or []
+
+    if isinstance(email_addresses, str):
+        email_addresses = [email_addresses]
+
+    # Add the currently logged in user to the list of email addresses
+    user_info = oauth_service.userinfo().get().execute()
+    if user_info["email"] not in email_addresses:
+        email_addresses.append(user_info["email"])
+
+    # Get the timezone of the currently logged in user
+    calendar = calendar_service.calendars().get(calendarId="primary").execute()
+    timezone_name = calendar.get("timeZone")
+
+    try:
+        tz = ZoneInfo(timezone_name)
+    # If the calendar timezone name is not supported by Python's zoneinfo, use UTC
+    except ZoneInfoNotFoundError:
+        timezone_name = "UTC"
+        tz = ZoneInfo("UTC")
+
+    # Set default start and end dates, if not provided by the caller
+    start_date = start_date or datetime.now(tz=tz).date().isoformat()
+    end_date = end_date or (datetime.now(tz=tz).date() + timedelta(days=7)).isoformat()
+
+    # Parse start and end dates to datetime objects
+    start_datetime = datetime.strptime(start_date, "%Y-%m-%d").replace(
+        hour=0, minute=0, second=0, microsecond=0, tzinfo=tz
+    )
+    end_datetime = datetime.strptime(end_date, "%Y-%m-%d").replace(
+        hour=23, minute=59, second=59, microsecond=0, tzinfo=tz
+    )
+
+    # Get the busy slots from the calendars of the users
+    freebusy_response = (
+        calendar_service.freebusy()
+        .query(
+            body={
+                "timeMin": start_datetime.isoformat(),
+                "timeMax": end_datetime.isoformat(),
+                "timeZone": timezone_name,
+                "items": [{"id": email_address} for email_address in email_addresses],
+            }
+        )
+        .execute()
+    )
+    busy_slots = freebusy_response["calendars"]
+
+    response_errors = []
+
+    for email in email_addresses:
+        if "errors" not in busy_slots[email]:
+            continue
+        errors = busy_slots[email]["errors"]
+        for error in errors:
+            response_errors.append(
+                f"Error retrieving free slots from calendar of '{email}': "
+                f"{error.get('reason', 'not determined')}"
+            )
+
+    if response_errors:
+        raise RetryableToolError(
+            "Error retrieving free slots from calendars of one or more users.",
+            additional_prompt_content=json.dumps(response_errors),
+            retry_after_ms=1000,
+            developer_message="Error retrieving free slots from calendars of one or more users.",
+        )
+
+    # Compute the free slots
+    free_slots = compute_free_time_intersection(
+        busy_data=busy_slots,
+        global_start=start_datetime,
+        global_end=end_datetime,
+        start_time_boundary=datetime.strptime(start_time_boundary, "%H:%M")
+        .time()
+        .replace(tzinfo=tz),
+        end_time_boundary=datetime.strptime(end_time_boundary, "%H:%M").time().replace(tzinfo=tz),
+        include_weekends=True,
+        tz=tz,
+    )
+
+    return {
+        "free_slots": free_slots,
+        "timezone": timezone_name,
+    }

arcade_google/tools/contacts.py

@@ -0,0 +1,96 @@
+import asyncio
+from typing import Annotated
+
+from arcade_tdk import ToolContext, tool
+from arcade_tdk.auth import Google
+
+from arcade_google.constants import DEFAULT_SEARCH_CONTACTS_LIMIT
+from arcade_google.utils import build_people_service, search_contacts
+
+
+async def _warmup_cache(service) -> None:  # type: ignore[no-untyped-def]
+    """
+    Warm-up the search cache for contacts by sending a request with an empty query.
+    This ensures that the lazy cache is updated for both primary contacts and other contacts.
+    This is unfortunately a real thing: https://developers.google.com/people/v1/contacts#search_the_users_contacts
+    """
+    service.people().searchContacts(query="", pageSize=1, readMask="names,emailAddresses").execute()
+    await asyncio.sleep(3)  # TODO experiment with this value
+
+
+@tool(requires_auth=Google(scopes=["https://www.googleapis.com/auth/contacts.readonly"]))
+async def search_contacts_by_email(
+    context: ToolContext,
+    email: Annotated[str, "The email address to search for"],
+    limit: Annotated[
+        int | None,
+        "The maximum number of contacts to return (30 is the max allowed by Google API)",
+    ] = DEFAULT_SEARCH_CONTACTS_LIMIT,
+) -> Annotated[dict, "A dictionary containing the list of matching contacts"]:
+    """
+    Search the user's contacts in Google Contacts by email address.
+    """
+    service = build_people_service(context.get_auth_token_or_empty())
+    # Warm-up the cache before performing search.
+    # TODO: Ideally we should warmup only if this user (or google domain?) hasn't warmed up recently
+    await _warmup_cache(service)
+
+    return {"contacts": search_contacts(service, email, limit)}
+
+
+@tool(requires_auth=Google(scopes=["https://www.googleapis.com/auth/contacts.readonly"]))
+async def search_contacts_by_name(
+    context: ToolContext,
+    name: Annotated[str, "The full name to search for"],
+    limit: Annotated[
+        int | None,
+        "The maximum number of contacts to return (30 is the max allowed by Google API)",
+    ] = DEFAULT_SEARCH_CONTACTS_LIMIT,
+) -> Annotated[dict, "A dictionary containing the list of matching contacts"]:
+    """
+    Search the user's contacts in Google Contacts by name.
+    """
+    service = build_people_service(context.get_auth_token_or_empty())
+    # Warm-up the cache before performing search.
+    # TODO: Ideally we should warmup only if this user (or google domain?) hasn't warmed up recently
+    await _warmup_cache(service)
+    return {"contacts": search_contacts(service, name, limit)}
+
+
+@tool(requires_auth=Google(scopes=["https://www.googleapis.com/auth/contacts"]))
+async def create_contact(
+    context: ToolContext,
+    given_name: Annotated[str, "The given name of the contact"],
+    family_name: Annotated[str | None, "The optional family name of the contact"],
+    email: Annotated[str | None, "The optional email address of the contact"],
+) -> Annotated[dict, "A dictionary containing the details of the created contact"]:
+    """
+    Create a new contact record in Google Contacts.
+
+    Examples:
+    ```
+    create_contact(given_name="Alice")
+    create_contact(given_name="Alice", family_name="Smith")
+    create_contact(given_name="Alice", email="alice@example.com")
+    ```
+    """
+    # Build the People API service
+    service = build_people_service(context.get_auth_token_or_empty())
+
+    # Construct the person payload with the specified names
+    name_body = {"givenName": given_name}
+    if family_name:
+        name_body["familyName"] = family_name
+    contact_body = {"names": [name_body]}
+    if email:
+        contact_body["emailAddresses"] = [{"value": email, "type": "work"}]
+
+    # Create the contact. The personFields parameter specifies what information
+    # should be returned. Here, we return names and emailAddresses.
+    created_contact = (
+        service.people()
+        .createContact(body=contact_body, personFields="names,emailAddresses")
+        .execute()
+    )
+
+    return {"contact": created_contact}

arcade_google/tools/docs.py

@@ -1,8 +1,9 @@
 from typing import Annotated
 
-from arcade.sdk import ToolContext, tool
-from arcade.sdk.auth import Google
-from arcade_google.tools.utils import build_docs_service
+from arcade_tdk import ToolContext, tool
+from arcade_tdk.auth import Google
+
+from arcade_google.utils import build_docs_service
 
 
 # Uses https://developers.google.com/docs/api/reference/rest/v1/documents/get
@@ -11,7 +12,7 @@ from arcade_google.tools.utils import build_docs_service
 @tool(
     requires_auth=Google(
         scopes=[
-            "https://www.googleapis.com/auth/documents.readonly",
+            "https://www.googleapis.com/auth/drive.file",
         ],
     )
 )
@@ -22,13 +23,15 @@ async def get_document_by_id(
     """
     Get the latest version of the specified Google Docs document.
     """
-    service = build_docs_service(context.authorization.token)
+    service = build_docs_service(
+        context.authorization.token if context.authorization and context.authorization.token else ""
+    )
 
     # Execute the documents().get() method. Returns a Document object
     # https://developers.google.com/docs/api/reference/rest/v1/documents#Document
     request = service.documents().get(documentId=document_id)
     response = request.execute()
-    return response
+    return dict(response)
 
 
 # Uses https://developers.google.com/docs/api/reference/rest/v1/documents/batchUpdate
@@ -36,7 +39,7 @@ async def get_document_by_id(
 @tool(
     requires_auth=Google(
         scopes=[
-            "https://www.googleapis.com/auth/documents",
+            "https://www.googleapis.com/auth/drive.file",
         ],
     )
 )
@@ -52,7 +55,9 @@ async def insert_text_at_end_of_document(
 
     end_index = document["body"]["content"][-1]["endIndex"]
 
-    service = build_docs_service(context.authorization.token)
+    service = build_docs_service(
+        context.authorization.token if context.authorization and context.authorization.token else ""
+    )
 
     requests = [
         {
@@ -72,7 +77,7 @@ async def insert_text_at_end_of_document(
         .execute()
     )
 
-    return response
+    return dict(response)
 
 
 # Uses https://developers.google.com/docs/api/reference/rest/v1/documents/create
@@ -80,7 +85,7 @@ async def insert_text_at_end_of_document(
 @tool(
     requires_auth=Google(
         scopes=[
-            "https://www.googleapis.com/auth/documents",
+            "https://www.googleapis.com/auth/drive.file",
         ],
     )
 )
@@ -90,7 +95,9 @@ async def create_blank_document(
     """
     Create a blank Google Docs document with the specified title.
     """
-    service = build_docs_service(context.authorization.token)
+    service = build_docs_service(
+        context.authorization.token if context.authorization and context.authorization.token else ""
+    )
 
     body = {"title": title}
 
@@ -106,11 +113,12 @@ async def create_blank_document(
 
 
 # Uses https://developers.google.com/docs/api/reference/rest/v1/documents/batchUpdate
-# Example `arcade chat` query: `create document with title "My New Document" and text content "Hello, World!"`
+# Example `arcade chat` query:
+#   `create document with title "My New Document" and text content "Hello, World!"`
 @tool(
     requires_auth=Google(
         scopes=[
-            "https://www.googleapis.com/auth/documents",
+            "https://www.googleapis.com/auth/drive.file",
         ],
     )
 )
@@ -125,7 +133,9 @@ async def create_document_from_text(
     # First, create a blank document
     document = await create_blank_document(context, title)
 
-    service = build_docs_service(context.authorization.token)
+    service = build_docs_service(
+        context.authorization.token if context.authorization and context.authorization.token else ""
+    )
 
     requests = [
         {