workspace-mcp 1.1.5__py3-none-any.whl → 1.1.6__py3-none-any.whl

gmail/gmail_tools.py

@@ -111,28 +111,31 @@ def _format_gmail_results_plain(messages: list, query: str) -> str:
         message_url = _generate_gmail_web_url(msg["id"])
         thread_url = _generate_gmail_web_url(msg["threadId"])
 
-        lines.extend([
-            f"  {i}. Message ID: {msg['id']}",
-            f"     Web Link: {message_url}",
-            f"     Thread ID: {msg['threadId']}",
-            f"     Thread Link: {thread_url}",
-            ""
-        ])
-
-    lines.extend([
-        "💡 USAGE:",
-        "  • Pass the Message IDs **as a list** to get_gmail_messages_content_batch()",
-        "    e.g. get_gmail_messages_content_batch(message_ids=[...])",
-        "  • Pass the Thread IDs to get_gmail_thread_content() (single) _or_",
-        "    get_gmail_threads_content_batch() (coming soon)"
-    ])
+        lines.extend(
+            [
+                f"  {i}. Message ID: {msg['id']}",
+                f"     Web Link: {message_url}",
+                f"     Thread ID: {msg['threadId']}",
+                f"     Thread Link: {thread_url}",
+                "",
+            ]
+        )
+
+    lines.extend(
+        [
+            "💡 USAGE:",
+            "  • Pass the Message IDs **as a list** to get_gmail_messages_content_batch()",
+            "    e.g. get_gmail_messages_content_batch(message_ids=[...])",
+            "  • Pass the Thread IDs to get_gmail_thread_content() (single) or get_gmail_threads_content_batch() (batch)",
+        ]
+    )
 
     return "\n".join(lines)
 
 
 @server.tool()
+@handle_http_errors("search_gmail_messages", is_read_only=True)
 @require_google_service("gmail", "gmail_read")
-@handle_http_errors("search_gmail_messages")
 async def search_gmail_messages(
     service, query: str, user_google_email: str, page_size: int = 10
 ) -> str:
@@ -148,7 +151,9 @@ async def search_gmail_messages(
     Returns:
         str: LLM-friendly structured results with Message IDs, Thread IDs, and clickable Gmail web interface URLs for each found message.
     """
-    logger.info(f"[search_gmail_messages] Email: '{user_google_email}', Query: '{query}'")
+    logger.info(
+        f"[search_gmail_messages] Email: '{user_google_email}', Query: '{query}'"
+    )
 
     response = await asyncio.to_thread(
         service.users()
@@ -164,8 +169,8 @@ async def search_gmail_messages(
 
 
 @server.tool()
+@handle_http_errors("get_gmail_message_content", is_read_only=True)
 @require_google_service("gmail", "gmail_read")
-@handle_http_errors("get_gmail_message_content")
 async def get_gmail_message_content(
     service, message_id: str, user_google_email: str
 ) -> str:
@@ -232,8 +237,8 @@ async def get_gmail_message_content(
 
 
 @server.tool()
+@handle_http_errors("get_gmail_messages_content_batch", is_read_only=True)
 @require_google_service("gmail", "gmail_read")
-@handle_http_errors("get_gmail_messages_content_batch")
 async def get_gmail_messages_content_batch(
     service,
     message_ids: List[str],
@@ -263,7 +268,7 @@ async def get_gmail_messages_content_batch(
 
     # Process in chunks of 100 (Gmail batch limit)
     for chunk_start in range(0, len(message_ids), 100):
-        chunk_ids = message_ids[chunk_start:chunk_start + 100]
+        chunk_ids = message_ids[chunk_start : chunk_start + 100]
         results: Dict[str, Dict] = {}
 
         def _batch_callback(request_id, response, exception):
@@ -276,17 +281,21 @@ async def get_gmail_messages_content_batch(
 
             for mid in chunk_ids:
                 if format == "metadata":
-                    req = service.users().messages().get(
-                        userId="me",
-                        id=mid,
-                        format="metadata",
-                        metadataHeaders=["Subject", "From"]
+                    req = (
+                        service.users()
+                        .messages()
+                        .get(
+                            userId="me",
+                            id=mid,
+                            format="metadata",
+                            metadataHeaders=["Subject", "From"],
+                        )
                     )
                 else:
-                    req = service.users().messages().get(
-                        userId="me",
-                        id=mid,
-                        format="full"
+                    req = (
+                        service.users()
+                        .messages()
+                        .get(userId="me", id=mid, format="full")
                     )
                 batch.add(req, request_id=mid)
 
@@ -303,20 +312,22 @@ async def get_gmail_messages_content_batch(
                 try:
                     if format == "metadata":
                         msg = await asyncio.to_thread(
-                            service.users().messages().get(
+                            service.users()
+                            .messages()
+                            .get(
                                 userId="me",
                                 id=mid,
                                 format="metadata",
-                                metadataHeaders=["Subject", "From"]
-                            ).execute
+                                metadataHeaders=["Subject", "From"],
+                            )
+                            .execute
                         )
                     else:
                         msg = await asyncio.to_thread(
-                            service.users().messages().get(
-                                userId="me",
-                                id=mid,
-                                format="full"
-                            ).execute
+                            service.users()
+                            .messages()
+                            .get(userId="me", id=mid, format="full")
+                            .execute
                         )
                     return mid, msg, None
                 except Exception as e:
@@ -324,8 +335,7 @@ async def get_gmail_messages_content_batch(
 
             # Fetch all messages in parallel
             fetch_results = await asyncio.gather(
-                *[fetch_message(mid) for mid in chunk_ids],
-                return_exceptions=False
+                *[fetch_message(mid) for mid in chunk_ids], return_exceptions=False
             )
 
             # Convert to results format
@@ -337,15 +347,11 @@ async def get_gmail_messages_content_batch(
             entry = results.get(mid, {"data": None, "error": "No result"})
 
             if entry["error"]:
-                output_messages.append(
-                    f"⚠️ Message {mid}: {entry['error']}\n"
-                )
+                output_messages.append(f"⚠️ Message {mid}: {entry['error']}\n")
             else:
                 message = entry["data"]
                 if not message:
-                    output_messages.append(
-                        f"⚠️ Message {mid}: No data returned\n"
-                    )
+                    output_messages.append(f"⚠️ Message {mid}: No data returned\n")
                     continue
 
                 # Extract content based on format
@@ -385,8 +391,8 @@ async def get_gmail_messages_content_batch(
 
 
 @server.tool()
-@require_google_service("gmail", GMAIL_SEND_SCOPE)
 @handle_http_errors("send_gmail_message")
+@require_google_service("gmail", GMAIL_SEND_SCOPE)
 async def send_gmail_message(
     service,
     user_google_email: str,
@@ -422,8 +428,8 @@ async def send_gmail_message(
 
 
 @server.tool()
-@require_google_service("gmail", GMAIL_COMPOSE_SCOPE)
 @handle_http_errors("draft_gmail_message")
+@require_google_service("gmail", GMAIL_COMPOSE_SCOPE)
 async def draft_gmail_message(
     service,
     user_google_email: str,
@@ -468,35 +474,18 @@ async def draft_gmail_message(
     return f"Draft created! Draft ID: {draft_id}"
 
 
-@server.tool()
-@require_google_service("gmail", "gmail_read")
-@handle_http_errors("get_gmail_thread_content")
-async def get_gmail_thread_content(
-    service, thread_id: str, user_google_email: str
-) -> str:
+def _format_thread_content(thread_data: dict, thread_id: str) -> str:
     """
-    Retrieves the complete content of a Gmail conversation thread, including all messages.
+    Helper function to format thread content from Gmail API response.
 
     Args:
-        thread_id (str): The unique ID of the Gmail thread to retrieve.
-        user_google_email (str): The user's Google email address. Required.
+        thread_data (dict): Thread data from Gmail API
+        thread_id (str): Thread ID for display
 
     Returns:
-        str: The complete thread content with all messages formatted for reading.
+        str: Formatted thread content
     """
-    logger.info(
-        f"[get_gmail_thread_content] Invoked. Thread ID: '{thread_id}', Email: '{user_google_email}'"
-    )
-
-    # Fetch the complete thread with all messages
-    thread_response = await asyncio.to_thread(
-        service.users()
-        .threads()
-        .get(userId="me", id=thread_id, format="full")
-        .execute
-    )
-
-    messages = thread_response.get("messages", [])
+    messages = thread_data.get("messages", [])
     if not messages:
         return f"No messages found in thread '{thread_id}'."
 
@@ -520,8 +509,7 @@ async def get_gmail_thread_content(
     for i, message in enumerate(messages, 1):
         # Extract headers
         headers = {
-            h["name"]: h["value"]
-            for h in message.get("payload", {}).get("headers", [])
+            h["name"]: h["value"] for h in message.get("payload", {}).get("headers", [])
         }
 
         sender = headers.get("From", "(unknown sender)")
@@ -553,13 +541,134 @@ async def get_gmail_thread_content(
             ]
         )
 
-    content_text = "\n".join(content_lines)
-    return content_text
+    return "\n".join(content_lines)
 
 
 @server.tool()
 @require_google_service("gmail", "gmail_read")
-@handle_http_errors("list_gmail_labels")
+@handle_http_errors("get_gmail_thread_content", is_read_only=True)
+async def get_gmail_thread_content(
+    service, thread_id: str, user_google_email: str
+) -> str:
+    """
+    Retrieves the complete content of a Gmail conversation thread, including all messages.
+
+    Args:
+        thread_id (str): The unique ID of the Gmail thread to retrieve.
+        user_google_email (str): The user's Google email address. Required.
+
+    Returns:
+        str: The complete thread content with all messages formatted for reading.
+    """
+    logger.info(
+        f"[get_gmail_thread_content] Invoked. Thread ID: '{thread_id}', Email: '{user_google_email}'"
+    )
+
+    # Fetch the complete thread with all messages
+    thread_response = await asyncio.to_thread(
+        service.users().threads().get(userId="me", id=thread_id, format="full").execute
+    )
+
+    return _format_thread_content(thread_response, thread_id)
+
+
+@server.tool()
+@require_google_service("gmail", "gmail_read")
+@handle_http_errors("get_gmail_threads_content_batch", is_read_only=True)
+async def get_gmail_threads_content_batch(
+    service,
+    thread_ids: List[str],
+    user_google_email: str,
+) -> str:
+    """
+    Retrieves the content of multiple Gmail threads in a single batch request.
+    Supports up to 100 threads per request using Google's batch API.
+
+    Args:
+        thread_ids (List[str]): A list of Gmail thread IDs to retrieve. The function will automatically batch requests in chunks of 100.
+        user_google_email (str): The user's Google email address. Required.
+
+    Returns:
+        str: A formatted list of thread contents with separators.
+    """
+    logger.info(
+        f"[get_gmail_threads_content_batch] Invoked. Thread count: {len(thread_ids)}, Email: '{user_google_email}'"
+    )
+
+    if not thread_ids:
+        raise ValueError("No thread IDs provided")
+
+    output_threads = []
+
+    def _batch_callback(request_id, response, exception):
+        """Callback for batch requests"""
+        results[request_id] = {"data": response, "error": exception}
+
+    # Process in chunks of 100 (Gmail batch limit)
+    for chunk_start in range(0, len(thread_ids), 100):
+        chunk_ids = thread_ids[chunk_start : chunk_start + 100]
+        results: Dict[str, Dict] = {}
+
+        # Try to use batch API
+        try:
+            batch = service.new_batch_http_request(callback=_batch_callback)
+
+            for tid in chunk_ids:
+                req = service.users().threads().get(userId="me", id=tid, format="full")
+                batch.add(req, request_id=tid)
+
+            # Execute batch request
+            await asyncio.to_thread(batch.execute)
+
+        except Exception as batch_error:
+            # Fallback to asyncio.gather if batch API fails
+            logger.warning(
+                f"[get_gmail_threads_content_batch] Batch API failed, falling back to asyncio.gather: {batch_error}"
+            )
+
+            async def fetch_thread(tid: str):
+                try:
+                    thread = await asyncio.to_thread(
+                        service.users()
+                        .threads()
+                        .get(userId="me", id=tid, format="full")
+                        .execute
+                    )
+                    return tid, thread, None
+                except Exception as e:
+                    return tid, None, e
+
+            # Fetch all threads in parallel
+            fetch_results = await asyncio.gather(
+                *[fetch_thread(tid) for tid in chunk_ids], return_exceptions=False
+            )
+
+            # Convert to results format
+            for tid, thread, error in fetch_results:
+                results[tid] = {"data": thread, "error": error}
+
+        # Process results for this chunk
+        for tid in chunk_ids:
+            entry = results.get(tid, {"data": None, "error": "No result"})
+
+            if entry["error"]:
+                output_threads.append(f"⚠️ Thread {tid}: {entry['error']}\n")
+            else:
+                thread = entry["data"]
+                if not thread:
+                    output_threads.append(f"⚠️ Thread {tid}: No data returned\n")
+                    continue
+
+                output_threads.append(_format_thread_content(thread, tid))
+
+    # Combine all threads with separators
+    header = f"Retrieved {len(thread_ids)} threads:"
+    return header + "\n\n" + "\n---\n\n".join(output_threads)
+
+
+@server.tool()
+@handle_http_errors("list_gmail_labels", is_read_only=True)
+@require_google_service("gmail", "gmail_read")
 async def list_gmail_labels(service, user_google_email: str) -> str:
     """
     Lists all labels in the user's Gmail account.
@@ -606,8 +715,8 @@ async def list_gmail_labels(service, user_google_email: str) -> str:
 
 
 @server.tool()
-@require_google_service("gmail", GMAIL_LABELS_SCOPE)
 @handle_http_errors("manage_gmail_label")
+@require_google_service("gmail", GMAIL_LABELS_SCOPE)
 async def manage_gmail_label(
     service,
     user_google_email: str,
@@ -631,7 +740,9 @@ async def manage_gmail_label(
     Returns:
         str: Confirmation message of the label operation.
     """
-    logger.info(f"[manage_gmail_label] Invoked. Email: '{user_google_email}', Action: '{action}'")
+    logger.info(
+        f"[manage_gmail_label] Invoked. Email: '{user_google_email}', Action: '{action}'"
+    )
 
     if action == "create" and not name:
         raise Exception("Label name is required for create action.")
@@ -663,7 +774,10 @@ async def manage_gmail_label(
         }
 
         updated_label = await asyncio.to_thread(
-            service.users().labels().update(userId="me", id=label_id, body=label_object).execute
+            service.users()
+            .labels()
+            .update(userId="me", id=label_id, body=label_object)
+            .execute
         )
         return f"Label updated successfully!\nName: {updated_label['name']}\nID: {updated_label['id']}"
 
@@ -680,8 +794,8 @@ async def manage_gmail_label(
 
 
 @server.tool()
-@require_google_service("gmail", GMAIL_MODIFY_SCOPE)
 @handle_http_errors("modify_gmail_message_labels")
+@require_google_service("gmail", GMAIL_MODIFY_SCOPE)
 async def modify_gmail_message_labels(
     service,
     user_google_email: str,
@@ -701,10 +815,14 @@ async def modify_gmail_message_labels(
     Returns:
         str: Confirmation message of the label changes applied to the message.
     """
-    logger.info(f"[modify_gmail_message_labels] Invoked. Email: '{user_google_email}', Message ID: '{message_id}'")
+    logger.info(
+        f"[modify_gmail_message_labels] Invoked. Email: '{user_google_email}', Message ID: '{message_id}'"
+    )
 
     if not add_label_ids and not remove_label_ids:
-        raise Exception("At least one of add_label_ids or remove_label_ids must be provided.")
+        raise Exception(
+            "At least one of add_label_ids or remove_label_ids must be provided."
+        )
 
     body = {}
     if add_label_ids:

gsheets/sheets_tools.py

@@ -21,8 +21,8 @@ logger = logging.getLogger(__name__)
 
 
 @server.tool()
+@handle_http_errors("list_spreadsheets", is_read_only=True)
 @require_google_service("drive", "drive_read")
-@handle_http_errors("list_spreadsheets")
 async def list_spreadsheets(
     service,
     user_google_email: str,
@@ -70,8 +70,8 @@ async def list_spreadsheets(
 
 
 @server.tool()
+@handle_http_errors("get_spreadsheet_info", is_read_only=True)
 @require_google_service("sheets", "sheets_read")
-@handle_http_errors("get_spreadsheet_info")
 async def get_spreadsheet_info(
     service,
     user_google_email: str,
@@ -120,8 +120,8 @@ async def get_spreadsheet_info(
 
 
 @server.tool()
+@handle_http_errors("read_sheet_values", is_read_only=True)
 @require_google_service("sheets", "sheets_read")
-@handle_http_errors("read_sheet_values")
 async def read_sheet_values(
     service,
     user_google_email: str,
@@ -170,8 +170,8 @@ async def read_sheet_values(
 
 
 @server.tool()
-@require_google_service("sheets", "sheets_write")
 @handle_http_errors("modify_sheet_values")
+@require_google_service("sheets", "sheets_write")
 async def modify_sheet_values(
     service,
     user_google_email: str,
@@ -241,8 +241,8 @@ async def modify_sheet_values(
 
 
 @server.tool()
-@require_google_service("sheets", "sheets_write")
 @handle_http_errors("create_spreadsheet")
+@require_google_service("sheets", "sheets_write")
 async def create_spreadsheet(
     service,
     user_google_email: str,
@@ -290,8 +290,8 @@ async def create_spreadsheet(
 
 
 @server.tool()
-@require_google_service("sheets", "sheets_write")
 @handle_http_errors("create_sheet")
+@require_google_service("sheets", "sheets_write")
 async def create_sheet(
     service,
     user_google_email: str,
@@ -344,7 +344,7 @@ _comment_tools = create_comment_tools("spreadsheet", "spreadsheet_id")
 
 # Extract and register the functions
 read_sheet_comments = _comment_tools['read_comments']
-create_sheet_comment = _comment_tools['create_comment'] 
+create_sheet_comment = _comment_tools['create_comment']
 reply_to_sheet_comment = _comment_tools['reply_to_comment']
 resolve_sheet_comment = _comment_tools['resolve_comment']
 

gslides/slides_tools.py

@@ -20,8 +20,8 @@ logger = logging.getLogger(__name__)
 
 
 @server.tool()
-@require_google_service("slides", "slides")
 @handle_http_errors("create_presentation")
+@require_google_service("slides", "slides")
 async def create_presentation(
     service,
     user_google_email: str,
@@ -42,27 +42,27 @@ async def create_presentation(
     body = {
         'title': title
     }
-    
+
     result = await asyncio.to_thread(
         service.presentations().create(body=body).execute
     )
-    
+
     presentation_id = result.get('presentationId')
     presentation_url = f"https://docs.google.com/presentation/d/{presentation_id}/edit"
-    
+
     confirmation_message = f"""Presentation Created Successfully for {user_google_email}:
 - Title: {title}
 - Presentation ID: {presentation_id}
 - URL: {presentation_url}
 - Slides: {len(result.get('slides', []))} slide(s) created"""
-    
+
     logger.info(f"Presentation created successfully for {user_google_email}")
     return confirmation_message
 
 
 @server.tool()
+@handle_http_errors("get_presentation", is_read_only=True)
 @require_google_service("slides", "slides_read")
-@handle_http_errors("get_presentation")
 async def get_presentation(
     service,
     user_google_email: str,
@@ -83,17 +83,17 @@ async def get_presentation(
     result = await asyncio.to_thread(
         service.presentations().get(presentationId=presentation_id).execute
     )
-    
+
     title = result.get('title', 'Untitled')
     slides = result.get('slides', [])
     page_size = result.get('pageSize', {})
-    
+
     slides_info = []
     for i, slide in enumerate(slides, 1):
         slide_id = slide.get('objectId', 'Unknown')
         page_elements = slide.get('pageElements', [])
         slides_info.append(f"  Slide {i}: ID {slide_id}, {len(page_elements)} element(s)")
-    
+
     confirmation_message = f"""Presentation Details for {user_google_email}:
 - Title: {title}
 - Presentation ID: {presentation_id}
@@ -103,14 +103,14 @@ async def get_presentation(
 
 Slides Breakdown:
 {chr(10).join(slides_info) if slides_info else '  No slides found'}"""
-    
+
     logger.info(f"Presentation retrieved successfully for {user_google_email}")
     return confirmation_message
 
 
 @server.tool()
-@require_google_service("slides", "slides")
 @handle_http_errors("batch_update_presentation")
+@require_google_service("slides", "slides")
 async def batch_update_presentation(
     service,
     user_google_email: str,
@@ -133,22 +133,22 @@ async def batch_update_presentation(
     body = {
         'requests': requests
     }
-    
+
     result = await asyncio.to_thread(
         service.presentations().batchUpdate(
             presentationId=presentation_id,
             body=body
         ).execute
     )
-    
+
     replies = result.get('replies', [])
-    
+
     confirmation_message = f"""Batch Update Completed for {user_google_email}:
 - Presentation ID: {presentation_id}
 - URL: https://docs.google.com/presentation/d/{presentation_id}/edit
 - Requests Applied: {len(requests)}
 - Replies Received: {len(replies)}"""
-    
+
     if replies:
         confirmation_message += "\n\nUpdate Results:"
         for i, reply in enumerate(replies, 1):
@@ -160,14 +160,14 @@ async def batch_update_presentation(
                 confirmation_message += f"\n  Request {i}: Created shape with ID {shape_id}"
             else:
                 confirmation_message += f"\n  Request {i}: Operation completed"
-    
+
     logger.info(f"Batch update completed successfully for {user_google_email}")
     return confirmation_message
 
 
 @server.tool()
+@handle_http_errors("get_page", is_read_only=True)
 @require_google_service("slides", "slides_read")
-@handle_http_errors("get_page")
 async def get_page(
     service,
     user_google_email: str,
@@ -193,10 +193,10 @@ async def get_page(
             pageObjectId=page_object_id
         ).execute
     )
-    
+
     page_type = result.get('pageType', 'Unknown')
     page_elements = result.get('pageElements', [])
-    
+
     elements_info = []
     for element in page_elements:
         element_id = element.get('objectId', 'Unknown')
@@ -213,7 +213,7 @@ async def get_page(
             elements_info.append(f"  Line: ID {element_id}, Type: {line_type}")
         else:
             elements_info.append(f"  Element: ID {element_id}, Type: Unknown")
-    
+
     confirmation_message = f"""Page Details for {user_google_email}:
 - Presentation ID: {presentation_id}
 - Page ID: {page_object_id}
@@ -222,14 +222,14 @@ async def get_page(
 
 Page Elements:
 {chr(10).join(elements_info) if elements_info else '  No elements found'}"""
-    
+
     logger.info(f"Page retrieved successfully for {user_google_email}")
     return confirmation_message
 
 
 @server.tool()
+@handle_http_errors("get_page_thumbnail", is_read_only=True)
 @require_google_service("slides", "slides_read")
-@handle_http_errors("get_page_thumbnail")
 async def get_page_thumbnail(
     service,
     user_google_email: str,
@@ -258,9 +258,9 @@ async def get_page_thumbnail(
             thumbnailPropertiesImageSize=thumbnail_size
         ).execute
     )
-    
+
     thumbnail_url = result.get('contentUrl', '')
-    
+
     confirmation_message = f"""Thumbnail Generated for {user_google_email}:
 - Presentation ID: {presentation_id}
 - Page ID: {page_object_id}
@@ -268,7 +268,7 @@ async def get_page_thumbnail(
 - Thumbnail URL: {thumbnail_url}
 
 You can view or download the thumbnail using the provided URL."""
-    
+
     logger.info(f"Thumbnail generated successfully for {user_google_email}")
     return confirmation_message