diff --git a/README.md b/README.md
index aa6c2fff..f1595cfc 100644
--- a/README.md
+++ b/README.md
@@ -160,6 +160,10 @@ Supports basic HTTP authentication and Bearer token authentication via the SDK.
 
 [instagram](instagram): Comprehensive Instagram Business/Creator integration for managing posts, comments, and insights via the Instagram Graph API v24.0. Supports account information retrieval, content publishing (images, videos, reels, carousels, stories), comment moderation (read, reply, hide/unhide, delete), and advanced analytics for both account and post performance. Features Business Login for Instagram authentication with granular permissions, media container polling for reliable publishing, and support for alt text on images. Includes 8 actions covering account management, content creation, comment engagement, and insights retrieval. Rate limits scale with account reach (4800 × impressions per 24hrs) with 100 posts per day publishing limit.
 
+### Gmail
+
+[gmail](gmail): Comprehensive Gmail integration for sending, reading, searching, labelling, and organising email messages, threads, and drafts via the Gmail API v1. Supports plain-text and rich-HTML messages with attachments (HTML sanitised via `bleach` with auto-generated plain-text fallback), thread replies, full draft lifecycle (create/update/list/get/send/delete), label management (list/create/apply/remove/list-by-label), inbox and all-mail listing with read/unread filtering, batch mark-as-read/unread, and archive operations. Pagination supported on every list endpoint via `nextPageToken`. Uses Google platform OAuth 2.0 with the `gmail.modify` scope. Includes 21 actions across messages, threads, drafts, and labels.
+
 ### Google Calendar
 
 [google-calendar](google-calendar): Integrates with Google Calendar API for comprehensive calendar and event management within Autohive workflows. Supports listing accessible calendars, creating and managing calendar events (both timed and all-day), attendee management, and event lifecycle operations. Features secure OAuth2 authentication and pagination support for large event datasets.
diff --git a/gmail/README.md b/gmail/README.md
new file mode 100644
index 00000000..35f29161
--- /dev/null
+++ b/gmail/README.md
@@ -0,0 +1,152 @@
+# Gmail Integration for Autohive
+
+Connects Autohive to the Gmail API to send, read, search, label, and organise email messages, threads, and drafts on behalf of an authenticated user.
+
+## Description
+
+This integration provides comprehensive Gmail functionality through Google's Gmail API v1. It supports the full email lifecycle — composing and sending plain-text or HTML messages with attachments, reading and replying to threads, managing drafts, applying and removing labels, and archiving messages.
+
+HTML email bodies are sanitised with [`bleach`](https://github.com/mozilla/bleach) before sending to prevent XSS and to strip disallowed tags/attributes/protocols. A plain-text fallback is generated automatically from the sanitised HTML for maximum email-client compatibility.
+
+Key features:
+
+- Send plain-text or rich-HTML email with attachments, CC, and BCC
+- Reply to threads with automatic recipient and subject handling
+- Draft lifecycle: create, update, list, get, send, delete
+- Read inbox / all mail with read/unread filtering and pagination
+- Read full threads and individual messages (with body, headers, and attachments)
+- Label management: list, create, apply, remove, list-by-label
+- Archive and mark as read/unread in batch
+- Pagination via `nextPageToken` on all list endpoints
+
+## Setup & Authentication
+
+The integration uses Google's platform OAuth 2.0 authentication. Users authenticate through the Google OAuth flow inside Autohive to grant access to their Gmail account.
+
+**Authentication Type:** Platform (Gmail)
+
+**Required Scopes:**
+
+- `https://www.googleapis.com/auth/gmail.modify` — read, compose, send, and permanently delete email is **not** included; the scope allows full mailbox modification (labels, drafts, sending) but excludes permanent deletion of messages.
+
+No additional configuration fields are required as authentication is handled through Google's OAuth 2.0 flow.
+
+## Actions
+
+The integration exposes 21 actions across messages, threads, drafts, and labels.
+
+### Messages
+
+| Action | Description |
+|---|---|
+| `send_email` | Send a new email (text or HTML) with optional CC/BCC and attachments |
+| `read_email` | Retrieve a single message by ID, including body, headers, and attachments |
+| `read_inbox` | List inbox messages, filtered by read/unread, with pagination |
+| `read_all_mail` | List messages across the entire mailbox with read/unread filtering and pagination |
+| `mark_emails_as_read` | Mark one or more messages as read |
+| `mark_emails_as_unread` | Mark one or more messages as unread |
+| `archive_emails` | Remove messages from the inbox (archive) |
+| `get_user_info` | Get profile information for the authenticated Gmail user |
+
+### Threads
+
+| Action | Description |
+|---|---|
+| `reply_to_thread` | Reply to an existing thread, with text/HTML body, attachments, and optional additional recipients |
+| `get_thread_emails` | Retrieve all messages in a thread |
+
+### Drafts
+
+| Action | Description |
+|---|---|
+| `create_draft` | Create a new draft, optionally as a reply to a thread/message |
+| `update_draft` | Update an existing draft |
+| `list_drafts` | List drafts with optional Gmail-search-syntax query and pagination |
+| `get_draft` | Retrieve a single draft by ID |
+| `send_draft` | Send a previously created draft |
+| `delete_draft` | Delete a draft |
+
+### Labels
+
+| Action | Description |
+|---|---|
+| `list_labels` | List all labels in the mailbox |
+| `create_label` | Create a new user label |
+| `add_labels_to_emails` | Apply one or more labels to one or more messages |
+| `remove_labels_from_emails` | Remove one or more labels from one or more messages |
+| `list_emails_by_label` | List messages with a given label, paginated |
+
+See [`config.json`](config.json) for the full input/output schema of every action.
+
+## HTML Email Notes
+
+When `body_format` is `"html"` on `send_email` / `reply_to_thread` / `create_draft`:
+
+- The HTML body is sanitised by `bleach` against an allow-list of tags, attributes, and protocols.
+- **Do not** include `<style>` blocks or `<script>` — they are stripped. Use inline `style="..."` attributes instead.
+- A plain-text version is generated automatically from the sanitised HTML and sent as the `text/plain` alternative.
+
+## Requirements
+
+Pinned in [`requirements.txt`](requirements.txt):
+
+- `autohive-integrations-sdk~=1.0.2`
+- `google-api-python-client`
+- `google-auth-httplib2`
+- `google-auth-oauthlib`
+- `html2text`
+- `bleach`
+
+## Usage Examples
+
+**Example 1: Send an HTML email with an attachment**
+
+```json
+{
+  "to": ["alice@example.com"],
+  "cc": ["bob@example.com"],
+  "subject": "Q3 report",
+  "body": "<p>Hi Alice,</p><p>Please find the Q3 report attached.</p>",
+  "body_format": "html",
+  "files": [
+    {
+      "name": "q3-report.pdf",
+      "contentType": "application/pdf",
+      "content": "JVBERi0xLjQK..."
+    }
+  ]
+}
+```
+
+**Example 2: Reply to a thread**
+
+```json
+{
+  "thread_id": "18dc14a8b32cb7e3",
+  "message_id": "18dc14a8b32cb7e3",
+  "body": "Thanks — confirmed on our side."
+}
+```
+
+**Example 3: List unread inbox messages, page through results**
+
+```json
+{
+  "user_id": "me",
+  "scope": "unread"
+}
+```
+
+Then on the next call, pass the `nextPageToken` from the previous response:
+
+```json
+{
+  "user_id": "me",
+  "scope": "unread",
+  "pageToken": "0987654321"
+}
+```
+
+## Testing
+
+The `tests/` directory follows the public repo testing pattern. Unit tests (`test_*_unit.py`) are auto-discovered by pytest and run in CI; integration tests (`test_*_integration.py`) require live credentials and are opt-in. See the SDK's [writing-unit-tests](https://github.com/autohive-ai/integrations-sdk/blob/master/skills/writing-unit-tests/SKILL.md) and [writing-integration-tests](https://github.com/autohive-ai/integrations-sdk/blob/master/skills/writing-integration-tests/SKILL.md) skills for the full pattern.
diff --git a/gmail/__init__.py b/gmail/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/gmail/config.json b/gmail/config.json
new file mode 100644
index 00000000..5e604c24
--- /dev/null
+++ b/gmail/config.json
@@ -0,0 +1,1746 @@
+{
+    "name": "Gmail",
+    "display_name": "Gmail",
+    "version": "0.1.0",
+    "description": "Send, read, and manage emails with labels and threads.",
+    "entry_point": "gmail.py",
+    "auth": {
+        "type": "platform",
+        "provider": "gmail",
+        "scopes": [
+            "https://www.googleapis.com/auth/gmail.modify"
+        ]
+    },
+    "actions": {
+        "reply_to_thread": {
+            "display_name": "Reply to Email Thread",
+            "description": "Reply to an existing email thread",
+            "input_schema": {
+                "type": "object",
+                "properties": {
+                    "user_id": {
+                        "type": "string",
+                        "description": "The user's email address. Special value 'me' indicates the authenticated user."
+                    },
+                    "thread_id": {
+                        "type": "string",
+                        "description": "The ID of the thread to reply to"
+                    },
+                    "message_id": {
+                        "type": "string",
+                        "description": "The ID of the message being replied to"
+                    },
+                    "to": {
+                        "type": "array",
+                        "description": "Additional recipients to include in the reply",
+                        "items": {
+                            "type": "string",
+                            "description": "Email address of a recipient"
+                        }
+                    },
+                    "cc": {
+                        "type": "array",
+                        "description": "The email addresses to CC in the reply",
+                        "items": {
+                            "type": "string",
+                            "description": "Email address to CC"
+                        }
+                    },
+                    "body": {
+                        "type": "string",
+                        "description": "The body of the reply"
+                    },
+                    "body_format": {
+                        "type": "string",
+                        "description": "Format of the reply body content. When set to 'html', the body parameter will be treated as HTML content and the reply will be sent as a rich HTML email with automatic plain text fallback for maximum compatibility. When set to 'text' (default), the body will be sent as plain text. LLMs can use 'html' to generate well-formatted replies with styling, links, tables, headers, lists, and other rich formatting elements. When using 'html' format, NEVER include CSS rule blocks (like <style> tags) in the body - instead use the 'style' attribute directly on HTML tags for styling (e.g., <p style=\"color: red;\">).",
+                        "enum": ["text", "html"],
+                        "default": "text"
+                    },
+                    "files": {
+                        "type": "array",
+                        "description": "List of files to attach to the reply",
+                        "items": {
+                            "type": "object",
+                            "properties": {
+                                "name": {
+                                    "type": "string",
+                                    "description": "Name of the file to attach to the reply"
+                                },
+                                "contentType": {
+                                    "type": "string",
+                                    "description": "The MIME type of the file"
+                                },
+                                "content": {
+                                    "type": "string",
+                                    "description": "The file content encoded as base64"
+                                }
+                            },
+                            "required": ["name", "contentType", "content"]
+                        }
+                    }
+                },
+                "required": [
+                    "thread_id",
+                    "message_id",
+                    "body"
+                ]
+            },
+            "output_schema": {
+                "type": "object",
+                "properties": {
+                    "id": {
+                        "type": "string",
+                        "description": "The ID of the sent reply"
+                    },
+                    "result": {
+                        "type": "boolean",
+                        "description": "The result of the reply send operation"
+                    },
+                    "error": {
+                        "type": "string",
+                        "description": "Error message if the action failed"
+                    }
+                },
+                "required": [
+                    "id",
+                    "result"
+                ]
+            }
+        },
+
+        "mark_emails_as_unread": {
+            "display_name": "Mark Emails as Unread",
+            "description": "Mark emails as unread",
+            "input_schema": {
+                "type": "object",
+                "properties": {
+                    "user_id": {
+                        "type": "string",
+                        "description": "The user's email address. Special value 'me' indicates the authenticated user."
+                    },
+                    "ids": {
+                        "type": "array",
+                        "description": "The IDs of the emails to mark as unread",
+                        "items": {
+                            "type": "string",
+                            "description": "The ID of the email to mark as unread"
+                        }
+                    }
+                },
+                "required": [
+                    "user_id",
+                    "ids"
+                ]
+            },
+            "output_schema": {
+                "type": "object",
+                "properties": {
+                    "result": {
+                        "type": "boolean",
+                        "description": "The result of the email modification"
+                    },
+                    "error": {
+                        "type": "string",
+                        "description": "Error message if the action failed"
+                    }
+                },
+                "required": [
+                    "result"
+                ]
+            }
+        },
+
+        "mark_emails_as_read": {
+            "display_name": "Mark Emails as Read",
+            "description": "Mark emails as read",
+            "input_schema": {
+                "type": "object",
+                "properties": {
+                    "user_id": {
+                        "type": "string",
+                        "description": "The user's email address. Special value 'me' indicates the authenticated user."
+                    },
+                    "ids": {
+                        "type": "array",
+                        "description": "The IDs of the emails to mark as read",
+                        "items": {
+                            "type": "string",
+                            "description": "The ID of the email to mark as read"
+                        }
+                    }
+                },
+                "required": [
+                    "user_id",
+                    "ids"
+                ]
+            },
+            "output_schema": {
+                "type": "object",
+                "properties": {
+                    "result": {
+                        "type": "boolean",
+                        "description": "The result of the email modification"
+                    },
+                    "error": {
+                        "type": "string",
+                        "description": "Error message if the action failed"
+                    }
+                },
+                "required": [
+                    "result"
+                ]
+            }
+        },
+
+        "get_user_info": {
+            "display_name": "Get User Info",
+            "description": "Get user info",
+            "input_schema": {
+                "type": "object",
+                "properties": {
+                    "user_id": {
+                        "type": "string",
+                        "description": "A user's email address. Special value 'me' indicates the authenticated user."
+                    }
+                },
+                "required": [
+                    "user_id"
+                ]
+            },
+            "output_schema": {
+                "type": "object",
+                "properties": {
+                    "user_info": {
+                        "type": "object",
+                        "description": "The user info",
+                        "properties": {
+                            "email_address": {
+                                "type": "string",
+                                "description": "The user's email address"
+                            },
+                            "messages_total": {
+                                "type": "number",
+                                "description": "The total number of messages in the user's inbox"
+                            },
+                            "threads_total": {
+                                "type": "number",
+                                "description": "The total number of threads in the user's inbox"
+                            },
+                            "history_id": {
+                                "type": "string",
+                                "description": "The history ID of the user's inbox"
+                            }
+                        },
+                        "required": [
+                            "email_address",
+                            "messages_total",
+                            "threads_total",
+                            "history_id"
+                        ]
+                    },
+                    "result": {
+                        "type": "boolean",
+                        "description": "The result of the user info"
+                    },
+                    "error": {
+                        "type": "string",
+                        "description": "Error message if the action failed"
+                    }
+                },
+                "required": [
+                    "user_info",
+                    "result"
+                ]
+            }
+        },
+
+        "read_email": {
+            "display_name": "Read Email",
+            "description": "Read an email",
+            "input_schema": {
+                "type": "object",
+                "properties": {
+                    "email_id": {
+                        "type": "string",
+                        "description": "The ID of the email to read"
+                    },
+                    "user_id": {
+                        "type": "string",
+                        "description": "The user's email address. Special value 'me' indicates the authenticated user."
+                    }
+                },
+                "required": [
+                    "email_id",
+                    "user_id"
+                ]
+            },
+            "output_schema": {
+                "type": "object",
+                "properties": {
+                    "result": {
+                        "type": "boolean",
+                        "description": "The result of the email read"
+                    },
+                    "email": {
+                        "type": "object",
+                        "description": "The email object",
+                        "properties": {
+                            "id": {
+                                "type": "string",
+                                "description": "Unique identifier of the email"
+                            },
+                            "thread_id": {
+                                "type": "string",
+                                "description": "Unique identifier of the thread"
+                            },
+                            "subject": {
+                                "type": "string",
+                                "description": "Subject line of the email"
+                            },
+                            "from": {
+                                "type": "string",
+                                "description": "Sender's email address"
+                            },
+                            "to": {
+                                "type": "string",
+                                "description": "recipients's email address"
+                            },
+                            "cc": {
+                                "type": "array",
+                                "description": "CC recipients' email addresses",
+                                "items": {
+                                    "type": "string",
+                                    "description": "Email address of a CC recipient"
+                                }
+                            },
+                            "date": {
+                                "type": "string",
+                                "description": "Date the email was received"
+                            },
+                            "body": {
+                                "type": "string",
+                                "description": "Body contents of the email"
+                            }
+                        },
+                        "required": [
+                            "id",
+                            "thread_id",
+                            "subject",
+                            "from",
+                            "to",
+                            "date",
+                            "body"
+                        ]
+                    },
+                    "files": {
+                        "type": "array",
+                        "description": "List of files to attach to the email",
+                        "items": {
+                            "type": "object",
+                            "properties": {
+                                "name": {
+                                    "type": "string",
+                                    "description": "Name of the file to attach"
+                                },
+                                "contentType": {
+                                    "type": "string",
+                                    "description": "The MIME type of the file"
+                                },
+                                "content": {
+                                    "type": "string",
+                                    "description": "The file content encoded as base64"
+                                }
+                            },
+                            "required": ["name", "contentType", "content"]
+                        }
+                    },
+                    "error": {
+                        "type": "string",
+                        "description": "Error message if the action failed"
+                    }
+                },
+                "required": [
+                    "email",
+                    "result",
+                    "files"
+                ]
+            }
+        },
+
+        "send_email": {
+            "display_name": "Send Email",
+            "description": "Send an email",
+            "input_schema": {
+                "type": "object",
+                "properties": {
+                    "to": {
+                        "type": "array",
+                        "description": "The email addresses of the recipients",
+                        "items": {
+                            "type": "string",
+                            "description": "Email address of a recipient"
+                        }
+                    },
+                    "cc": {
+                        "type": "array",
+                        "description": "The email addresses to CC",
+                        "items": {
+                            "type": "string",
+                            "description": "Email address to CC"
+                        }
+                    },
+                    "subject": {
+                        "type": "string",
+                        "description": "The subject of the email"
+                    },
+                    "body": {
+                        "type": "string",
+                        "description": "The body of the email"
+                    },
+                    "body_format": {
+                        "type": "string",
+                        "description": "Format of the email body content. When set to 'html', the body parameter will be treated as HTML content and the email will be sent as a rich HTML email with automatic plain text fallback for maximum compatibility. When set to 'text' (default), the body will be sent as plain text. LLMs can use 'html' to generate well-formatted emails with styling, links, tables, headers, lists, and other rich formatting elements. When using 'html' format, NEVER include CSS rule blocks (like <style> tags) in the body - instead use the 'style' attribute directly on HTML tags for styling (e.g., <p style=\"color: red;\">).",
+                        "enum": ["text", "html"],
+                        "default": "text"
+                    },
+                    "files": {
+                        "type": "array",
+                        "description": "List of files to attach to the email",
+                        "items": {
+                            "type": "object",
+                            "properties": {
+                                "name": {
+                                    "type": "string",
+                                    "description": "Name of the file to attach"
+                                },
+                                "contentType": {
+                                    "type": "string",
+                                    "description": "The MIME type of the file"
+                                },
+                                "content": {
+                                    "type": "string",
+                                    "description": "The file content encoded as base64"
+                                }
+                            },
+                            "required": ["name", "contentType", "content"]
+                        }
+                    }
+                },
+                "required": [
+                    "to",
+                    "subject",
+                    "body"
+                ]
+            },
+            "output_schema": {
+                "type": "object",
+                "properties": {
+                    "id": {
+                        "type": "string",
+                        "description": "The ID of the email"
+                    },
+                    "result": {
+                        "type": "boolean",
+                        "description": "The result of the email send"
+                    },
+                    "error": {
+                        "type": "string",
+                        "description": "Error message if the action failed"
+                    }
+                },
+                "required": [
+                    "id",
+                    "result"
+                ]
+            }
+        },
+
+        "read_inbox": {
+            "display_name": "Read Inbox",
+            "description": "List emails in the user's inbox, filtered by read status. Results are paginated - use the nextPageToken from a previous response to retrieve the next page.",
+            "input_schema": {
+                "type": "object",
+                "properties": {
+                    "user_id": {
+                        "type": "string",
+                        "description": "The user's email address. Special value 'me' indicates the authenticated user."
+                    },
+                    "scope": {
+                        "type": "string",
+                        "description": "Filter emails by read status. 'all' returns all emails, 'unread' returns only unread emails, 'read' returns only emails that have been read.",
+                        "enum": ["all", "read", "unread"]
+                    },
+                    "pageToken": {
+                        "type": "string",
+                        "description": "An optional parameter: The page token to get the next page of results. Use the nextPageToken from a previous response."
+                    }
+                },
+                "required": [
+                    "user_id",
+                    "scope"
+                ]
+            },
+            "output_schema": {
+                "type": "object",
+                "properties": {
+                    "result": {
+                        "type": "boolean",
+                        "description": "The result of the email list"
+                    },
+                    "nextPageToken": {
+                        "type": "string",
+                        "description": "An optional parameter: The page token to get the next page of results (only present if there are more results)"
+                    },
+                    "emails": {
+                        "type": "array",
+                        "description": "List of email messages",
+                        "items": {
+                            "type": "object",
+                            "properties": {
+                                "id": {
+                                    "type": "string",
+                                    "description": "Unique identifier of the email"
+                                },
+                                "thread_id": {
+                                    "type": "string",
+                                    "description": "Unique identifier of the thread"
+                                },
+                                "subject": {
+                                    "type": "string",
+                                    "description": "Subject line of the email"
+                                },
+                                "from": {
+                                    "type": "string",
+                                    "description": "Sender's email address"
+                                },
+                                "to": {
+                                    "type": "string",
+                                    "description": "recipients's email address"
+                                },
+                                "cc": {
+                                    "type": "array",
+                                    "description": "CC recipients' email addresses",
+                                    "items": {
+                                        "type": "string",
+                                        "description": "Email address of a CC recipient"
+                                    }
+                                },
+                                "date": {
+                                    "type": "string",
+                                    "description": "Date the email was received"
+                                },
+                                "snippet": {
+                                    "type": "string",
+                                    "description": "Preview snippet of the email content"
+                                }
+                            },
+                            "required": [
+                                "id",
+                                "thread_id",
+                                "subject",
+                                "from",
+                                "to",
+                                "date",
+                                "snippet"
+                            ]
+                        }
+                    },
+                    "error": {
+                        "type": "string",
+                        "description": "Error message if the action failed"
+                    }
+                },
+                "required": [
+                    "emails",
+                    "result"
+                ]
+            }
+        },
+
+        "read_all_mail": {
+            "display_name": "Read All Mail",
+            "description": "List all emails across the entire mailbox regardless of labels, filtered by read status. Results are paginated - use the nextPageToken from a previous response to retrieve the next page.",
+            "input_schema": {
+                "type": "object",
+                "properties": {
+                    "user_id": {
+                        "type": "string",
+                        "description": "The user's email address. Special value 'me' indicates the authenticated user."
+                    },
+                    "scope": {
+                        "type": "string",
+                        "description": "Filter emails by read status. 'all' returns all emails, 'unread' returns only unread emails, 'read' returns only emails that have been read.",
+                        "enum": ["all", "read", "unread"]
+                    },
+                    "pageToken": {
+                        "type": "string",
+                        "description": "An optional parameter: The page token to get the next page of results. Use the nextPageToken from a previous response."
+                    },
+                    "include_spam_trash": {
+                        "type": "boolean",
+                        "description": "An optional parameter: Whether to include emails from spam and trash. When false, emails in trash and spam are excluded. When true, returns all emails including those in trash and spam."
+                    }
+                },
+                "required": [
+                    "user_id",
+                    "scope"
+                ]
+            },
+            "output_schema": {
+                "type": "object",
+                "properties": {
+                    "result": {
+                        "type": "boolean",
+                        "description": "The result of the email list"
+                    },
+                    "nextPageToken": {
+                        "type": "string",
+                        "description": "An optional parameter: The page token to get the next page of results (only present if there are more results)"
+                    },
+                    "emails": {
+                        "type": "array",
+                        "description": "List of email messages",
+                        "items": {
+                            "type": "object",
+                            "properties": {
+                                "id": {
+                                    "type": "string",
+                                    "description": "Unique identifier of the email"
+                                },
+                                "thread_id": {
+                                    "type": "string",
+                                    "description": "Unique identifier of the thread"
+                                },
+                                "subject": {
+                                    "type": "string",
+                                    "description": "Subject line of the email"
+                                },
+                                "from": {
+                                    "type": "string",
+                                    "description": "Sender's email address"
+                                },
+                                "to": {
+                                    "type": "string",
+                                    "description": "recipients's email address"
+                                },
+                                "cc": {
+                                    "type": "array",
+                                    "description": "CC recipients' email addresses",
+                                    "items": {
+                                        "type": "string",
+                                        "description": "Email address of a CC recipient"
+                                    }
+                                },
+                                "date": {
+                                    "type": "string",
+                                    "description": "Date the email was received"
+                                },
+                                "snippet": {
+                                    "type": "string",
+                                    "description": "Preview snippet of the email content"
+                                }
+                            },
+                            "required": [
+                                "id",
+                                "thread_id",
+                                "subject",
+                                "from",
+                                "to",
+                                "date",
+                                "snippet"
+                            ]
+                        }
+                    },
+                    "error": {
+                        "type": "string",
+                        "description": "Error message if the action failed"
+                    }
+                },
+                "required": [
+                    "emails",
+                    "result"
+                ]
+            }
+        },
+
+        "list_labels": {
+            "display_name": "List Gmail Labels",
+            "description": "List all Gmail labels (folders) available to the user. Can filter by label type (user-created or system labels).",
+            "input_schema": {
+                "type": "object",
+                "properties": {
+                    "user_id": {
+                        "type": "string",
+                        "description": "The user's email address. Special value 'me' indicates the authenticated user."
+                    },
+                    "label_type": {
+                        "type": "string",
+                        "description": "Optional filter for label type. 'user' for user-created labels, 'system' for Gmail system labels (like INBOX, SENT, etc.)",
+                        "enum": ["user", "system"]
+                    }
+                },
+                "required": [
+                    "user_id"
+                ]
+            },
+            "output_schema": {
+                "type": "object",
+                "properties": {
+                    "labels": {
+                        "type": "array",
+                        "description": "List of Gmail labels",
+                        "items": {
+                            "type": "object",
+                            "properties": {
+                                "id": {
+                                    "type": "string",
+                                    "description": "Unique identifier of the label"
+                                },
+                                "name": {
+                                    "type": "string",
+                                    "description": "Display name of the label"
+                                },
+                                "type": {
+                                    "type": "string",
+                                    "description": "Type of label (user or system)"
+                                },
+                                "messageListVisibility": {
+                                    "type": "string",
+                                    "description": "Visibility of the label in the message list"
+                                },
+                                "labelListVisibility": {
+                                    "type": "string",
+                                    "description": "Visibility of the label in the label list"
+                                }
+                            },
+                            "required": [
+                                "id",
+                                "name",
+                                "type"
+                            ]
+                        }
+                    },
+                    "result": {
+                        "type": "boolean",
+                        "description": "The result of the label list operation"
+                    },
+                    "error": {
+                        "type": "string",
+                        "description": "Error message if the action failed"
+                    }
+                },
+                "required": [
+                    "labels",
+                    "result"
+                ]
+            }
+        },
+
+        "list_emails_by_label": {
+            "display_name": "List Emails by Label",
+            "description": "List emails that have specific Gmail labels (folders). By default, only returns emails in the inbox (excludes archived emails) unless include_archived is true or INBOX label is explicitly specified. Supports pagination and can filter by multiple labels. Uses label names (not IDs) for filtering.",
+            "input_schema": {
+                "type": "object",
+                "properties": {
+                    "user_id": {
+                        "type": "string",
+                        "description": "The user's email address. Special value 'me' indicates the authenticated user."
+                    },
+                    "label_names": {
+                        "oneOf": [
+                            {
+                                "type": "string",
+                                "description": "Single label name to filter emails by (e.g., 'INBOX', 'SENT', 'Work', 'Personal')"
+                            },
+                            {
+                                "type": "array",
+                                "description": "Array of label names - emails must have ALL specified labels (e.g., ['Work', 'STARRED'])",
+                                "items": {
+                                    "type": "string",
+                                    "description": "Label name (e.g., 'INBOX', 'SENT', 'Work', 'Personal')"
+                                }
+                            }
+                        ]
+                    },
+                    "pageToken": {
+                        "type": "string",
+                        "description": "An optional parameter: The page token to get the next page of results. Use the nextPageToken from a previous response."
+                    },
+                    "maxResults": {
+                        "type": "integer",
+                        "description": "Maximum number of emails to return (default is Gmail API default)"
+                    },
+                    "include_archived": {
+                        "type": "boolean",
+                        "description": "An optional parameter: Whether to include archived emails. When false (default), only returns emails in the inbox. When true, returns all emails with the specified labels including archived ones.",
+                        "default": false
+                    }
+                },
+                "required": [
+                    "user_id",
+                    "label_names"
+                ]
+            },
+            "output_schema": {
+                "type": "object",
+                "properties": {
+                    "emails": {
+                        "type": "array",
+                        "description": "List of email messages with the specified labels",
+                        "items": {
+                            "type": "object",
+                            "properties": {
+                                "id": {
+                                    "type": "string",
+                                    "description": "Unique identifier of the email"
+                                },
+                                "thread_id": {
+                                    "type": "string",
+                                    "description": "Unique identifier of the thread"
+                                },
+                                "subject": {
+                                    "type": "string",
+                                    "description": "Subject line of the email"
+                                },
+                                "from": {
+                                    "type": "string",
+                                    "description": "Sender's email address"
+                                },
+                                "to": {
+                                    "type": "string",
+                                    "description": "recipients's email address"
+                                },
+                                "cc": {
+                                    "type": "array",
+                                    "description": "CC recipients' email addresses",
+                                    "items": {
+                                        "type": "string",
+                                        "description": "Email address of a CC recipient"
+                                    }
+                                },
+                                "date": {
+                                    "type": "string",
+                                    "description": "Date the email was received"
+                                },
+                                "snippet": {
+                                    "type": "string",
+                                    "description": "Preview snippet of the email content"
+                                }
+                            },
+                            "required": [
+                                "id",
+                                "thread_id",
+                                "subject",
+                                "from",
+                                "to",
+                                "date",
+                                "snippet"
+                            ]
+                        }
+                    },
+                    "nextPageToken": {
+                        "type": "string",
+                        "description": "An optional parameter: The page token to get the next page of results (only present if there are more results)"
+                    },
+                    "result": {
+                        "type": "boolean",
+                        "description": "The result of the email list operation"
+                    },
+                    "error": {
+                        "type": "string",
+                        "description": "Error message if the action failed"
+                    }
+                },
+                "required": [
+                    "emails",
+                    "result"
+                ]
+            }
+        },
+
+        "add_labels_to_emails": {
+            "display_name": "Add Labels to Emails",
+            "description": "Add one or more labels to specified emails. This is equivalent to moving emails to folders or applying tags.",
+            "input_schema": {
+                "type": "object",
+                "properties": {
+                    "user_id": {
+                        "type": "string",
+                        "description": "The user's email address. Special value 'me' indicates the authenticated user."
+                    },
+                    "message_ids": {
+                        "type": "array",
+                        "description": "Array of email message IDs to add labels to",
+                        "items": {
+                            "type": "string",
+                            "description": "Email message ID"
+                        }
+                    },
+                    "label_ids": {
+                        "type": "array",
+                        "description": "Array of label IDs to add to the emails",
+                        "items": {
+                            "type": "string",
+                            "description": "Label ID"
+                        }
+                    }
+                },
+                "required": [
+                    "user_id",
+                    "message_ids",
+                    "label_ids"
+                ]
+            },
+            "output_schema": {
+                "type": "object",
+                "properties": {
+                    "result": {
+                        "type": "boolean",
+                        "description": "The result of the label addition operation"
+                    },
+                    "error": {
+                        "type": "string",
+                        "description": "Error message if the action failed"
+                    }
+                },
+                "required": [
+                    "result"
+                ]
+            }
+        },
+
+        "remove_labels_from_emails": {
+            "display_name": "Remove Labels from Emails",
+            "description": "Remove one or more labels from specified emails. This is equivalent to moving emails out of folders or removing tags.",
+            "input_schema": {
+                "type": "object",
+                "properties": {
+                    "user_id": {
+                        "type": "string",
+                        "description": "The user's email address. Special value 'me' indicates the authenticated user."
+                    },
+                    "message_ids": {
+                        "type": "array",
+                        "description": "Array of email message IDs to remove labels from",
+                        "items": {
+                            "type": "string",
+                            "description": "Email message ID"
+                        }
+                    },
+                    "label_ids": {
+                        "type": "array",
+                        "description": "Array of label IDs to remove from the emails",
+                        "items": {
+                            "type": "string",
+                            "description": "Label ID"
+                        }
+                    }
+                },
+                "required": [
+                    "user_id",
+                    "message_ids",
+                    "label_ids"
+                ]
+            },
+            "output_schema": {
+                "type": "object",
+                "properties": {
+                    "result": {
+                        "type": "boolean",
+                        "description": "The result of the label removal operation"
+                    },
+                    "error": {
+                        "type": "string",
+                        "description": "Error message if the action failed"
+                    }
+                },
+                "required": [
+                    "result"
+                ]
+            }
+        },
+
+        "create_label": {
+            "display_name": "Create Custom Label",
+            "description": "Create a new custom label (folder) in Gmail. Labels are used to organize and categorize emails.",
+            "input_schema": {
+                "type": "object",
+                "properties": {
+                    "user_id": {
+                        "type": "string",
+                        "description": "The user's email address. Special value 'me' indicates the authenticated user."
+                    },
+                    "name": {
+                        "type": "string",
+                        "description": "The display name for the new label. Cannot conflict with existing system labels (INBOX, SENT, etc.)"
+                    },
+                    "messageListVisibility": {
+                        "type": "string",
+                        "description": "Whether to show messages with this label in the message list",
+                        "enum": ["show", "hide"],
+                        "default": "show"
+                    },
+                    "labelListVisibility": {
+                        "type": "string",
+                        "description": "How to display the label in the label list",
+                        "enum": ["labelShow", "labelShowIfUnread", "labelHide"],
+                        "default": "labelShow"
+                    },
+                    "textColor": {
+                        "type": "string",
+                        "description": "Optional: Text color for the label as hex string (e.g., #000000). Must be from Gmail's predefined color set."
+                    },
+                    "backgroundColor": {
+                        "type": "string",
+                        "description": "Optional: Background color for the label as hex string (e.g., #ffffff). Must be from Gmail's predefined color set."
+                    }
+                },
+                "required": [
+                    "user_id",
+                    "name"
+                ]
+            },
+            "output_schema": {
+                "type": "object",
+                "properties": {
+                    "label": {
+                        "type": "object",
+                        "description": "The created label object",
+                        "properties": {
+                            "id": {
+                                "type": "string",
+                                "description": "The unique ID of the created label"
+                            },
+                            "name": {
+                                "type": "string",
+                                "description": "The display name of the label"
+                            },
+                            "type": {
+                                "type": "string",
+                                "description": "The type of label (will be 'user' for custom labels)"
+                            },
+                            "messageListVisibility": {
+                                "type": "string",
+                                "description": "Visibility setting for messages with this label"
+                            },
+                            "labelListVisibility": {
+                                "type": "string",
+                                "description": "Visibility setting for the label in the label list"
+                            }
+                        },
+                        "required": [
+                            "id",
+                            "name",
+                            "type",
+                            "messageListVisibility",
+                            "labelListVisibility"
+                        ]
+                    },
+                    "result": {
+                        "type": "boolean",
+                        "description": "The result of the label creation operation"
+                    },
+                    "error": {
+                        "type": "string",
+                        "description": "Error message if the action failed"
+                    }
+                },
+                "required": [
+                    "label",
+                    "result"
+                ]
+            }
+        },
+
+        "get_thread_emails": {
+            "display_name": "Get Thread Emails",
+            "description": "Get all emails in a thread, returned as snippets in chronological order",
+            "input_schema": {
+                "type": "object",
+                "properties": {
+                    "user_id": {
+                        "type": "string",
+                        "description": "The user's email address. Special value 'me' indicates the authenticated user."
+                    },
+                    "thread_id": {
+                        "type": "string",
+                        "description": "The ID of the thread to retrieve emails from"
+                    }
+                },
+                "required": [
+                    "user_id",
+                    "thread_id"
+                ]
+            },
+            "output_schema": {
+                "type": "object",
+                "properties": {
+                    "thread_id": {
+                        "type": "string",
+                        "description": "The ID of the thread"
+                    },
+                    "emails": {
+                        "type": "array",
+                        "description": "List of email messages in the thread, ordered chronologically",
+                        "items": {
+                            "type": "object",
+                            "properties": {
+                                "id": {
+                                    "type": "string",
+                                    "description": "Unique identifier of the email"
+                                },
+                                "thread_id": {
+                                    "type": "string",
+                                    "description": "Unique identifier of the thread"
+                                },
+                                "subject": {
+                                    "type": "string",
+                                    "description": "Subject line of the email"
+                                },
+                                "from": {
+                                    "type": "string",
+                                    "description": "Sender's email address"
+                                },
+                                "to": {
+                                    "type": "string",
+                                    "description": "recipients's email address"
+                                },
+                                "cc": {
+                                    "type": "array",
+                                    "description": "CC recipients' email addresses",
+                                    "items": {
+                                        "type": "string",
+                                        "description": "Email address of a CC recipient"
+                                    }
+                                },
+                                "date": {
+                                    "type": "string",
+                                    "description": "Date the email was received"
+                                },
+                                "snippet": {
+                                    "type": "string",
+                                    "description": "Preview snippet of the email content"
+                                }
+                            },
+                            "required": [
+                                "id",
+                                "thread_id",
+                                "subject",
+                                "from",
+                                "to",
+                                "date",
+                                "snippet"
+                            ]
+                        }
+                    },
+                    "result": {
+                        "type": "boolean",
+                        "description": "The result of the thread retrieval operation"
+                    },
+                    "error": {
+                        "type": "string",
+                        "description": "Error message if the action failed"
+                    }
+                },
+                "required": [
+                    "thread_id",
+                    "emails",
+                    "result"
+                ]
+            }
+        },
+
+        "archive_emails": {
+            "display_name": "Archive Emails",
+            "description": "Archive emails by removing the INBOX label. Archived emails remain accessible but are hidden from the main inbox view.",
+            "input_schema": {
+                "type": "object",
+                "properties": {
+                    "user_id": {
+                        "type": "string",
+                        "description": "The user's email address. Special value 'me' indicates the authenticated user."
+                    },
+                    "ids": {
+                        "type": "array",
+                        "description": "The IDs of the emails to archive",
+                        "items": {
+                            "type": "string",
+                            "description": "The ID of the email to archive"
+                        }
+                    }
+                },
+                "required": [
+                    "user_id",
+                    "ids"
+                ]
+            },
+            "output_schema": {
+                "type": "object",
+                "properties": {
+                    "result": {
+                        "type": "boolean",
+                        "description": "The result of the email archiving operation"
+                    },
+                    "error": {
+                        "type": "string",
+                        "description": "Error message if the action failed"
+                    }
+                },
+                "required": [
+                    "result"
+                ]
+            }
+        },
+
+        "create_draft": {
+            "display_name": "Create Draft",
+            "description": "Create a new email draft or a draft reply to an existing email. For replies, provide thread_id and message_id - the recipient ('to'), subject, and threading headers will be automatically populated from the original message.",
+            "input_schema": {
+                "type": "object",
+                "properties": {
+                    "user_id": {
+                        "type": "string",
+                        "description": "The user's email address. Special value 'me' indicates the authenticated user.",
+                        "default": "me"
+                    },
+                    "thread_id": {
+                        "type": "string",
+                        "description": "Optional: The thread ID to reply to. When provided with message_id, creates a draft reply instead of a new draft."
+                    },
+                    "message_id": {
+                        "type": "string",
+                        "description": "Optional: The Gmail message ID to reply to (the 'id' field from the email object, NOT the Message-ID header). Required if thread_id is provided."
+                    },
+                    "to": {
+                        "type": "array",
+                        "description": "The email addresses of the recipients. For replies, if not provided, defaults to the original sender.",
+                        "items": {
+                            "type": "string",
+                            "description": "Email address of a recipient"
+                        }
+                    },
+                    "cc": {
+                        "type": "array",
+                        "description": "The email addresses to CC",
+                        "items": {
+                            "type": "string",
+                            "description": "Email address to CC"
+                        }
+                    },
+                    "bcc": {
+                        "type": "array",
+                        "description": "The email addresses to BCC",
+                        "items": {
+                            "type": "string",
+                            "description": "Email address to BCC"
+                        }
+                    },
+                    "subject": {
+                        "type": "string",
+                        "description": "The subject of the draft email. For replies, if not provided, automatically prefixes the original subject with 'Re:'"
+                    },
+                    "body": {
+                        "type": "string",
+                        "description": "The body content of the draft email"
+                    },
+                    "body_format": {
+                        "type": "string",
+                        "description": "Format of the email body content. When set to 'html', the body parameter will be treated as HTML content. When set to 'text' (default), the body will be sent as plain text.",
+                        "enum": ["text", "html"],
+                        "default": "text"
+                    },
+                    "files": {
+                        "type": "array",
+                        "description": "List of files to attach to the draft",
+                        "items": {
+                            "type": "object",
+                            "properties": {
+                                "name": {
+                                    "type": "string",
+                                    "description": "Name of the file to attach"
+                                },
+                                "contentType": {
+                                    "type": "string",
+                                    "description": "The MIME type of the file"
+                                },
+                                "content": {
+                                    "type": "string",
+                                    "description": "The file content encoded as base64"
+                                }
+                            },
+                            "required": ["name", "contentType", "content"]
+                        }
+                    }
+                },
+                "required": []
+            },
+            "output_schema": {
+                "type": "object",
+                "properties": {
+                    "draft": {
+                        "type": "object",
+                        "description": "The created draft object",
+                        "properties": {
+                            "id": {
+                                "type": "string",
+                                "description": "The unique ID of the created draft"
+                            },
+                            "message": {
+                                "type": "object",
+                                "description": "The message content of the draft",
+                                "properties": {
+                                    "id": {
+                                        "type": "string",
+                                        "description": "The message ID"
+                                    },
+                                    "threadId": {
+                                        "type": "string",
+                                        "description": "The thread ID"
+                                    }
+                                }
+                            }
+                        }
+                    },
+                    "result": {
+                        "type": "boolean",
+                        "description": "The result of the draft creation operation"
+                    },
+                    "error": {
+                        "type": "string",
+                        "description": "Error message if the action failed"
+                    }
+                },
+                "required": [
+                    "draft",
+                    "result"
+                ]
+            }
+        },
+
+        "update_draft": {
+            "display_name": "Update Draft",
+            "description": "Update an existing email draft with new content, recipients, or attachments. Automatically preserves thread context for reply drafts - the threadId and threading headers (In-Reply-To, References) are maintained so the draft remains associated with its original conversation.",
+            "input_schema": {
+                "type": "object",
+                "properties": {
+                    "user_id": {
+                        "type": "string",
+                        "description": "The user's email address. Special value 'me' indicates the authenticated user.",
+                        "default": "me"
+                    },
+                    "draft_id": {
+                        "type": "string",
+                        "description": "The ID of the draft to update"
+                    },
+                    "to": {
+                        "type": "array",
+                        "description": "The email addresses of the recipients",
+                        "items": {
+                            "type": "string",
+                            "description": "Email address of a recipient"
+                        }
+                    },
+                    "cc": {
+                        "type": "array",
+                        "description": "The email addresses to CC",
+                        "items": {
+                            "type": "string",
+                            "description": "Email address to CC"
+                        }
+                    },
+                    "bcc": {
+                        "type": "array",
+                        "description": "The email addresses to BCC",
+                        "items": {
+                            "type": "string",
+                            "description": "Email address to BCC"
+                        }
+                    },
+                    "subject": {
+                        "type": "string",
+                        "description": "The subject of the draft email"
+                    },
+                    "body": {
+                        "type": "string",
+                        "description": "The body content of the draft email"
+                    },
+                    "body_format": {
+                        "type": "string",
+                        "description": "Format of the email body content. When set to 'html', the body parameter will be treated as HTML content. When set to 'text' (default), the body will be sent as plain text.",
+                        "enum": ["text", "html"],
+                        "default": "text"
+                    },
+                    "files": {
+                        "type": "array",
+                        "description": "List of files to attach to the draft. Note: This replaces any existing attachments - include all desired files in the update.",
+                        "items": {
+                            "type": "object",
+                            "properties": {
+                                "name": {
+                                    "type": "string",
+                                    "description": "Name of the file to attach"
+                                },
+                                "contentType": {
+                                    "type": "string",
+                                    "description": "The MIME type of the file"
+                                },
+                                "content": {
+                                    "type": "string",
+                                    "description": "The file content encoded as base64"
+                                }
+                            },
+                            "required": ["name", "contentType", "content"]
+                        }
+                    }
+                },
+                "required": [
+                    "draft_id"
+                ]
+            },
+            "output_schema": {
+                "type": "object",
+                "properties": {
+                    "draft": {
+                        "type": "object",
+                        "description": "The updated draft object",
+                        "properties": {
+                            "id": {
+                                "type": "string",
+                                "description": "The unique ID of the draft"
+                            },
+                            "message": {
+                                "type": "object",
+                                "description": "The message content of the draft",
+                                "properties": {
+                                    "id": {
+                                        "type": "string",
+                                        "description": "The message ID"
+                                    },
+                                    "threadId": {
+                                        "type": "string",
+                                        "description": "The thread ID"
+                                    }
+                                }
+                            }
+                        }
+                    },
+                    "result": {
+                        "type": "boolean",
+                        "description": "The result of the draft update operation"
+                    },
+                    "error": {
+                        "type": "string",
+                        "description": "Error message if the action failed"
+                    }
+                },
+                "required": [
+                    "draft",
+                    "result"
+                ]
+            }
+        },
+
+        "list_drafts": {
+            "display_name": "List Drafts",
+            "description": "List all drafts in the user's mailbox with pagination support",
+            "input_schema": {
+                "type": "object",
+                "properties": {
+                    "user_id": {
+                        "type": "string",
+                        "description": "The user's email address. Special value 'me' indicates the authenticated user.",
+                        "default": "me"
+                    },
+                    "pageToken": {
+                        "type": "string",
+                        "description": "Page token for pagination. Use the nextPageToken from a previous response to get the next page."
+                    },
+                    "maxResults": {
+                        "type": "integer",
+                        "description": "Maximum number of drafts to return (1-500, default: 100)",
+                        "minimum": 1,
+                        "maximum": 500,
+                        "default": 100
+                    },
+                    "q": {
+                        "type": "string",
+                        "description": "Query to filter drafts using Gmail search syntax (e.g., 'subject:urgent', 'from:example@gmail.com')"
+                    },
+                    "includeSpamTrash": {
+                        "type": "boolean",
+                        "description": "Include drafts from spam and trash folders",
+                        "default": false
+                    }
+                },
+                "required": []
+            },
+            "output_schema": {
+                "type": "object",
+                "properties": {
+                    "drafts": {
+                        "type": "array",
+                        "description": "List of draft objects",
+                        "items": {
+                            "type": "object",
+                            "properties": {
+                                "id": {
+                                    "type": "string",
+                                    "description": "The unique ID of the draft"
+                                },
+                                "message": {
+                                    "type": "object",
+                                    "description": "Basic message information",
+                                    "properties": {
+                                        "id": {
+                                            "type": "string",
+                                            "description": "The message ID"
+                                        },
+                                        "threadId": {
+                                            "type": "string",
+                                            "description": "The thread ID"
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    },
+                    "nextPageToken": {
+                        "type": "string",
+                        "description": "Token for the next page of results (only present if there are more results)"
+                    },
+                    "resultSizeEstimate": {
+                        "type": "integer",
+                        "description": "Estimated total number of drafts"
+                    },
+                    "result": {
+                        "type": "boolean",
+                        "description": "The result of the list operation"
+                    },
+                    "error": {
+                        "type": "string",
+                        "description": "Error message if the action failed"
+                    }
+                },
+                "required": [
+                    "drafts",
+                    "result"
+                ]
+            }
+        },
+
+        "get_draft": {
+            "display_name": "Get Draft",
+            "description": "Retrieve a specific draft by ID with full content details",
+            "input_schema": {
+                "type": "object",
+                "properties": {
+                    "user_id": {
+                        "type": "string",
+                        "description": "The user's email address. Special value 'me' indicates the authenticated user.",
+                        "default": "me"
+                    },
+                    "draft_id": {
+                        "type": "string",
+                        "description": "The ID of the draft to retrieve"
+                    },
+                    "format": {
+                        "type": "string",
+                        "description": "The format to return the draft message in",
+                        "enum": ["minimal", "full", "raw", "metadata"],
+                        "default": "full"
+                    }
+                },
+                "required": [
+                    "draft_id"
+                ]
+            },
+            "output_schema": {
+                "type": "object",
+                "properties": {
+                    "draft": {
+                        "type": "object",
+                        "description": "The complete draft object",
+                        "properties": {
+                            "id": {
+                                "type": "string",
+                                "description": "The unique ID of the draft"
+                            },
+                            "message": {
+                                "type": "object",
+                                "description": "Full message content",
+                                "properties": {
+                                    "id": {
+                                        "type": "string",
+                                        "description": "The message ID"
+                                    },
+                                    "threadId": {
+                                        "type": "string",
+                                        "description": "The thread ID"
+                                    },
+                                    "subject": {
+                                        "type": "string",
+                                        "description": "Subject of the draft"
+                                    },
+                                    "from": {
+                                        "type": "string",
+                                        "description": "Sender's email address"
+                                    },
+                                    "to": {
+                                        "type": "string",
+                                        "description": "Recipients' email addresses"
+                                    },
+                                    "cc": {
+                                        "type": "array",
+                                        "description": "CC recipients' email addresses",
+                                        "items": {
+                                            "type": "string",
+                                            "description": "Email address of a CC recipient"
+                                        }
+                                    },
+                                    "bcc": {
+                                        "type": "array",
+                                        "description": "BCC recipients' email addresses",
+                                        "items": {
+                                            "type": "string",
+                                            "description": "Email address of a BCC recipient"
+                                        }
+                                    },
+                                    "body": {
+                                        "type": "string",
+                                        "description": "Body content of the draft"
+                                    }
+                                }
+                            }
+                        }
+                    },
+                    "files": {
+                        "type": "array",
+                        "description": "List of files attached to the draft",
+                        "items": {
+                            "type": "object",
+                            "properties": {
+                                "name": {
+                                    "type": "string",
+                                    "description": "Name of the attached file"
+                                },
+                                "contentType": {
+                                    "type": "string",
+                                    "description": "The MIME type of the file"
+                                },
+                                "content": {
+                                    "type": "string",
+                                    "description": "The file content encoded as base64"
+                                }
+                            },
+                            "required": ["name", "contentType", "content"]
+                        }
+                    },
+                    "result": {
+                        "type": "boolean",
+                        "description": "The result of the get operation"
+                    },
+                    "error": {
+                        "type": "string",
+                        "description": "Error message if the action failed"
+                    }
+                },
+                "required": [
+                    "draft",
+                    "files",
+                    "result"
+                ]
+            }
+        },
+
+        "send_draft": {
+            "display_name": "Send Draft",
+            "description": "Send an existing draft to its recipients. The draft will be automatically deleted after sending.",
+            "input_schema": {
+                "type": "object",
+                "properties": {
+                    "user_id": {
+                        "type": "string",
+                        "description": "The user's email address. Special value 'me' indicates the authenticated user.",
+                        "default": "me"
+                    },
+                    "draft_id": {
+                        "type": "string",
+                        "description": "The ID of the draft to send"
+                    }
+                },
+                "required": [
+                    "draft_id"
+                ]
+            },
+            "output_schema": {
+                "type": "object",
+                "properties": {
+                    "message": {
+                        "type": "object",
+                        "description": "The sent message object",
+                        "properties": {
+                            "id": {
+                                "type": "string",
+                                "description": "The unique ID of the sent message"
+                            },
+                            "threadId": {
+                                "type": "string",
+                                "description": "The thread ID of the sent message"
+                            }
+                        }
+                    },
+                    "result": {
+                        "type": "boolean",
+                        "description": "The result of the send operation"
+                    },
+                    "error": {
+                        "type": "string",
+                        "description": "Error message if the action failed"
+                    }
+                },
+                "required": [
+                    "message",
+                    "result"
+                ]
+            }
+        },
+
+        "delete_draft": {
+            "display_name": "Delete Draft",
+            "description": "Permanently delete a draft from the user's mailbox",
+            "input_schema": {
+                "type": "object",
+                "properties": {
+                    "user_id": {
+                        "type": "string",
+                        "description": "The user's email address. Special value 'me' indicates the authenticated user.",
+                        "default": "me"
+                    },
+                    "draft_id": {
+                        "type": "string",
+                        "description": "The ID of the draft to delete"
+                    }
+                },
+                "required": [
+                    "draft_id"
+                ]
+            },
+            "output_schema": {
+                "type": "object",
+                "properties": {
+                    "result": {
+                        "type": "boolean",
+                        "description": "The result of the delete operation"
+                    },
+                    "error": {
+                        "type": "string",
+                        "description": "Error message if the action failed"
+                    }
+                },
+                "required": [
+                    "result"
+                ]
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/gmail/gmail.py b/gmail/gmail.py
new file mode 100644
index 00000000..7a82589a
--- /dev/null
+++ b/gmail/gmail.py
@@ -0,0 +1,1272 @@
+from autohive_integrations_sdk import Integration, ExecutionContext, ActionHandler, ActionResult
+
+from typing import Dict, Any
+from email.mime.text import MIMEText
+from email.mime.multipart import MIMEMultipart
+from email.mime.base import MIMEBase
+from email import encoders
+import base64
+from googleapiclient.discovery import build
+from google.oauth2.credentials import Credentials
+import html2text
+import bleach
+
+gmail = Integration.load()
+
+
+def create_email_message(body: str, files: list = None, is_html: bool = False) -> MIMEMultipart:
+    """Create email message with optional files and HTML support.
+
+    Args:
+        body: Email body text or HTML content
+        files: List of file dictionaries with name, contentType, and content
+        is_html: Whether the body content is HTML that should be rendered as rich email
+
+    Returns:
+        MIMEMultipart or MIMEText message object
+    """
+    if is_html:
+        # Sanitize HTML content to prevent XSS and other security issues
+        allowed_tags = [
+            "p",
+            "br",
+            "strong",
+            "em",
+            "u",
+            "i",
+            "b",
+            "h1",
+            "h2",
+            "h3",
+            "h4",
+            "h5",
+            "h6",
+            "ul",
+            "ol",
+            "li",
+            "blockquote",
+            "div",
+            "span",
+            "a",
+            "img",
+            "table",
+            "thead",
+            "tbody",
+            "tr",
+            "th",
+            "td",
+            "hr",
+            "pre",
+            "code",
+        ]
+
+        allowed_attributes = {
+            "*": ["style", "class"],
+            "a": ["href", "title"],
+            "img": ["src", "alt", "title", "width", "height"],
+            "table": ["border", "cellpadding", "cellspacing"],
+            "th": ["colspan", "rowspan"],
+            "td": ["colspan", "rowspan"],
+        }
+
+        allowed_protocols = ["http", "https", "mailto"]
+
+        # Sanitize the HTML content
+        sanitized_body = bleach.clean(
+            body,
+            tags=allowed_tags,
+            attributes=allowed_attributes,
+            protocols=allowed_protocols,
+            strip=True,  # Remove disallowed tags entirely
+        )
+
+        # Generate plain text version from sanitized HTML for better email client compatibility
+        h = html2text.HTML2Text()
+        h.ignore_links = False
+        h.body_width = 0  # No line wrapping
+        plain_text = h.handle(sanitized_body)
+
+        if files:
+            # HTML email with attachments: multipart/mixed containing multipart/alternative + files
+            message = MIMEMultipart("mixed")
+
+            # Create alternative container for HTML and plain text versions
+            alternative_container = MIMEMultipart("alternative")
+
+            # Add plain text version first (preferred order for email clients)
+            text_part = MIMEText(plain_text, "plain", "utf-8")
+            alternative_container.attach(text_part)
+
+            # Add HTML version
+            html_part = MIMEText(sanitized_body, "html", "utf-8")
+            alternative_container.attach(html_part)
+
+            # Attach alternative container to main message
+            message.attach(alternative_container)
+        else:
+            # HTML email without attachments: simple multipart/alternative
+            message = MIMEMultipart("alternative")
+
+            # Add plain text version first (preferred order for email clients)
+            text_part = MIMEText(plain_text, "plain", "utf-8")
+            message.attach(text_part)
+
+            # Add HTML version
+            html_part = MIMEText(sanitized_body, "html", "utf-8")
+            message.attach(html_part)
+
+    elif files:
+        # Plain text email with attachments: multipart/mixed
+        message = MIMEMultipart("mixed")
+
+        # Add the text body
+        text_part = MIMEText(body, "plain", "utf-8")
+        message.attach(text_part)
+    else:
+        # Simple plain text email
+        message = MIMEText(body, "plain", "utf-8")
+
+    # Add files if present
+    if files:
+        for file_item in files:
+            part = MIMEBase("application", "octet-stream")
+
+            # Decode base64 content. The input 'content' might be base64url encoded
+            # (e.g., if it came from a read_email action) and may lack padding.
+            # We use urlsafe_b64decode and ensure correct padding.
+            content_as_string = file_item["content"]
+
+            # Add necessary padding. len() on string is fine for calculating padding length.
+            padded_content_string = content_as_string + "=" * (-len(content_as_string) % 4)
+
+            # base64.urlsafe_b64decode can take an ASCII string or bytes.
+            # Encoding to 'ascii' bytes first is a robust practice.
+            file_binary_data = base64.urlsafe_b64decode(padded_content_string.encode("ascii"))
+            part.set_payload(file_binary_data)
+
+            # Encode the payload in base64
+            encoders.encode_base64(part)
+
+            # Add header with filename
+            part.add_header("Content-Disposition", f"attachment; filename= {file_item['name']}")
+
+            # Set content type if provided
+            if "contentType" in file_item:
+                part.set_type(file_item["contentType"])
+
+            message.attach(part)
+
+    return message
+
+
+def build_credentials(context: ExecutionContext):
+    """Build Google credentials from ExecutionContext.
+
+    Args:
+        context: ExecutionContext containing authentication information
+
+    Returns:
+        Google credentials object
+    """
+    # Extract access token from context.auth.credentials
+    access_token = context.auth["credentials"]["access_token"]
+
+    creds = Credentials(token=access_token, token_uri="https://oauth2.googleapis.com/token")  # nosec B106
+
+    return creds
+
+
+def build_gmail_service(context: ExecutionContext):
+    """Build Gmail service object.
+
+    Args:
+        context: ExecutionContext containing authentication information
+
+    Returns:
+        Gmail service object
+    """
+    credentials = build_credentials(context)
+    service = build("gmail", "v1", credentials=credentials)
+    return service
+
+
+class GmailMessageParser:
+    @staticmethod
+    def decode_body(data: str) -> str:
+        """Decode base64 encoded message body."""
+        try:
+            return base64.urlsafe_b64decode(data + "=" * (-len(data) % 4)).decode("utf-8")
+        except Exception:
+            return ""
+
+    @staticmethod
+    def extract_plain_text(payload: Dict[str, Any], depth: int = 0, max_depth: int = 5) -> str:
+        """Extract plain text content from message payload.
+
+        Args:
+            payload: The message payload to extract text from
+            depth: Current recursion depth (internal use)
+            max_depth: Maximum recursion depth to prevent stack overflow
+        """
+        # Prevent excessive recursion
+        if depth > max_depth:
+            return "[Email content too deeply nested to extract]"
+
+        # Case 1: Body data directly in the payload (simple emails)
+        if "body" in payload and "data" in payload["body"]:
+            return GmailMessageParser.decode_body(payload["body"]["data"])
+
+        # Case 2: Simple email with mimeType text/plain
+        if payload.get("mimeType") == "text/plain" and "body" in payload and "data" in payload["body"]:
+            return GmailMessageParser.decode_body(payload["body"]["data"])
+
+        # Case 3: Handle multipart messages recursively
+        if "parts" in payload:
+            # First, try to find a text/plain part
+            for part in payload["parts"]:
+                if part.get("mimeType") == "text/plain" and "body" in part and "data" in part["body"]:
+                    return GmailMessageParser.decode_body(part["body"]["data"])
+
+            # If no text/plain, try to find content recursively in each part
+            for part in payload["parts"]:
+                text = GmailMessageParser.extract_plain_text(part, depth + 1, max_depth)
+                if text:
+                    return text
+
+        return ""
+
+    @staticmethod
+    def get_header_value(headers: list, name: str) -> str:
+        """Extract header value by name."""
+        for header in headers:
+            if header["name"].lower() == name.lower():
+                return header["value"]
+        return ""
+
+    @staticmethod
+    def parse_email_list(email_str: str) -> list:
+        """Parse a comma-separated list of email addresses into an array."""
+        if not email_str:
+            return []
+        # Split by comma and strip whitespace from each email
+        return [email.strip() for email in email_str.split(",")]
+
+    @staticmethod
+    def extract_files(
+        service, user_id: str, message_id: str, payload: Dict[str, Any], depth: int = 0, max_depth: int = 5
+    ) -> list:
+        """Extract files from message payload.
+
+        Args:
+            service: Gmail service object
+            user_id: User ID for Gmail API calls
+            message_id: Message ID for file retrieval
+            payload: The message payload to extract files from
+            depth: Current recursion depth (internal use)
+            max_depth: Maximum recursion depth to prevent stack overflow
+        """
+        files = []
+
+        # Prevent excessive recursion
+        if depth > max_depth:
+            return files
+
+        # Check if this part has an attachment (file)
+        if "body" in payload and "attachmentId" in payload["body"]:
+            filename = payload.get("filename", "attachment")
+            if filename:
+                try:
+                    attachment_data = (
+                        service.users()
+                        .messages()
+                        .attachments()
+                        .get(userId=user_id, messageId=message_id, id=payload["body"]["attachmentId"])
+                        .execute()
+                    )
+
+                    # Convert Gmail's base64url to standard base64
+                    base64url_string = attachment_data["data"]
+                    # Add padding for urlsafe_b64decode
+                    padded_base64url_string = base64url_string + "=" * (-len(base64url_string) % 4)
+                    # Decode from base64url (handles '-' and '_')
+                    binary_data = base64.urlsafe_b64decode(padded_base64url_string)
+                    # Re-encode to standard base64 (uses '+' and '/', adds padding)
+                    standard_base64_bytes = base64.b64encode(binary_data)
+                    # Decode bytes to string for JSON output
+                    standard_base64_string = standard_base64_bytes.decode("utf-8")
+
+                    files.append(
+                        {
+                            "name": filename,
+                            "contentType": payload.get("mimeType", "application/octet-stream"),
+                            "content": standard_base64_string,  # Store the standard base64 string
+                        }
+                    )
+                except Exception as e:
+                    print(f"Error retrieving or converting file {filename}: {e}")  # Updated log
+
+        if "parts" in payload:
+            for part in payload["parts"]:
+                files.extend(GmailMessageParser.extract_files(service, user_id, message_id, part, depth + 1, max_depth))
+
+        return files
+
+    @staticmethod
+    def parse_message_with_snippet(raw_message: Dict[str, Any]) -> Dict[str, Any]:
+        """Parse raw Gmail message into standardized format."""
+        headers = raw_message["payload"]["headers"]
+        cc_header = GmailMessageParser.get_header_value(headers, "Cc")
+
+        return {
+            "id": raw_message["id"],
+            "thread_id": raw_message["threadId"],
+            "subject": GmailMessageParser.get_header_value(headers, "Subject"),
+            "from": GmailMessageParser.get_header_value(headers, "From"),
+            "to": GmailMessageParser.get_header_value(headers, "To"),
+            "cc": GmailMessageParser.parse_email_list(cc_header),
+            "date": GmailMessageParser.get_header_value(headers, "Date"),
+            "snippet": raw_message.get("snippet", ""),
+        }
+
+    @staticmethod
+    def parse_message_with_body(raw_message: Dict[str, Any]) -> Dict[str, Any]:
+        """Parse raw Gmail message into standardized format."""
+        headers = raw_message["payload"]["headers"]
+        cc_header = GmailMessageParser.get_header_value(headers, "Cc")
+
+        return {
+            "id": raw_message["id"],
+            "thread_id": raw_message["threadId"],
+            "subject": GmailMessageParser.get_header_value(headers, "Subject"),
+            "from": GmailMessageParser.get_header_value(headers, "From"),
+            "to": GmailMessageParser.get_header_value(headers, "To"),
+            "cc": GmailMessageParser.parse_email_list(cc_header),
+            "date": GmailMessageParser.get_header_value(headers, "Date"),
+            "body": GmailMessageParser.extract_plain_text(raw_message["payload"]),
+        }
+
+
+@gmail.action("mark_emails_as_unread")
+class MarkEmailsAsUnread(ActionHandler):
+    async def execute(self, inputs: Dict[str, Any], context: ExecutionContext):
+        try:
+            service = build_gmail_service(context)
+            user_id = inputs["user_id"]
+            ids = inputs["ids"]
+
+            body = {"ids": ids, "addLabelIds": ["UNREAD"], "removeLabelIds": []}
+
+            request = service.users().messages().batchModify(userId=user_id, body=body)
+            request.execute()
+
+            return ActionResult(data={"result": True}, cost_usd=0.0)
+
+        except Exception as e:
+            return ActionResult(data={"error": str(e)}, cost_usd=0.0)
+
+
+@gmail.action("mark_emails_as_read")
+class MarkEmailsAsRead(ActionHandler):
+    async def execute(self, inputs: Dict[str, Any], context: ExecutionContext):
+        try:
+            service = build_gmail_service(context)
+            user_id = inputs["user_id"]
+            ids = inputs["ids"]
+
+            body = {"ids": ids, "addLabelIds": [], "removeLabelIds": ["UNREAD"]}
+
+            request = service.users().messages().batchModify(userId=user_id, body=body)
+            request.execute()
+
+            return ActionResult(data={"result": True}, cost_usd=0.0)
+
+        except Exception as e:
+            return ActionResult(data={"error": str(e)}, cost_usd=0.0)
+
+
+@gmail.action("get_user_info")
+class GetUserInfo(ActionHandler):
+    async def execute(self, inputs: Dict[str, Any], context: ExecutionContext):
+        try:
+            service = build_gmail_service(context)
+            user_id = inputs["user_id"]
+
+            request = service.users().getProfile(userId=user_id)
+            result = request.execute()
+
+            return ActionResult(
+                data={
+                    "user_info": {
+                        "email_address": result["emailAddress"],
+                        "messages_total": result["messagesTotal"],
+                        "threads_total": result["threadsTotal"],
+                        "history_id": result["historyId"],
+                    },
+                    "result": True,
+                },
+                cost_usd=0.0,
+            )
+
+        except Exception as e:
+            return ActionResult(data={"error": str(e)}, cost_usd=0.0)
+
+
+@gmail.action("read_email")
+class ReadEmail(ActionHandler):
+    async def execute(self, inputs: Dict[str, Any], context: ExecutionContext):
+        try:
+            service = build_gmail_service(context)
+            user_id = inputs["user_id"]
+            email_id = inputs["email_id"]
+
+            # Fetch the full email message
+            message_data = service.users().messages().get(userId=user_id, id=email_id, format="full").execute()
+
+            # Parse the main email fields (without files)
+            email_object = GmailMessageParser.parse_message_with_body(message_data)
+
+            # Extract files separately
+            extracted_files = GmailMessageParser.extract_files(
+                service, user_id, message_data["id"], message_data["payload"]
+            )
+
+            return ActionResult(data={"email": email_object, "files": extracted_files, "result": True}, cost_usd=0.0)
+
+        except Exception as e:
+            return ActionResult(data={"error": str(e)}, cost_usd=0.0)
+
+
+@gmail.action("send_email")
+class SendEmail(ActionHandler):
+    async def execute(self, inputs: Dict[str, Any], context: ExecutionContext):
+        """Send an email using Gmail API."""
+
+        try:
+            service = build_gmail_service(context)
+            user_id = "me"
+
+            # Create the email message
+            message = {"raw": self._create_raw_email(inputs)}
+
+            # Send the email using Gmail API
+            request = service.users().messages().send(userId=user_id, body=message)
+            response = request.execute()
+
+            return ActionResult(data={"id": response.get("id", ""), "result": True}, cost_usd=0.0)
+
+        except Exception as e:
+            return ActionResult(data={"error": str(e)}, cost_usd=0.0)
+
+    def _create_raw_email(self, inputs: Dict[str, Any]) -> str:
+        """Create base64 encoded email message."""
+        # Determine if HTML formatting is requested
+        body_format = inputs.get("body_format", "text")
+        is_html = body_format == "html"
+
+        # Create message with optional files and HTML support
+        input_files = inputs.get("files", [])
+        message = create_email_message(inputs["body"], input_files, is_html)
+
+        # Handle multiple recipients in 'to' field
+        if isinstance(inputs["to"], list):
+            message["to"] = ", ".join(inputs["to"])
+        else:
+            message["to"] = inputs["to"]
+
+        # Handle CC recipients if present
+        if "cc" in inputs:
+            if isinstance(inputs["cc"], list):
+                message["cc"] = ", ".join(inputs["cc"])
+            else:
+                message["cc"] = inputs["cc"]
+
+        message["subject"] = inputs["subject"]
+
+        # Add from if provided
+        if "from" in inputs and inputs["from"] != "me":
+            message["from"] = inputs["from"]
+
+        # Encode the message
+        return base64.urlsafe_b64encode(message.as_bytes()).decode()
+
+
+@gmail.action("reply_to_thread")
+class ReplyToThread(ActionHandler):
+    async def execute(self, inputs: Dict[str, Any], context: ExecutionContext):
+        try:
+            service = build_gmail_service(context)
+            user_id = inputs.get("user_id", "me")
+            thread_id = inputs["thread_id"]
+            message_id = inputs["message_id"]
+            body = inputs["body"]
+
+            # Fetch the original message to get headers
+            original_request = service.users().messages().get(userId=user_id, id=message_id)
+            original_message = original_request.execute()
+
+            # Parse original message headers
+            headers = original_message["payload"]["headers"]
+            original_subject = GmailMessageParser.get_header_value(headers, "Subject")
+            original_from = GmailMessageParser.get_header_value(headers, "From")
+            message_id_header = GmailMessageParser.get_header_value(headers, "Message-ID")
+            references = GmailMessageParser.get_header_value(headers, "References")
+
+            # Determine if HTML formatting is requested
+            body_format = inputs.get("body_format", "text")
+            is_html = body_format == "html"
+
+            # Create message with optional files and HTML support
+            input_files = inputs.get("files", [])
+            message = create_email_message(body, input_files, is_html)
+
+            # Set recipients
+            recipients = [original_from]
+            if "to" in inputs and inputs["to"]:
+                recipients.extend(inputs["to"])
+            message["to"] = ", ".join(recipients)
+
+            # Add CC if provided
+            if "cc" in inputs and inputs["cc"]:
+                message["cc"] = ", ".join(inputs["cc"])
+
+            message["subject"] = (
+                f"Re: {original_subject}" if not original_subject.startswith("Re:") else original_subject
+            )
+
+            # Add threading headers
+            message["In-Reply-To"] = message_id_header
+            # Combine existing references with the new message ID
+            new_references = f"{references} {message_id_header}" if references else message_id_header
+            message["References"] = new_references
+
+            # Add thread ID to keep messages grouped
+            message_payload = {"raw": base64.urlsafe_b64encode(message.as_bytes()).decode(), "threadId": thread_id}
+
+            # Send the reply
+            request = service.users().messages().send(userId=user_id, body=message_payload)
+            response = request.execute()
+
+            return ActionResult(data={"id": response.get("id", ""), "result": True}, cost_usd=0.0)
+
+        except Exception as e:
+            return ActionResult(data={"error": str(e)}, cost_usd=0.0)
+
+
+@gmail.action("read_inbox")
+class ReadInbox(ActionHandler):
+    async def execute(self, inputs: Dict[str, Any], context: ExecutionContext):
+        try:
+            service = build_gmail_service(context)
+            user_id = inputs["user_id"]
+
+            # Build query based on scope
+            scope = inputs.get("scope", "all")
+
+            if scope == "unread":
+                query = "is:unread in:inbox"
+            elif scope == "read":
+                query = "-is:unread in:inbox"
+            else:  # 'all'
+                query = "in:inbox"
+
+            request_params = {"userId": user_id, "q": query}
+            if "pageToken" in inputs:
+                request_params["pageToken"] = inputs["pageToken"]
+
+            # Get list of messages
+            request = service.users().messages().list(**request_params)
+            messages = request.execute()
+
+            inbox_emails = []
+            for message in messages.get("messages", []):
+                # Get individual message details
+                message_request = service.users().messages().get(userId=user_id, id=message["id"])
+                email_with_id = message_request.execute()
+
+                inbox_emails.append(GmailMessageParser.parse_message_with_snippet(email_with_id))
+
+            # Prepare response with pagination support
+            response = {"emails": inbox_emails, "result": True}
+
+            # Add nextPageToken if present in Gmail API response
+            if "nextPageToken" in messages:
+                response["nextPageToken"] = messages["nextPageToken"]
+
+            return ActionResult(data=response, cost_usd=0.0)
+
+        except Exception as e:
+            return ActionResult(data={"error": str(e)}, cost_usd=0.0)
+
+
+@gmail.action("read_all_mail")
+class ReadAllMail(ActionHandler):
+    async def execute(self, inputs: Dict[str, Any], context: ExecutionContext):
+        try:
+            service = build_gmail_service(context)
+            user_id = inputs["user_id"]
+
+            # No label filtering - return all mail
+            include_spam_trash = inputs.get("include_spam_trash", False)
+            scope = inputs.get("scope", "all")
+
+            if scope == "unread":
+                query = "is:unread"
+            elif scope == "read":
+                query = "-is:unread"
+            else:  # 'all'
+                query = ""
+
+            request_params = {"userId": user_id, "includeSpamTrash": include_spam_trash}
+            if query:
+                request_params["q"] = query
+            if "pageToken" in inputs:
+                request_params["pageToken"] = inputs["pageToken"]
+
+            # Get list of messages
+            request = service.users().messages().list(**request_params)
+            messages = request.execute()
+
+            all_emails = []
+            for message in messages.get("messages", []):
+                # Get individual message details
+                message_request = service.users().messages().get(userId=user_id, id=message["id"])
+                email_with_id = message_request.execute()
+
+                all_emails.append(GmailMessageParser.parse_message_with_snippet(email_with_id))
+
+            # Prepare response with pagination support
+            response = {"emails": all_emails, "result": True}
+
+            # Add nextPageToken if present in Gmail API response
+            if "nextPageToken" in messages:
+                response["nextPageToken"] = messages["nextPageToken"]
+
+            return ActionResult(data=response, cost_usd=0.0)
+
+        except Exception as e:
+            return ActionResult(data={"error": str(e)}, cost_usd=0.0)
+
+
+@gmail.action("list_labels")
+class ListLabels(ActionHandler):
+    async def execute(self, inputs: Dict[str, Any], context: ExecutionContext):
+        try:
+            service = build_gmail_service(context)
+            user_id = inputs["user_id"]
+
+            # Get list of labels
+            request = service.users().labels().list(userId=user_id)
+            result = request.execute()
+
+            labels = result.get("labels", [])
+
+            # Filter labels based on type if specified
+            if "label_type" in inputs:
+                label_type = inputs["label_type"].lower()
+                if label_type == "user":
+                    labels = [label for label in labels if label.get("type") == "user"]
+                elif label_type == "system":
+                    labels = [label for label in labels if label.get("type") == "system"]
+
+            return ActionResult(data={"labels": labels, "result": True}, cost_usd=0.0)
+
+        except Exception as e:
+            return ActionResult(data={"error": str(e)}, cost_usd=0.0)
+
+
+@gmail.action("list_emails_by_label")
+class ListEmailsByLabel(ActionHandler):
+    async def execute(self, inputs: Dict[str, Any], context: ExecutionContext):
+        try:
+            service = build_gmail_service(context)
+            user_id = inputs["user_id"]
+            label_names = inputs["label_names"]
+
+            # Build query for label filtering
+            if isinstance(label_names, list):
+                # Multiple labels - emails must have ALL specified labels
+                label_query = " ".join([f"label:{label_name}" for label_name in label_names])
+            else:
+                # Single label
+                label_query = f"label:{label_names}"
+
+            # Default to inbox-only emails unless include_archived is True
+            # Exception: if user explicitly requests INBOX label, don't add inbox restriction
+            include_archived = inputs.get("include_archived", False)
+            if not include_archived:
+                # Check if INBOX is already in the query (case-insensitive)
+                label_names_list = label_names if isinstance(label_names, list) else [label_names]
+                inbox_already_specified = any(name.upper() == "INBOX" for name in label_names_list)
+
+                if not inbox_already_specified:
+                    label_query += " in:inbox"
+
+            # Build request parameters
+            request_params = {"userId": user_id, "q": label_query}
+
+            if "pageToken" in inputs:
+                request_params["pageToken"] = inputs["pageToken"]
+            if "maxResults" in inputs:
+                request_params["maxResults"] = inputs["maxResults"]
+
+            # Get list of messages
+            request = service.users().messages().list(**request_params)
+            messages = request.execute()
+
+            emails = []
+            for message in messages.get("messages", []):
+                # Get individual message details
+                message_request = service.users().messages().get(userId=user_id, id=message["id"])
+                email_with_id = message_request.execute()
+
+                # Trust the Gmail API query - no additional filtering needed
+                emails.append(GmailMessageParser.parse_message_with_snippet(email_with_id))
+
+            # Prepare response with pagination support
+            response = {"emails": emails, "result": True}
+
+            # Add nextPageToken if present in Gmail API response
+            if "nextPageToken" in messages:
+                response["nextPageToken"] = messages["nextPageToken"]
+
+            return ActionResult(data=response, cost_usd=0.0)
+
+        except Exception as e:
+            return ActionResult(data={"error": str(e)}, cost_usd=0.0)
+
+
+@gmail.action("add_labels_to_emails")
+class AddLabelsToEmails(ActionHandler):
+    async def execute(self, inputs: Dict[str, Any], context: ExecutionContext):
+        try:
+            service = build_gmail_service(context)
+            user_id = inputs["user_id"]
+            message_ids = inputs["message_ids"]
+            label_ids = inputs["label_ids"]
+
+            body = {"ids": message_ids, "addLabelIds": label_ids, "removeLabelIds": []}
+
+            request = service.users().messages().batchModify(userId=user_id, body=body)
+            request.execute()
+
+            return ActionResult(data={"result": True}, cost_usd=0.0)
+
+        except Exception as e:
+            return ActionResult(data={"error": str(e)}, cost_usd=0.0)
+
+
+@gmail.action("remove_labels_from_emails")
+class RemoveLabelsFromEmails(ActionHandler):
+    async def execute(self, inputs: Dict[str, Any], context: ExecutionContext):
+        try:
+            service = build_gmail_service(context)
+            user_id = inputs["user_id"]
+            message_ids = inputs["message_ids"]
+            label_ids = inputs["label_ids"]
+
+            body = {"ids": message_ids, "addLabelIds": [], "removeLabelIds": label_ids}
+
+            request = service.users().messages().batchModify(userId=user_id, body=body)
+            request.execute()
+
+            return ActionResult(data={"result": True}, cost_usd=0.0)
+
+        except Exception as e:
+            return ActionResult(data={"error": str(e)}, cost_usd=0.0)
+
+
+@gmail.action("create_label")
+class CreateLabel(ActionHandler):
+    async def execute(self, inputs: Dict[str, Any], context: ExecutionContext):
+        try:
+            service = build_gmail_service(context)
+            user_id = inputs["user_id"]
+
+            # Build the label object for creation
+            label_body = {
+                "name": inputs["name"],
+                "messageListVisibility": inputs.get("messageListVisibility", "show"),
+                "labelListVisibility": inputs.get("labelListVisibility", "labelShow"),
+            }
+
+            # Add color if provided
+            if "textColor" in inputs or "backgroundColor" in inputs:
+                color = {}
+                if "textColor" in inputs:
+                    color["textColor"] = inputs["textColor"]
+                if "backgroundColor" in inputs:
+                    color["backgroundColor"] = inputs["backgroundColor"]
+                label_body["color"] = color
+
+            # Create the label using Gmail API
+            request = service.users().labels().create(userId=user_id, body=label_body)
+            created_label = request.execute()
+
+            return ActionResult(
+                data={
+                    "label": {
+                        "id": created_label.get("id", ""),
+                        "name": created_label.get("name", ""),
+                        "type": created_label.get("type", "user"),
+                        "messageListVisibility": created_label.get("messageListVisibility", "show"),
+                        "labelListVisibility": created_label.get("labelListVisibility", "labelShow"),
+                    },
+                    "result": True,
+                },
+                cost_usd=0.0,
+            )
+
+        except Exception as e:
+            return ActionResult(data={"error": str(e)}, cost_usd=0.0)
+
+
+@gmail.action("get_thread_emails")
+class GetThreadEmails(ActionHandler):
+    async def execute(self, inputs: Dict[str, Any], context: ExecutionContext):
+        try:
+            service = build_gmail_service(context)
+            user_id = inputs["user_id"]
+            thread_id = inputs["thread_id"]
+
+            # Get the thread with all messages
+            thread_request = service.users().threads().get(userId=user_id, id=thread_id)
+            thread_data = thread_request.execute()
+
+            thread_emails = []
+            for message in thread_data.get("messages", []):
+                # Parse each message in the thread
+                parsed_email = GmailMessageParser.parse_message_with_snippet(message)
+                thread_emails.append(parsed_email)
+
+            # Sort emails by date to ensure chronological order
+            # Parse the date string and sort by it
+            def parse_date_for_sorting(email):
+                try:
+                    # Gmail date format is typically: "Mon, 1 Jan 2024 12:00:00 +0000"
+                    from email.utils import parsedate_to_datetime
+
+                    return parsedate_to_datetime(email["date"])
+                except Exception:
+                    # Fallback: use the email ID as a rough ordering mechanism
+                    return email["id"]
+
+            thread_emails.sort(key=parse_date_for_sorting)
+
+            return ActionResult(data={"thread_id": thread_id, "emails": thread_emails, "result": True}, cost_usd=0.0)
+
+        except Exception as e:
+            return ActionResult(data={"error": str(e)}, cost_usd=0.0)
+
+
+@gmail.action("archive_emails")
+class ArchiveEmails(ActionHandler):
+    async def execute(self, inputs: Dict[str, Any], context: ExecutionContext):
+        try:
+            service = build_gmail_service(context)
+            user_id = inputs["user_id"]
+            ids = inputs["ids"]
+
+            body = {"ids": ids, "addLabelIds": [], "removeLabelIds": ["INBOX"]}
+
+            request = service.users().messages().batchModify(userId=user_id, body=body)
+            request.execute()
+
+            return ActionResult(data={"result": True}, cost_usd=0.0)
+
+        except Exception as e:
+            return ActionResult(data={"error": str(e)}, cost_usd=0.0)
+
+
+@gmail.action("create_draft")
+class CreateDraft(ActionHandler):
+    async def execute(self, inputs: Dict[str, Any], context: ExecutionContext):
+        try:
+            service = build_gmail_service(context)
+            user_id = inputs.get("user_id", "me")
+
+            # Get user's email address for From header if not provided
+            if "from" not in inputs or not inputs["from"] or inputs["from"] == "me":
+                profile = service.users().getProfile(userId=user_id).execute()
+                inputs["from"] = profile["emailAddress"]
+
+            # Check if this is a reply (thread_id and message_id provided)
+            is_reply = (
+                "thread_id" in inputs
+                and inputs.get("thread_id")
+                and "message_id" in inputs
+                and inputs.get("message_id")
+            )
+
+            if is_reply:
+                # Handle reply draft with threading headers
+                thread_id = inputs["thread_id"]
+                message_id = inputs["message_id"]
+
+                # Fetch the original message to get proper headers and recipient info
+                original_message = service.users().messages().get(userId=user_id, id=message_id).execute()
+                headers = original_message["payload"]["headers"]
+
+                # Get original sender to set as recipient for the reply
+                original_from = GmailMessageParser.get_header_value(headers, "From")
+
+                # Get Message-ID header for proper threading
+                message_id_header = GmailMessageParser.get_header_value(headers, "Message-ID")
+
+                # Get original subject for Re: prefix
+                original_subject = GmailMessageParser.get_header_value(headers, "Subject")
+
+                # Get References header for threading
+                references = GmailMessageParser.get_header_value(headers, "References")
+
+                # Set recipients: if not provided, default to original sender
+                if "to" not in inputs or not inputs["to"]:
+                    inputs["to"] = [original_from]
+                elif isinstance(inputs["to"], str):
+                    inputs["to"] = [inputs["to"]]
+                else:
+                    # If 'to' is provided as list, prepend original sender
+                    if original_from not in inputs["to"]:
+                        inputs["to"] = [original_from] + list(inputs["to"])
+
+                # Set subject with Re: prefix if not provided
+                if "subject" not in inputs or not inputs["subject"]:
+                    if original_subject.startswith("Re:"):
+                        inputs["subject"] = original_subject
+                    else:
+                        inputs["subject"] = f"Re: {original_subject}"
+
+                # Create the draft reply message with threading headers
+                draft_message = {
+                    "raw": self._create_raw_email(inputs, message_id_header, references),
+                    "threadId": thread_id,
+                }
+            else:
+                # Create a new draft (not a reply)
+                draft_message = {"raw": self._create_raw_email(inputs)}
+
+            # Create the draft using Gmail API
+            draft_body = {"message": draft_message}
+            request = service.users().drafts().create(userId=user_id, body=draft_body)
+            response = request.execute()
+
+            return ActionResult(
+                data={
+                    "draft": {
+                        "id": response.get("id", ""),
+                        "message": {
+                            "id": response.get("message", {}).get("id", ""),
+                            "threadId": response.get("message", {}).get("threadId", ""),
+                        },
+                    },
+                    "result": True,
+                },
+                cost_usd=0.0,
+            )
+
+        except Exception as e:
+            return ActionResult(data={"error": str(e)}, cost_usd=0.0)
+
+    def _create_raw_email(self, inputs: Dict[str, Any], message_id_header: str = None, references: str = None) -> str:
+        """Create base64 encoded email message for draft."""
+        # Determine if HTML formatting is requested
+        body_format = inputs.get("body_format", "text")
+        is_html = body_format == "html"
+
+        # Create message with optional files and HTML support
+        input_files = inputs.get("files", [])
+        body = inputs.get("body", "")
+        message = create_email_message(body, input_files, is_html)
+
+        # Add From header (REQUIRED for drafts to display properly in Gmail)
+        if "from" in inputs and inputs["from"]:
+            message["from"] = inputs["from"]
+
+        # Add reply headers for proper threading if provided
+        if message_id_header:
+            message["In-Reply-To"] = message_id_header
+            # Combine existing references with the new message ID
+            if references:
+                message["References"] = f"{references} {message_id_header}"
+            else:
+                message["References"] = message_id_header
+
+        # Handle recipients
+        if "to" in inputs and inputs["to"]:
+            if isinstance(inputs["to"], list):
+                message["to"] = ", ".join(inputs["to"])
+            else:
+                message["to"] = inputs["to"]
+
+        # Handle CC recipients if present
+        if "cc" in inputs and inputs["cc"]:
+            if isinstance(inputs["cc"], list):
+                message["cc"] = ", ".join(inputs["cc"])
+            else:
+                message["cc"] = inputs["cc"]
+
+        # Handle BCC recipients if present
+        if "bcc" in inputs and inputs["bcc"]:
+            if isinstance(inputs["bcc"], list):
+                message["bcc"] = ", ".join(inputs["bcc"])
+            else:
+                message["bcc"] = inputs["bcc"]
+
+        # Set subject
+        if "subject" in inputs and inputs["subject"]:
+            message["subject"] = inputs["subject"]
+
+        # Encode the message
+        return base64.urlsafe_b64encode(message.as_bytes()).decode()
+
+
+@gmail.action("update_draft")
+class UpdateDraft(ActionHandler):
+    async def execute(self, inputs: Dict[str, Any], context: ExecutionContext):
+        try:
+            service = build_gmail_service(context)
+            user_id = inputs.get("user_id", "me")
+            draft_id = inputs["draft_id"]
+
+            # Get user's email address for From header if not provided
+            if "from" not in inputs or not inputs["from"] or inputs["from"] == "me":
+                profile = service.users().getProfile(userId=user_id).execute()
+                inputs["from"] = profile["emailAddress"]
+
+            # Fetch the existing draft to preserve threadId and threading headers
+            existing_draft = service.users().drafts().get(userId=user_id, id=draft_id, format="metadata").execute()
+            existing_thread_id = existing_draft.get("message", {}).get("threadId")
+
+            # Get existing headers for threading info (In-Reply-To, References)
+            existing_headers = existing_draft.get("message", {}).get("payload", {}).get("headers", [])
+            message_id_header = None
+            references = None
+            for header in existing_headers:
+                if header["name"] == "In-Reply-To":
+                    message_id_header = header["value"]
+                elif header["name"] == "References":
+                    references = header["value"]
+
+            # Create the updated email message with threading headers if this was a reply
+            draft_message = {"raw": self._create_raw_email(inputs, message_id_header, references)}
+
+            # Preserve threadId if the draft was part of a thread
+            if existing_thread_id:
+                draft_message["threadId"] = existing_thread_id
+
+            # Update the draft using Gmail API
+            draft_body = {"message": draft_message}
+            request = service.users().drafts().update(userId=user_id, id=draft_id, body=draft_body)
+            response = request.execute()
+
+            return ActionResult(
+                data={
+                    "draft": {
+                        "id": response.get("id", ""),
+                        "message": {
+                            "id": response.get("message", {}).get("id", ""),
+                            "threadId": response.get("message", {}).get("threadId", ""),
+                        },
+                    },
+                    "result": True,
+                },
+                cost_usd=0.0,
+            )
+
+        except Exception as e:
+            return ActionResult(data={"error": str(e)}, cost_usd=0.0)
+
+    def _create_raw_email(self, inputs: Dict[str, Any], message_id_header: str = None, references: str = None) -> str:
+        """Create base64 encoded email message for draft."""
+        # Determine if HTML formatting is requested
+        body_format = inputs.get("body_format", "text")
+        is_html = body_format == "html"
+
+        # Create message with optional files and HTML support
+        input_files = inputs.get("files", [])
+        body = inputs.get("body", "")
+        message = create_email_message(body, input_files, is_html)
+
+        # Add From header (REQUIRED for drafts to display properly in Gmail)
+        if "from" in inputs and inputs["from"]:
+            message["from"] = inputs["from"]
+
+        # Add reply headers for proper threading if provided (preserved from existing draft)
+        if message_id_header:
+            message["In-Reply-To"] = message_id_header
+            # Combine existing references with the message ID
+            if references:
+                message["References"] = references
+            else:
+                message["References"] = message_id_header
+
+        # Handle recipients
+        if "to" in inputs and inputs["to"]:
+            if isinstance(inputs["to"], list):
+                message["to"] = ", ".join(inputs["to"])
+            else:
+                message["to"] = inputs["to"]
+
+        # Handle CC recipients if present
+        if "cc" in inputs and inputs["cc"]:
+            if isinstance(inputs["cc"], list):
+                message["cc"] = ", ".join(inputs["cc"])
+            else:
+                message["cc"] = inputs["cc"]
+
+        # Handle BCC recipients if present
+        if "bcc" in inputs and inputs["bcc"]:
+            if isinstance(inputs["bcc"], list):
+                message["bcc"] = ", ".join(inputs["bcc"])
+            else:
+                message["bcc"] = inputs["bcc"]
+
+        # Set subject
+        if "subject" in inputs and inputs["subject"]:
+            message["subject"] = inputs["subject"]
+
+        # Encode the message
+        return base64.urlsafe_b64encode(message.as_bytes()).decode()
+
+
+@gmail.action("list_drafts")
+class ListDrafts(ActionHandler):
+    async def execute(self, inputs: Dict[str, Any], context: ExecutionContext):
+        try:
+            service = build_gmail_service(context)
+            user_id = inputs.get("user_id", "me")
+
+            # Build request parameters
+            request_params = {"userId": user_id}
+
+            if "pageToken" in inputs:
+                request_params["pageToken"] = inputs["pageToken"]
+
+            if "maxResults" in inputs:
+                request_params["maxResults"] = inputs["maxResults"]
+
+            if "q" in inputs:
+                request_params["q"] = inputs["q"]
+
+            if "includeSpamTrash" in inputs:
+                request_params["includeSpamTrash"] = inputs["includeSpamTrash"]
+
+            # Get list of drafts
+            request = service.users().drafts().list(**request_params)
+            response = request.execute()
+
+            drafts = response.get("drafts", [])
+
+            # Prepare response with pagination support
+            result = {"drafts": drafts, "result": True}
+
+            # Add pagination info if present
+            if "nextPageToken" in response:
+                result["nextPageToken"] = response["nextPageToken"]
+
+            if "resultSizeEstimate" in response:
+                result["resultSizeEstimate"] = response["resultSizeEstimate"]
+
+            return ActionResult(data=result, cost_usd=0.0)
+
+        except Exception as e:
+            return ActionResult(data={"error": str(e)}, cost_usd=0.0)
+
+
+@gmail.action("get_draft")
+class GetDraft(ActionHandler):
+    async def execute(self, inputs: Dict[str, Any], context: ExecutionContext):
+        try:
+            service = build_gmail_service(context)
+            user_id = inputs.get("user_id", "me")
+            draft_id = inputs["draft_id"]
+            format_type = inputs.get("format", "full")
+
+            # Get the draft with specified format
+            request = service.users().drafts().get(userId=user_id, id=draft_id, format=format_type)
+            draft_data = request.execute()
+
+            # Parse the draft message if format is full
+            draft_info = {
+                "id": draft_data.get("id", ""),
+                "message": {
+                    "id": draft_data.get("message", {}).get("id", ""),
+                    "threadId": draft_data.get("message", {}).get("threadId", ""),
+                },
+            }
+
+            extracted_files = []
+
+            # If format is full, parse the message content
+            if format_type == "full" and "message" in draft_data:
+                message_data = draft_data["message"]
+                if "payload" in message_data:
+                    # Parse message headers and content
+                    headers = message_data["payload"].get("headers", [])
+
+                    draft_info["message"].update(
+                        {
+                            "subject": GmailMessageParser.get_header_value(headers, "Subject"),
+                            "from": GmailMessageParser.get_header_value(headers, "From"),
+                            "to": GmailMessageParser.get_header_value(headers, "To"),
+                            "cc": GmailMessageParser.parse_email_list(
+                                GmailMessageParser.get_header_value(headers, "Cc")
+                            ),
+                            "bcc": GmailMessageParser.parse_email_list(
+                                GmailMessageParser.get_header_value(headers, "Bcc")
+                            ),
+                            "body": GmailMessageParser.extract_plain_text(message_data["payload"]),
+                        }
+                    )
+
+                    # Extract files if present
+                    extracted_files = GmailMessageParser.extract_files(
+                        service, user_id, message_data["id"], message_data["payload"]
+                    )
+
+            return ActionResult(data={"draft": draft_info, "files": extracted_files, "result": True}, cost_usd=0.0)
+
+        except Exception as e:
+            return ActionResult(data={"error": str(e)}, cost_usd=0.0)
+
+
+@gmail.action("send_draft")
+class SendDraft(ActionHandler):
+    async def execute(self, inputs: Dict[str, Any], context: ExecutionContext):
+        try:
+            service = build_gmail_service(context)
+            user_id = inputs.get("user_id", "me")
+            draft_id = inputs["draft_id"]
+
+            # Send the draft using Gmail API
+            draft_body = {"id": draft_id}
+            request = service.users().drafts().send(userId=user_id, body=draft_body)
+            response = request.execute()
+
+            return ActionResult(
+                data={
+                    "message": {"id": response.get("id", ""), "threadId": response.get("threadId", "")},
+                    "result": True,
+                },
+                cost_usd=0.0,
+            )
+
+        except Exception as e:
+            return ActionResult(data={"error": str(e)}, cost_usd=0.0)
+
+
+@gmail.action("delete_draft")
+class DeleteDraft(ActionHandler):
+    async def execute(self, inputs: Dict[str, Any], context: ExecutionContext):
+        try:
+            service = build_gmail_service(context)
+            user_id = inputs.get("user_id", "me")
+            draft_id = inputs["draft_id"]
+
+            # Delete the draft using Gmail API
+            request = service.users().drafts().delete(userId=user_id, id=draft_id)
+            request.execute()
+
+            return ActionResult(data={"result": True}, cost_usd=0.0)
+
+        except Exception as e:
+            return ActionResult(data={"error": str(e)}, cost_usd=0.0)
diff --git a/gmail/icon.png b/gmail/icon.png
new file mode 100644
index 00000000..9456450c
Binary files /dev/null and b/gmail/icon.png differ
diff --git a/gmail/requirements.txt b/gmail/requirements.txt
new file mode 100644
index 00000000..ff5185cc
--- /dev/null
+++ b/gmail/requirements.txt
@@ -0,0 +1,6 @@
+autohive-integrations-sdk~=1.0.2
+google-api-python-client
+google-auth-httplib2
+google-auth-oauthlib
+html2text
+bleach
diff --git a/gmail/tests/__init__.py b/gmail/tests/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/gmail/tests/context.py b/gmail/tests/context.py
new file mode 100644
index 00000000..27343b77
--- /dev/null
+++ b/gmail/tests/context.py
@@ -0,0 +1,5 @@
+import os
+import sys
+
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
+from gmail import gmail  # noqa: F401
diff --git a/gmail/tests/test_gmail.py b/gmail/tests/test_gmail.py
new file mode 100644
index 00000000..77e0900d
--- /dev/null
+++ b/gmail/tests/test_gmail.py
@@ -0,0 +1,6 @@
+import context  # noqa: F401
+
+
+def test_placeholder():
+    """Placeholder test — replace with real tests."""
+    pass