universal-mcp-applications 0.1.27rc3__tar.gz → 0.1.29__tar.gz

{universal_mcp_applications-0.1.27rc3 → universal_mcp_applications-0.1.29}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: universal-mcp-applications
-Version: 0.1.27rc3
+Version: 0.1.29
 Summary: A Universal MCP Application: universal_mcp_applications
 Project-URL: Homepage, https://github.com/universal-mcp/applications
 Project-URL: Repository, https://github.com/universal-mcp/applications

{universal_mcp_applications-0.1.27rc3 → universal_mcp_applications-0.1.29}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "universal-mcp-applications"
-version = "0.1.27-rc3"
+version = "0.1.29"
 description = "A Universal MCP Application: universal_mcp_applications"
 readme = "README.md"
 requires-python = ">=3.11"

{universal_mcp_applications-0.1.27rc3 → universal_mcp_applications-0.1.29}/src/scripts/run_docgen.py

@@ -2,7 +2,7 @@ import os
 import subprocess
 
 APPS = [
-    "onedrive"
+    "scraper",
 ]
 
 

{universal_mcp_applications-0.1.27rc3 → universal_mcp_applications-0.1.29}/src/tests/test_applications.py

@@ -70,10 +70,10 @@ ALL_APPS = [
     "sendgrid",
     "sentry",
     "serpapi",
-    "sharepoint",  # not seeded
+    "sharepoint",
     "shopify",
     "shortcut",
-    "slack",  # not seeded
+    "slack",
     "spotify",  # not seeded
     "supabase",
     "tavily",

{universal_mcp_applications-0.1.27rc3 → universal_mcp_applications-0.1.29}/src/universal_mcp/applications/google_gemini/app.py

@@ -62,9 +62,9 @@ class GoogleGeminiApp(APIApplication):
     async def generate_image(
         self,
         prompt: Annotated[str, "The prompt to generate image from"],
-        images: Annotated[list[str], "The reference images path"] | None = None,
+        images: Annotated[list[str], "The reference image URLs"] | None = None, 
         model: str = "gemini-2.5-flash-image-preview",
-    ) -> list:
+    ) -> dict:
         """
         Generates an image based on a text prompt and an optional reference image using the Google Gemini model.
         This tool is ideal for creating visual content or modifying existing images based on natural language descriptions.
@@ -72,7 +72,7 @@ class GoogleGeminiApp(APIApplication):
 
         Args:
             prompt (str): The descriptive text prompt to guide the image generation. For example: "A futuristic city at sunset with flying cars."
-            images (list[str], optional): An optional list of URL to a reference image. These images will be used as a basis for the generation.
+            images (list[str], optional): An optional list of URLs to reference images. These images will be used as a basis for the generation.
             model (str, optional): The Gemini model to use for image generation. Defaults to "gemini-2.5-flash-image-preview".
 
         Returns:

{universal_mcp_applications-0.1.27rc3 → universal_mcp_applications-0.1.29}/src/universal_mcp/applications/onedrive/README.md

@@ -1,10 +1,10 @@
-# OneDriveApp MCP Server
+# OnedriveApp MCP Server
 
-An MCP Server for the OneDriveApp API.
+An MCP Server for the OnedriveApp API.
 
 ## 🛠️ Tool List
 
-This is automatically generated from OpenAPI schema for the OneDriveApp API.
+This is automatically generated from OpenAPI schema for the OnedriveApp API.
 
 
 | Tool | Description |
@@ -21,4 +21,4 @@ This is automatically generated from OpenAPI schema for the OneDriveApp API.
 | `list_files` | Retrieves a list of files within a specified OneDrive folder, defaulting to the root. Unlike `_list_drive_items` which fetches all items, this function filters the results to exclusively return items identified as files, excluding any subdirectories. |
 | `create_folder_and_list` | Performs a composite action: creates a new folder, then lists all items (files and folders) within that parent directory. This confirms creation by returning the parent's updated contents, distinct from `create_folder` which only returns the new folder's metadata. |
 | `upload_text_file` | Creates and uploads a new file to OneDrive directly from a string of text content. Unlike `upload_file`, which requires a local file path, this function is specifically for creating a text file from in-memory string data, with a customizable name and destination folder. |
-| `get_document_content` | Retrieves the content of a file specified by its ID. It automatically detects if the file is text or binary; text content is returned as a string, while binary content is returned base64-encoded. This differs from `download_file`, which only provides a URL. |
+| `get_document_content` | Retrieves the content of a specific file by its item ID and returns it directly as base64-encoded data. This function is distinct from `download_file`, which only provides a temporary URL for the content, and from `get_item_metadata`, which returns file attributes without the content itself. The function fetches the content by following the file's pre-authenticated download URL. |

{universal_mcp_applications-0.1.27rc3 → universal_mcp_applications-0.1.29}/src/universal_mcp/applications/onedrive/app.py

@@ -272,7 +272,7 @@ class OnedriveApp(APIApplication):
 
     def get_document_content(self, item_id: str) -> dict[str, Any]:
         """
-        Retrieves the content of a file from OneDrive and formats it as a dictionary, similar to an email attachment.
+        Retrieves the content of a specific file by its item ID and returns it directly as base64-encoded data. This function is distinct from `download_file`, which only provides a temporary URL for the content, and from `get_item_metadata`, which returns file attributes without the content itself. The function fetches the content by following the file's pre-authenticated download URL.
 
         Args:
             item_id (str): The ID of the file.

universal_mcp_applications-0.1.29/src/universal_mcp/applications/scraper/app.py

@@ -0,0 +1,175 @@
+from dotenv import load_dotenv
+
+load_dotenv()
+
+from typing import Any, Literal
+
+from loguru import logger
+from universal_mcp.applications.application import APIApplication
+from universal_mcp.integrations import Integration
+
+from universal_mcp.applications.unipile import UnipileApp
+
+
+class ScraperApp(APIApplication):
+    """
+    Application for interacting with LinkedIn API.
+    Provides a simplified interface for LinkedIn search operations.
+    """
+
+    def __init__(self, integration: Integration, **kwargs: Any) -> None:
+        super().__init__(name="scraper", integration=integration, **kwargs)
+        if self.integration:
+            credentials = self.integration.get_credentials()
+            self.account_id = credentials.get("account_id")
+            self._unipile_app = UnipileApp(integration=self.integration)
+        else:
+            logger.warning("Integration not found")
+            self.account_id = None
+            self._unipile_app = None
+
+    def linkedin_search(
+        self,
+        category: Literal["people", "companies", "posts", "jobs"],
+        cursor: str | None = None,
+        limit: int | None = None,
+        keywords: str | None = None,
+        date_posted: str | None = None,
+        sort_by: Literal["relevance", "date"] = "relevance",
+        minimum_salary_value: int = 40,
+    ) -> dict[str, Any]:
+        """
+        Performs a general LinkedIn search for posts, people, companies, or jobs using keywords and various filters. This function provides broad, keyword-based discovery across the platform, distinct from other methods that retrieve content from a specific user or company profile. It supports pagination and filtering criteria.
+        
+        Args:
+            category: Type of search to perform. Valid values are "people", "companies", "posts", or "jobs".
+            cursor: Pagination cursor for the next page of entries.
+            limit: Number of items to return (up to 50 for Classic search).
+            keywords: Keywords to search for.
+            date_posted: Filter by when the post was posted (posts only). Valid values are "past_day", "past_week", or "past_month".
+            sort_by: How to sort the results (for posts and jobs). Valid values are "relevance" or "date".
+            minimum_salary_value: The minimum salary to filter for (jobs only).
+        
+        Returns:
+            A dictionary containing search results and pagination details.
+        
+        Raises:
+            httpx.HTTPError: If the API request fails.
+        
+        Tags:
+            linkedin, search, posts, people, companies, api, scrapper, important
+        """
+        return self._unipile_app.search(
+            account_id=self.account_id,
+            category=category,
+            cursor=cursor,
+            limit=limit,
+            keywords=keywords,
+            date_posted=date_posted,
+            sort_by=sort_by,
+            minimum_salary_value=minimum_salary_value,
+        )
+
+    def linkedin_list_profile_posts(
+        self,
+        identifier: str,
+        cursor: str | None = None,
+        limit: int | None = None,
+    ) -> dict[str, Any]:
+        """
+        Fetches a paginated list of all posts from a specific user or company profile using their unique identifier. This function retrieves content directly from a single profile, unlike the broader, keyword-based `linkedin_search` which searches across the entire LinkedIn platform.
+        
+        Args:
+            identifier: The entity's provider internal ID (LinkedIn ID).starts with ACo for users, while for companies it's a series of numbers. You can get it in the results of linkedin_search.
+            cursor: Pagination cursor for the next page of entries.
+            limit: Number of items to return (1-100, though spec allows up to 250).
+        
+        Returns:
+            A dictionary containing a list of post objects and pagination details.
+        
+        Raises:
+            httpx.HTTPError: If the API request fails.
+        
+        Tags:
+            linkedin, post, list, user_posts, company_posts, content, api, important
+        """
+
+        return self._unipile_app.list_profile_posts(
+            identifier=identifier,
+            account_id=self.account_id,
+            cursor=cursor,
+            limit=limit,
+        )
+
+    def linkedin_retrieve_profile(
+        self,
+        identifier: str,
+    ) -> dict[str, Any]:
+        """
+        Retrieves a specific LinkedIn user's profile using their unique identifier (e.g., public username). Unlike other methods that list posts or comments, this function focuses on fetching the user's core profile data by delegating the request to the integrated Unipile application.
+        
+        Args:
+            identifier: Use the id from linkedin_search results. It starts with ACo for users and is a series of numbers for companies.
+        
+        Returns:
+            A dictionary containing the user's profile details.
+        
+        Raises:
+            httpx.HTTPError: If the API request fails.
+        
+        Tags:
+            linkedin, user, profile, retrieve, get, api, important
+        """
+
+        return self._unipile_app.retrieve_user_profile(
+            identifier=identifier,
+            account_id=self.account_id,
+        )
+
+    def linkedin_list_post_comments(
+        self,
+        post_id: str,
+        comment_id: str | None = None,
+        cursor: str | None = None,
+        limit: int | None = None,
+    ) -> dict[str, Any]:
+        """
+        Fetches a paginated list of comments for a specified LinkedIn post. Providing a `comment_id` retrieves replies to that specific comment instead of top-level ones. This function exclusively targets post interactions, differentiating it from others that list posts or retrieve entire profiles.
+        
+        Args:
+            post_id: The social ID of the post. Example urn:li:ugcPost:7386500271624896512
+            comment_id: If provided, retrieves replies to this comment ID instead of top-level comments.
+            cursor: Pagination cursor.
+            limit: Number of comments to return.
+        
+        Returns:
+            A dictionary containing a list of comment objects and pagination details.
+        
+        Raises:
+            httpx.HTTPError: If the API request fails.
+        
+        Tags:
+            linkedin, post, comment, list, content, api, important
+        """
+
+        return self._unipile_app.list_post_comments(
+            post_id=post_id,
+            account_id=self.account_id,
+            comment_id=comment_id,
+            cursor=cursor,
+            limit=limit,
+        )
+
+    def list_tools(self):
+        """
+        Returns a list of available tools/functions in this application.
+
+        Returns:
+            A list of functions that can be used as tools.
+        """
+        return [
+            self.linkedin_search,
+            self.linkedin_list_profile_posts,
+            self.linkedin_retrieve_profile,
+            self.linkedin_list_post_comments,
+        ]

universal_mcp_applications-0.1.29/src/universal_mcp/applications/sharepoint/README.md

@@ -0,0 +1,19 @@
+# SharePoint Application
+
+This application provides tools for interacting with the Microsoft SharePoint API via Microsoft Graph. It allows you to manage files, folders, and retrieve information about your SharePoint drive.
+
+## Available Tools
+
+-   `get_my_profile`: Fetches the profile for the currently authenticated user.
+-   `get_drive_info`: Fetches high-level information about the user's SharePoint drive.
+-   `search_files`: Searches for files and folders in the user's SharePoint.
+-   `get_item_metadata`: Fetches metadata for a specific file or folder.
+-   `create_folder`: Creates a new folder.
+-   `delete_item`: Deletes a file or folder.
+-   `download_file`: Retrieves a download URL for a file.
+-   `upload_file`: Uploads a local file.
+-   `list_folders`: Lists all folders in a specified directory.
+-   `list_files`: Lists all files in a specified directory.
+-   `create_folder_and_list`: Creates a folder and then lists the contents of the parent directory.
+-   `upload_text_file`: Uploads content from a string to a new text file.
+-   `get_document_content`: Retrieves the content of a file.

universal_mcp_applications-0.1.29/src/universal_mcp/applications/sharepoint/app.py

@@ -0,0 +1,338 @@
+import base64
+import os
+from typing import Any
+
+from loguru import logger
+from universal_mcp.applications.application import APIApplication
+from universal_mcp.integrations import Integration
+
+
+class SharepointApp(APIApplication):
+    """
+    Application for interacting with Microsoft SharePoint API (via Microsoft Graph).
+    Provides tools to manage files, folders, and access Drive information.
+    """
+
+    def __init__(self, integration: Integration | None = None, **kwargs) -> None:
+        super().__init__(name="sharepoint", integration=integration, **kwargs)
+        self.base_url = "https://graph.microsoft.com/v1.0"
+
+    def get_my_profile(self) -> dict[str, Any]:
+        """
+        Fetches the profile for the currently authenticated user, specifically retrieving their ID and user principal name. This function confirms user identity, distinguishing it from `get_drive_info`, which returns details about the SharePoint storage space (e.g., quota) rather than the user's personal profile.
+
+        Returns:
+            dict[str, Any]: A dictionary containing the user's id and userPrincipalName.
+
+        Raises:
+            HTTPStatusError: If the API request fails.
+
+        Tags:
+            profile, user, account
+        """
+        url = f"{self.base_url}/me"
+        query_params = {"$select": "id,userPrincipalName"}
+        response = self._get(url, params=query_params)
+        return self._handle_response(response)
+
+    def get_drive_info(self) -> dict[str, Any]:
+        """
+        Fetches high-level information about the user's entire SharePoint. It returns drive-wide details like the owner and storage quota, differing from `get_item_metadata` which describes a specific item, and `get_my_profile` which retrieves general user account information.
+
+        Returns:
+            A dictionary containing drive information.
+
+        Tags:
+            drive, storage, quota, info
+        """
+        url = f"{self.base_url}/me/drive"
+        response = self._get(url)
+        return self._handle_response(response)
+
+    def _list_drive_items(self, item_id: str = "root") -> dict[str, Any]:
+        """
+        Lists the files and folders in the current user's SharePoint.
+
+        Args:
+            item_id (str, optional): The ID of the folder to list. Defaults to 'root'.
+
+        Returns:
+            A dictionary containing the list of files and folders.
+        """
+        url = f"{self.base_url}/me/drive/items/{item_id}/children"
+        response = self._get(url)
+        return self._handle_response(response)
+
+    def search_files(self, query: str) -> dict[str, Any]:
+        """
+        Searches the user's entire SharePoint for files and folders matching a specified text query. This function performs a comprehensive search from the drive's root, distinguishing it from `list_files` or `list_folders` which only browse the contents of a single directory.
+
+        Args:
+            query (str): The search query.
+
+        Returns:
+            A dictionary containing the search results.
+
+        Tags:
+            search, find, query, files, important
+        """
+        if not query:
+            raise ValueError("Search query cannot be empty.")
+
+        url = f"{self.base_url}/me/drive/root/search(q='{query}')"
+        response = self._get(url)
+        return self._handle_response(response)
+
+    def get_item_metadata(self, item_id: str) -> dict[str, Any]:
+        """
+        Fetches detailed metadata for a specific file or folder using its unique ID. It returns properties like name, size, and type. Unlike `get_document_content`, it doesn't retrieve the file's actual content, focusing solely on the item's attributes for quick inspection without a full download.
+
+        Args:
+            item_id (str): The ID of the file or folder.
+
+        Returns:
+            A dictionary containing the item's metadata.
+
+        Tags:
+            metadata, info, file, folder
+        """
+        if not item_id:
+            raise ValueError("Missing required parameter 'item_id'.")
+
+        url = f"{self.base_url}/me/drive/items/{item_id}"
+        response = self._get(url)
+        return self._handle_response(response)
+
+    def create_folder(self, name: str, parent_id: str = "root") -> dict[str, Any]:
+        """
+        Creates a new folder with a specified name within a parent directory, which defaults to the root. Returns metadata for the new folder. Unlike `create_folder_and_list`, this function only creates the folder and returns its specific metadata, not the parent directory's contents.
+
+        Args:
+            name (str): The name of the new folder.
+            parent_id (str, optional): The ID of the parent folder. Defaults to 'root'.
+
+        Returns:
+            A dictionary containing the new folder's metadata.
+
+        Tags:
+            create, folder, directory, important
+        """
+        if not name:
+            raise ValueError("Folder name cannot be empty.")
+
+        url = f"{self.base_url}/me/drive/items/{parent_id}/children"
+        data = {"name": name, "folder": {}, "@microsoft.graph.conflictBehavior": "rename"}
+        response = self._post(url, data=data)
+        return self._handle_response(response)
+
+    def delete_item(self, item_id: str) -> dict[str, Any]:
+        """
+        Permanently deletes a specified file or folder from SharePoint using its unique item ID. This versatile function can remove any type of drive item, distinguished from functions that only list or create specific types. A successful deletion returns an empty response, confirming the item's removal.
+
+        Args:
+            item_id (str): The ID of the item to delete.
+
+        Returns:
+            An empty dictionary if successful.
+
+        Tags:
+            delete, remove, file, folder, important
+        """
+        if not item_id:
+            raise ValueError("Missing required parameter 'item_id'.")
+
+        url = f"{self.base_url}/me/drive/items/{item_id}"
+        response = self._delete(url)
+        return self._handle_response(response)
+
+    def download_file(self, item_id: str) -> dict[str, Any]:
+        """
+        Retrieves a temporary, pre-authenticated download URL for a specific file using its item ID. This function provides a link for subsequent download, differing from `get_document_content` which directly fetches the file's raw content. The URL is returned within a dictionary.
+
+        Args:
+            item_id (str): The ID of the file to download.
+
+        Returns:
+            A dictionary containing the download URL for the file under the key '@microsoft.graph.downloadUrl'.
+
+        Tags:
+            download, file, get, important
+        """
+        if not item_id:
+            raise ValueError("Missing required parameter 'item_id'.")
+
+        url = f"{self.base_url}/me/drive/items/{item_id}"
+        response = self._get(url)
+        metadata = self._handle_response(response)
+        download_url = metadata.get("@microsoft.graph.downloadUrl")
+        if not download_url:
+            raise ValueError("Could not retrieve download URL for the item.")
+        return {"download_url": download_url}
+
+    def upload_file(self, file_path: str, parent_id: str = "root", file_name: str | None = None) -> dict[str, Any]:
+        """
+        Uploads a local binary file (under 4MB) from a given path to a specified SharePoint folder. Unlike `upload_text_file`, which uploads string content, this function reads from the filesystem. The destination filename can be customized, and it returns the new file's metadata upon completion.
+
+        Args:
+            file_path (str): The local path to the file to upload.
+            parent_id (str, optional): The ID of the folder to upload the file to. Defaults to 'root'.
+            file_name (str, optional): The name to give the uploaded file. If not provided, the local filename is used.
+
+        Returns:
+            A dictionary containing the uploaded file's metadata.
+
+        Tags:
+            upload, file, put, important
+        """
+        if not os.path.exists(file_path):
+            raise FileNotFoundError(f"The file was not found at path: {file_path}")
+
+        if not file_name:
+            file_name = os.path.basename(file_path)
+
+        url = f"{self.base_url}/me/drive/items/{parent_id}:/{file_name}:/content"
+        with open(file_path, "rb") as f:
+            data = f.read()
+        response = self._put(url, data=data, content_type="application/octet-stream")
+        return self._handle_response(response)
+
+    def list_folders(self, item_id: str = "root") -> dict[str, Any]:
+        """
+        Retrieves a list of only the folders within a specified parent directory in SharePoint. Unlike `_list_drive_items` which returns all items, this function filters the results to exclude files. Defaults to the root directory if no parent `item_id` is provided.
+
+        Args:
+            item_id (str, optional): The ID of the folder to list from. Defaults to 'root'.
+
+        Returns:
+            A dictionary containing the list of folders.
+
+        Tags:
+            list, folders, directories, important
+        """
+        all_items = self._list_drive_items(item_id=item_id)
+        folders = [item for item in all_items.get("value", []) if "folder" in item]
+        return {"value": folders}
+
+    def list_files(self, item_id: str = "root") -> dict[str, Any]:
+        """
+        Retrieves a list of files within a specified SharePoint folder, defaulting to the root. Unlike `_list_drive_items` which fetches all items, this function filters the results to exclusively return items identified as files, excluding any subdirectories.
+
+        Args:
+            item_id (str, optional): The ID of the folder to list files from. Defaults to 'root'.
+
+        Returns:
+            A dictionary containing the list of files.
+
+        Tags:
+            list, files, documents, important
+        """
+        all_items = self._list_drive_items(item_id=item_id)
+        files = [item for item in all_items.get("value", []) if "file" in item]
+        return {"value": files}
+
+    def create_folder_and_list(self, name: str, parent_id: str = "root") -> dict[str, Any]:
+        """
+        Performs a composite action: creates a new folder, then lists all items (files and folders) within that parent directory. This confirms creation by returning the parent's updated contents, distinct from `create_folder` which only returns the new folder's metadata.
+
+        Args:
+            name (str): The name of the new folder.
+            parent_id (str, optional): The ID of the parent folder. Defaults to 'root'.
+
+        Returns:
+            A dictionary containing the list of items in the parent folder after creation.
+
+        Tags:
+            create, folder, list, important
+        """
+        self.create_folder(name=name, parent_id=parent_id)
+        return self._list_drive_items(item_id=parent_id)
+
+    def upload_text_file(self, content: str, parent_id: str = "root", file_name: str = "new_file.txt") -> dict[str, Any]:
+        """
+        Creates and uploads a new file to SharePoint directly from a string of text content. Unlike `upload_file`, which requires a local file path, this function is specifically for creating a text file from in-memory string data, with a customizable name and destination folder.
+
+        Args:
+            content (str): The text content to upload.
+            parent_id (str, optional): The ID of the folder to upload the file to. Defaults to 'root'.
+            file_name (str, optional): The name to give the uploaded file. Defaults to 'new_file.txt'.
+
+        Returns:
+            A dictionary containing the uploaded file's metadata.
+
+        Tags:
+            upload, text, file, create, important
+        """
+        if not file_name:
+            raise ValueError("File name cannot be empty.")
+
+        url = f"{self.base_url}/me/drive/items/{parent_id}:/{file_name}:/content"
+        data = content.encode("utf-8")
+        response = self._put(url, data=data, content_type="text/plain")
+        return self._handle_response(response)
+
+    def get_document_content(self, item_id: str) -> dict[str, Any]:
+        """
+        Retrieves the content of a specific file by its item ID and returns it directly as base64-encoded data. This function is distinct from `download_file`, which only provides a temporary URL for the content, and from `get_item_metadata`, which returns file attributes without the content itself. The function fetches the content by following the file's pre-authenticated download URL.
+
+        Args:
+            item_id (str): The ID of the file.
+
+        Returns:
+            dict[str, Any]: A dictionary containing the file details:
+                - 'type' (str): The general type of the file (e.g., "image", "audio", "video", "file").
+                - 'data' (str): The base64 encoded content of the file.
+                - 'mime_type' (str): The MIME type of the file.
+                - 'file_name' (str): The name of the file.
+
+        Tags:
+            get, content, read, file, important
+        """
+        if not item_id:
+            raise ValueError("Missing required parameter 'item_id'.")
+
+        metadata = self.get_item_metadata(item_id=item_id)
+        file_metadata = metadata.get("file")
+        if not file_metadata:
+            raise ValueError(f"Item with ID '{item_id}' is not a file.")
+
+        file_mime_type = file_metadata.get("mimeType", "application/octet-stream")
+        file_name = metadata.get("name")
+
+        download_url = metadata.get("@microsoft.graph.downloadUrl")
+        if not download_url:
+            logger.error(f"Could not find @microsoft.graph.downloadUrl in metadata for item {item_id}")
+            raise ValueError("Could not retrieve download URL for the item.")
+
+        response = self._get(download_url)
+
+        response.raise_for_status()
+
+        content = response.content
+
+        attachment_type = file_mime_type.split("/")[0] if "/" in file_mime_type else "file"
+        if attachment_type not in ["image", "audio", "video", "text"]:
+            attachment_type = "file"
+
+        return {
+            "type": attachment_type,
+            "data": content,
+            "mime_type": file_mime_type,
+            "file_name": file_name,
+        }
+
+    def list_tools(self):
+        return [
+            self.get_drive_info,
+            self.search_files,
+            self.get_item_metadata,
+            self.create_folder,
+            self.delete_item,
+            self.download_file,
+            self.upload_file,
+            self.get_my_profile,
+            self.list_folders,
+            self.list_files,
+            self.create_folder_and_list,
+            self.upload_text_file,
+            self.get_document_content,
+        ]