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

auth/google_auth.py

@@ -1,14 +1,16 @@
 # auth/google_auth.py
 
-import os
+import asyncio
 import json
+import jwt
 import logging
-import asyncio
-from typing import List, Optional, Tuple, Dict, Any, Callable
 import os
 
+from datetime import datetime
+from typing import List, Optional, Tuple, Dict, Any
+
 from google.oauth2.credentials import Credentials
-from google_auth_oauthlib.flow import Flow, InstalledAppFlow
+from google_auth_oauthlib.flow import Flow
 from google.auth.transport.requests import Request
 from google.auth.exceptions import RefreshError
 from googleapiclient.discovery import build
@@ -161,8 +163,6 @@ def load_credentials_from_file(
         expiry = None
         if creds_data.get("expiry"):
             try:
-                from datetime import datetime
-
                 expiry = datetime.fromisoformat(creds_data["expiry"])
             except (ValueError, TypeError) as e:
                 logger.warning(
@@ -789,8 +789,6 @@ async def get_authenticated_google_service(
         # Try to get email from credentials if needed for validation
         if credentials and credentials.id_token:
             try:
-                import jwt
-
                 # Decode without verification (just to get email for logging)
                 decoded_token = jwt.decode(
                     credentials.id_token, options={"verify_signature": False}

auth/oauth_callback_server.py

@@ -5,15 +5,17 @@ In streamable-http mode: Uses the existing FastAPI server
 In stdio mode: Starts a minimal HTTP server just for OAuth callbacks
 """
 
+import os
 import asyncio
 import logging
 import threading
 import time
-from typing import Optional, Dict, Any
 import socket
+import uvicorn
 
 from fastapi import FastAPI, Request
-import uvicorn
+from typing import Optional
+from urllib.parse import urlparse
 
 from auth.google_auth import handle_auth_callback, check_client_secrets
 from auth.scopes import OAUTH_STATE_TO_SESSION_ID_MAP, SCOPES
@@ -73,10 +75,11 @@ class MinimalOAuthServer:
                     logger.warning(f"OAuth callback: No MCP session ID found for state '{state}'. Auth will not be tied to a specific session.")
 
                 # Exchange code for credentials
+                redirect_uri = get_oauth_redirect_uri(port=self.port, base_uri=self.base_uri)
                 verified_user_id, credentials = handle_auth_callback(
                     scopes=SCOPES,
                     authorization_response=str(request.url),
-                    redirect_uri=f"{self.base_uri}:{self.port}/oauth2callback",
+                    redirect_uri=redirect_uri,
                     session_id=mcp_session_id
                 )
 
@@ -105,7 +108,6 @@ class MinimalOAuthServer:
         # Check if port is available
         # Extract hostname from base_uri (e.g., "http://localhost" -> "localhost")
         try:
-            from urllib.parse import urlparse
             parsed_uri = urlparse(self.base_uri)
             hostname = parsed_uri.hostname or 'localhost'
         except Exception:
@@ -179,19 +181,31 @@ class MinimalOAuthServer:
 # Global instance for stdio mode
 _minimal_oauth_server: Optional[MinimalOAuthServer] = None
 
-def get_oauth_redirect_uri(transport_mode: str = "stdio", port: int = 8000, base_uri: str = "http://localhost") -> str:
+def get_oauth_redirect_uri(port: int = 8000, base_uri: str = "http://localhost") -> str:
     """
-    Get the appropriate OAuth redirect URI based on transport mode.
+    Get the appropriate OAuth redirect URI.
+
+    Priority:
+    1. GOOGLE_OAUTH_REDIRECT_URI environment variable
+    2. Constructed from port and base URI
 
     Args:
-        transport_mode: "stdio" or "streamable-http"
         port: Port number (default 8000)
         base_uri: Base URI (default "http://localhost")
 
     Returns:
         OAuth redirect URI
     """
-    return f"{base_uri}:{port}/oauth2callback"
+    # Highest priority: Use the environment variable if it's set
+    env_redirect_uri = os.getenv("GOOGLE_OAUTH_REDIRECT_URI")
+    if env_redirect_uri:
+        logger.info(f"Using redirect URI from GOOGLE_OAUTH_REDIRECT_URI: {env_redirect_uri}")
+        return env_redirect_uri
+
+    # Fallback to constructing the URI based on server settings
+    constructed_uri = f"{base_uri}:{port}/oauth2callback"
+    logger.info(f"Constructed redirect URI: {constructed_uri}")
+    return constructed_uri
 
 def ensure_oauth_callback_available(transport_mode: str = "stdio", port: int = 8000, base_uri: str = "http://localhost") -> bool:
     """

core/server.py

@@ -82,7 +82,7 @@ def set_transport_mode(mode: str):
 
 def get_oauth_redirect_uri_for_current_mode() -> str:
     """Get OAuth redirect URI based on current transport mode."""
-    return get_oauth_redirect_uri(_current_transport_mode, WORKSPACE_MCP_PORT, WORKSPACE_MCP_BASE_URI)
+    return get_oauth_redirect_uri(WORKSPACE_MCP_PORT, WORKSPACE_MCP_BASE_URI)
 
 # Health check endpoint
 @server.custom_route("/health", methods=["GET"])

core/utils.py

@@ -3,11 +3,24 @@ import logging
 import os
 import tempfile
 import zipfile, xml.etree.ElementTree as ET
+import ssl
+import time
+import asyncio
+import functools
 
 from typing import List, Optional
 
+from googleapiclient.errors import HttpError
+
 logger = logging.getLogger(__name__)
 
+
+class TransientNetworkError(Exception):
+    """Custom exception for transient network errors after retries."""
+
+    pass
+
+
 def check_credentials_directory_permissions(credentials_dir: str = None) -> None:
     """
     Check if the service has appropriate permissions to create and write to the .credentials directory.
@@ -21,6 +34,7 @@ def check_credentials_directory_permissions(credentials_dir: str = None) -> None
     """
     if credentials_dir is None:
         from auth.google_auth import get_default_credentials_dir
+
         credentials_dir = get_default_credentials_dir()
 
     try:
@@ -29,22 +43,28 @@ def check_credentials_directory_permissions(credentials_dir: str = None) -> None
             # Directory exists, check if we can write to it
             test_file = os.path.join(credentials_dir, ".permission_test")
             try:
-                with open(test_file, 'w') as f:
+                with open(test_file, "w") as f:
                     f.write("test")
                 os.remove(test_file)
-                logger.info(f"Credentials directory permissions check passed: {os.path.abspath(credentials_dir)}")
+                logger.info(
+                    f"Credentials directory permissions check passed: {os.path.abspath(credentials_dir)}"
+                )
             except (PermissionError, OSError) as e:
-                raise PermissionError(f"Cannot write to existing credentials directory '{os.path.abspath(credentials_dir)}': {e}")
+                raise PermissionError(
+                    f"Cannot write to existing credentials directory '{os.path.abspath(credentials_dir)}': {e}"
+                )
         else:
             # Directory doesn't exist, try to create it and its parent directories
             try:
                 os.makedirs(credentials_dir, exist_ok=True)
                 # Test writing to the new directory
                 test_file = os.path.join(credentials_dir, ".permission_test")
-                with open(test_file, 'w') as f:
+                with open(test_file, "w") as f:
                     f.write("test")
                 os.remove(test_file)
-                logger.info(f"Created credentials directory with proper permissions: {os.path.abspath(credentials_dir)}")
+                logger.info(
+                    f"Created credentials directory with proper permissions: {os.path.abspath(credentials_dir)}"
+                )
             except (PermissionError, OSError) as e:
                 # Clean up if we created the directory but can't write to it
                 try:
@@ -52,12 +72,17 @@ def check_credentials_directory_permissions(credentials_dir: str = None) -> None
                         os.rmdir(credentials_dir)
                 except:
                     pass
-                raise PermissionError(f"Cannot create or write to credentials directory '{os.path.abspath(credentials_dir)}': {e}")
+                raise PermissionError(
+                    f"Cannot create or write to credentials directory '{os.path.abspath(credentials_dir)}': {e}"
+                )
 
     except PermissionError:
         raise
     except Exception as e:
-        raise OSError(f"Unexpected error checking credentials directory permissions: {e}")
+        raise OSError(
+            f"Unexpected error checking credentials directory permissions: {e}"
+        )
+
 
 def extract_office_xml_text(file_bytes: bytes, mime_type: str) -> Optional[str]:
     """
@@ -66,23 +91,38 @@ def extract_office_xml_text(file_bytes: bytes, mime_type: str) -> Optional[str]:
     No external deps – just std-lib zipfile + ElementTree.
     """
     shared_strings: List[str] = []
-    ns_excel_main = 'http://schemas.openxmlformats.org/spreadsheetml/2006/main'
+    ns_excel_main = "http://schemas.openxmlformats.org/spreadsheetml/2006/main"
 
     try:
         with zipfile.ZipFile(io.BytesIO(file_bytes)) as zf:
             targets: List[str] = []
             # Map MIME → iterable of XML files to inspect
-            if mime_type == "application/vnd.openxmlformats-officedocument.wordprocessingml.document":
+            if (
+                mime_type
+                == "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+            ):
                 targets = ["word/document.xml"]
-            elif mime_type == "application/vnd.openxmlformats-officedocument.presentationml.presentation":
+            elif (
+                mime_type
+                == "application/vnd.openxmlformats-officedocument.presentationml.presentation"
+            ):
                 targets = [n for n in zf.namelist() if n.startswith("ppt/slides/slide")]
-            elif mime_type == "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet":
-                targets = [n for n in zf.namelist() if n.startswith("xl/worksheets/sheet") and "drawing" not in n]
+            elif (
+                mime_type
+                == "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+            ):
+                targets = [
+                    n
+                    for n in zf.namelist()
+                    if n.startswith("xl/worksheets/sheet") and "drawing" not in n
+                ]
                 # Attempt to parse sharedStrings.xml for Excel files
                 try:
                     shared_strings_xml = zf.read("xl/sharedStrings.xml")
                     shared_strings_root = ET.fromstring(shared_strings_xml)
-                    for si_element in shared_strings_root.findall(f"{{{ns_excel_main}}}si"):
+                    for si_element in shared_strings_root.findall(
+                        f"{{{ns_excel_main}}}si"
+                    ):
                         text_parts = []
                         # Find all <t> elements, simple or within <r> runs, and concatenate their text
                         for t_element in si_element.findall(f".//{{{ns_excel_main}}}t"):
@@ -90,11 +130,18 @@ def extract_office_xml_text(file_bytes: bytes, mime_type: str) -> Optional[str]:
                                 text_parts.append(t_element.text)
                         shared_strings.append("".join(text_parts))
                 except KeyError:
-                    logger.info("No sharedStrings.xml found in Excel file (this is optional).")
+                    logger.info(
+                        "No sharedStrings.xml found in Excel file (this is optional)."
+                    )
                 except ET.ParseError as e:
                     logger.error(f"Error parsing sharedStrings.xml: {e}")
-                except Exception as e: # Catch any other unexpected error during sharedStrings parsing
-                    logger.error(f"Unexpected error processing sharedStrings.xml: {e}", exc_info=True)
+                except (
+                    Exception
+                ) as e:  # Catch any other unexpected error during sharedStrings parsing
+                    logger.error(
+                        f"Unexpected error processing sharedStrings.xml: {e}",
+                        exc_info=True,
+                    )
             else:
                 return None
 
@@ -105,93 +152,145 @@ def extract_office_xml_text(file_bytes: bytes, mime_type: str) -> Optional[str]:
                     xml_root = ET.fromstring(xml_content)
                     member_texts: List[str] = []
 
-                    if mime_type == "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet":
-                        for cell_element in xml_root.findall(f".//{{{ns_excel_main}}}c"): # Find all <c> elements
-                            value_element = cell_element.find(f"{{{ns_excel_main}}}v") # Find <v> under <c>
+                    if (
+                        mime_type
+                        == "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+                    ):
+                        for cell_element in xml_root.findall(
+                            f".//{{{ns_excel_main}}}c"
+                        ):  # Find all <c> elements
+                            value_element = cell_element.find(
+                                f"{{{ns_excel_main}}}v"
+                            )  # Find <v> under <c>
 
                             # Skip if cell has no value element or value element has no text
                             if value_element is None or value_element.text is None:
                                 continue
 
-                            cell_type = cell_element.get('t')
-                            if cell_type == 's':  # Shared string
+                            cell_type = cell_element.get("t")
+                            if cell_type == "s":  # Shared string
                                 try:
                                     ss_idx = int(value_element.text)
                                     if 0 <= ss_idx < len(shared_strings):
                                         member_texts.append(shared_strings[ss_idx])
                                     else:
-                                        logger.warning(f"Invalid shared string index {ss_idx} in {member}. Max index: {len(shared_strings)-1}")
+                                        logger.warning(
+                                            f"Invalid shared string index {ss_idx} in {member}. Max index: {len(shared_strings)-1}"
+                                        )
                                 except ValueError:
-                                    logger.warning(f"Non-integer shared string index: '{value_element.text}' in {member}.")
+                                    logger.warning(
+                                        f"Non-integer shared string index: '{value_element.text}' in {member}."
+                                    )
                             else:  # Direct value (number, boolean, inline string if not 's')
                                 member_texts.append(value_element.text)
                     else:  # Word or PowerPoint
                         for elem in xml_root.iter():
                             # For Word: <w:t> where w is "http://schemas.openxmlformats.org/wordprocessingml/2006/main"
                             # For PowerPoint: <a:t> where a is "http://schemas.openxmlformats.org/drawingml/2006/main"
-                            if elem.tag.endswith("}t") and elem.text: # Check for any namespaced tag ending with 't'
+                            if (
+                                elem.tag.endswith("}t") and elem.text
+                            ):  # Check for any namespaced tag ending with 't'
                                 cleaned_text = elem.text.strip()
-                                if cleaned_text: # Add only if there's non-whitespace text
-                                     member_texts.append(cleaned_text)
+                                if (
+                                    cleaned_text
+                                ):  # Add only if there's non-whitespace text
+                                    member_texts.append(cleaned_text)
 
                     if member_texts:
-                        pieces.append(" ".join(member_texts)) # Join texts from one member with spaces
+                        pieces.append(
+                            " ".join(member_texts)
+                        )  # Join texts from one member with spaces
 
                 except ET.ParseError as e:
-                    logger.warning(f"Could not parse XML in member '{member}' for {mime_type} file: {e}")
+                    logger.warning(
+                        f"Could not parse XML in member '{member}' for {mime_type} file: {e}"
+                    )
                 except Exception as e:
-                    logger.error(f"Error processing member '{member}' for {mime_type}: {e}", exc_info=True)
+                    logger.error(
+                        f"Error processing member '{member}' for {mime_type}: {e}",
+                        exc_info=True,
+                    )
                     # continue processing other members
 
-            if not pieces: # If no text was extracted at all
+            if not pieces:  # If no text was extracted at all
                 return None
 
             # Join content from different members (sheets/slides) with double newlines for separation
             text = "\n\n".join(pieces).strip()
-            return text or None # Ensure None is returned if text is empty after strip
+            return text or None  # Ensure None is returned if text is empty after strip
 
     except zipfile.BadZipFile:
         logger.warning(f"File is not a valid ZIP archive (mime_type: {mime_type}).")
         return None
-    except ET.ParseError as e: # Catch parsing errors at the top level if zipfile itself is XML-like
+    except (
+        ET.ParseError
+    ) as e:  # Catch parsing errors at the top level if zipfile itself is XML-like
         logger.error(f"XML parsing error at a high level for {mime_type}: {e}")
         return None
     except Exception as e:
-        logger.error(f"Failed to extract office XML text for {mime_type}: {e}", exc_info=True)
+        logger.error(
+            f"Failed to extract office XML text for {mime_type}: {e}", exc_info=True
+        )
         return None
 
-import functools
-from googleapiclient.errors import HttpError
 
-def handle_http_errors(tool_name: str):
+def handle_http_errors(tool_name: str, is_read_only: bool = False):
     """
-    A decorator to handle Google API HttpErrors in a standardized way.
+    A decorator to handle Google API HttpErrors and transient SSL errors in a standardized way.
 
     It wraps a tool function, catches HttpError, logs a detailed error message,
     and raises a generic Exception with a user-friendly message.
 
+    If is_read_only is True, it will also catch ssl.SSLError and retry with
+    exponential backoff. After exhausting retries, it raises a TransientNetworkError.
+
     Args:
         tool_name (str): The name of the tool being decorated (e.g., 'list_calendars').
-                         This is used for logging purposes.
+        is_read_only (bool): If True, the operation is considered safe to retry on
+                             transient network errors. Defaults to False.
     """
+
     def decorator(func):
         @functools.wraps(func)
         async def wrapper(*args, **kwargs):
-            try:
-                return await func(*args, **kwargs)
-            except HttpError as error:
-                user_google_email = kwargs.get('user_google_email', 'N/A')
-                message = (
-                    f"API error in {tool_name}: {error}. "
-                    f"You might need to re-authenticate for user '{user_google_email}'. "
-                    f"LLM: Try 'start_google_auth' with the user's email and the appropriate service_name."
-                )
-                logger.error(message, exc_info=True)
-                raise Exception(message)
-            except Exception as e:
-                # Catch any other unexpected errors
-                message = f"An unexpected error occurred in {tool_name}: {e}"
-                logger.exception(message)
-                raise Exception(message)
+            max_retries = 3
+            base_delay = 1
+
+            for attempt in range(max_retries):
+                try:
+                    return await func(*args, **kwargs)
+                except ssl.SSLError as e:
+                    if is_read_only and attempt < max_retries - 1:
+                        delay = base_delay * (2**attempt)
+                        logger.warning(
+                            f"SSL error in {tool_name} on attempt {attempt + 1}: {e}. Retrying in {delay} seconds..."
+                        )
+                        await asyncio.sleep(delay)
+                    else:
+                        logger.error(
+                            f"SSL error in {tool_name} on final attempt: {e}. Raising exception."
+                        )
+                        raise TransientNetworkError(
+                            f"A transient SSL error occurred in '{tool_name}' after {max_retries} attempts. "
+                            "This is likely a temporary network or certificate issue. Please try again shortly."
+                        ) from e
+                except HttpError as error:
+                    user_google_email = kwargs.get("user_google_email", "N/A")
+                    message = (
+                        f"API error in {tool_name}: {error}. "
+                        f"You might need to re-authenticate for user '{user_google_email}'. "
+                        f"LLM: Try 'start_google_auth' with the user's email and the appropriate service_name."
+                    )
+                    logger.error(message, exc_info=True)
+                    raise Exception(message) from error
+                except TransientNetworkError:
+                    # Re-raise without wrapping to preserve the specific error type
+                    raise
+                except Exception as e:
+                    message = f"An unexpected error occurred in {tool_name}: {e}"
+                    logger.exception(message)
+                    raise Exception(message) from e
+
         return wrapper
+
     return decorator

gcalendar/calendar_tools.py

@@ -12,6 +12,7 @@ from typing import List, Optional, Dict, Any
 
 from mcp import types
 from googleapiclient.errors import HttpError
+from googleapiclient.discovery import build
 
 from auth.service_decorator import require_google_service
 from core.utils import handle_http_errors
@@ -79,8 +80,8 @@ def _correct_time_format_for_api(
 
 
 @server.tool()
+@handle_http_errors("list_calendars", is_read_only=True)
 @require_google_service("calendar", "calendar_read")
-@handle_http_errors("list_calendars")
 async def list_calendars(service, user_google_email: str) -> str:
     """
     Retrieves a list of calendars accessible to the authenticated user.
@@ -113,8 +114,8 @@ async def list_calendars(service, user_google_email: str) -> str:
 
 
 @server.tool()
+@handle_http_errors("get_events", is_read_only=True)
 @require_google_service("calendar", "calendar_read")
-@handle_http_errors("get_events")
 async def get_events(
     service,
     user_google_email: str,
@@ -201,8 +202,8 @@ async def get_events(
 
 
 @server.tool()
-@require_google_service("calendar", "calendar_events")
 @handle_http_errors("create_event")
+@require_google_service("calendar", "calendar_events")
 async def create_event(
     service,
     user_google_email: str,
@@ -268,7 +269,6 @@ async def create_event(
     if attachments:
         # Accept both file URLs and file IDs. If a URL, extract the fileId.
         event_body["attachments"] = []
-        from googleapiclient.discovery import build
         drive_service = None
         try:
             drive_service = service._http and build("drive", "v3", http=service._http)
@@ -326,8 +326,8 @@ async def create_event(
 
 
 @server.tool()
-@require_google_service("calendar", "calendar_events")
 @handle_http_errors("modify_event")
+@require_google_service("calendar", "calendar_events")
 async def modify_event(
     service,
     user_google_email: str,
@@ -446,8 +446,8 @@ async def modify_event(
 
 
 @server.tool()
-@require_google_service("calendar", "calendar_events")
 @handle_http_errors("delete_event")
+@require_google_service("calendar", "calendar_events")
 async def delete_event(service, user_google_email: str, event_id: str, calendar_id: str = "primary") -> str:
     """
     Deletes an existing event.
@@ -500,8 +500,8 @@ async def delete_event(service, user_google_email: str, event_id: str, calendar_
 
 
 @server.tool()
+@handle_http_errors("get_event", is_read_only=True)
 @require_google_service("calendar", "calendar_read")
-@handle_http_errors("get_event")
 async def get_event(
     service,
     user_google_email: str,

gdocs/docs_tools.py

@@ -9,7 +9,6 @@ import io
 from typing import List
 
 from mcp import types
-from googleapiclient.errors import HttpError
 from googleapiclient.http import MediaIoBaseDownload
 
 # Auth & server utilities
@@ -21,8 +20,8 @@ from core.comments import create_comment_tools
 logger = logging.getLogger(__name__)
 
 @server.tool()
+@handle_http_errors("search_docs", is_read_only=True)
 @require_google_service("drive", "drive_read")
-@handle_http_errors("search_docs")
 async def search_docs(
     service,
     user_google_email: str,
@@ -58,11 +57,11 @@ async def search_docs(
     return "\n".join(output)
 
 @server.tool()
+@handle_http_errors("get_doc_content", is_read_only=True)
 @require_multiple_services([
     {"service_type": "drive", "scopes": "drive_read", "param_name": "drive_service"},
     {"service_type": "docs", "scopes": "docs_read", "param_name": "docs_service"}
 ])
-@handle_http_errors("get_doc_content")
 async def get_doc_content(
     drive_service,
     docs_service,
@@ -158,8 +157,8 @@ async def get_doc_content(
     return header + body_text
 
 @server.tool()
+@handle_http_errors("list_docs_in_folder", is_read_only=True)
 @require_google_service("drive", "drive_read")
-@handle_http_errors("list_docs_in_folder")
 async def list_docs_in_folder(
     service,
     user_google_email: str,
@@ -190,8 +189,8 @@ async def list_docs_in_folder(
     return "\n".join(out)
 
 @server.tool()
-@require_google_service("docs", "docs_write")
 @handle_http_errors("create_doc")
+@require_google_service("docs", "docs_write")
 async def create_doc(
     service,
     user_google_email: str,

gdrive/drive_tools.py

@@ -76,8 +76,8 @@ def _build_drive_list_params(
     return list_params
 
 @server.tool()
+@handle_http_errors("search_drive_files", is_read_only=True)
 @require_google_service("drive", "drive_read")
-@handle_http_errors("search_drive_files")
 async def search_drive_files(
     service,
     user_google_email: str,
@@ -143,8 +143,8 @@ async def search_drive_files(
     return text_output
 
 @server.tool()
+@handle_http_errors("get_drive_file_content", is_read_only=True)
 @require_google_service("drive", "drive_read")
-@handle_http_errors("get_drive_file_content")
 async def get_drive_file_content(
     service,
     user_google_email: str,
@@ -200,7 +200,7 @@ async def get_drive_file_content(
         "application/vnd.openxmlformats-officedocument.presentationml.presentation",
         "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
     }
-    
+
     if mime_type in office_mime_types:
         office_text = extract_office_xml_text(file_content_bytes, mime_type)
         if office_text:
@@ -233,8 +233,8 @@ async def get_drive_file_content(
 
 
 @server.tool()
+@handle_http_errors("list_drive_items", is_read_only=True)
 @require_google_service("drive", "drive_read")
-@handle_http_errors("list_drive_items")
 async def list_drive_items(
     service,
     user_google_email: str,
@@ -289,8 +289,8 @@ async def list_drive_items(
     return text_output
 
 @server.tool()
-@require_google_service("drive", "drive_file")
 @handle_http_errors("create_drive_file")
+@require_google_service("drive", "drive_file")
 async def create_drive_file(
     service,
     user_google_email: str,