@bubblelab/bubble-core 0.1.0

package/dist/bubbles/service-bubble/gmail.js

@@ -0,0 +1,908 @@
+import { z } from 'zod';
+import { ServiceBubble } from '../../types/service-bubble-class.js';
+import { CredentialType } from '@bubblelab/shared-schemas';
+// Define email header schema
+const EmailHeaderSchema = z
+    .object({
+    name: z.string().describe('Header name (e.g., "Subject", "From", "To")'),
+    value: z.string().describe('Header value'),
+})
+    .describe('Email header key-value pair');
+// Define email message schema
+const GmailMessageSchema = z
+    .object({
+    id: z.string().describe('Unique message identifier'),
+    threadId: z.string().describe('Thread identifier this message belongs to'),
+    labelIds: z
+        .array(z.string())
+        .optional()
+        .describe('List of label IDs applied to this message'),
+    snippet: z
+        .string()
+        .optional()
+        .describe('Short snippet of the message text'),
+    historyId: z
+        .string()
+        .optional()
+        .describe('History record ID that last modified this message'),
+    internalDate: z
+        .string()
+        .optional()
+        .describe('Internal message creation timestamp (epoch ms)'),
+    sizeEstimate: z.number().optional().describe('Estimated size in bytes'),
+    raw: z
+        .string()
+        .optional()
+        .describe('Entire email message in RFC 2822 format (base64url encoded)'),
+    payload: z
+        .object({
+        mimeType: z
+            .string()
+            .optional()
+            .describe('MIME type of the email content'),
+        headers: z
+            .array(EmailHeaderSchema)
+            .optional()
+            .describe('Email headers (Subject, From, To, etc.)'),
+        body: z
+            .object({
+            data: z
+                .string()
+                .optional()
+                .describe('Email body content (base64url encoded)'),
+            size: z
+                .number()
+                .optional()
+                .describe('Size of the body content in bytes'),
+            attachmentId: z
+                .string()
+                .optional()
+                .describe('ID of the attachment if this body part is an attachment'),
+        })
+            .optional()
+            .describe('Email body content and metadata'),
+        parts: z
+            .array(z.any())
+            .optional()
+            .describe('Array of message parts for multipart emails'),
+    })
+        .optional()
+        .describe('Parsed email structure'),
+})
+    .describe('Gmail message object');
+// Define draft schema
+const GmailDraftSchema = z
+    .object({
+    id: z.string().describe('Unique draft identifier'),
+    message: GmailMessageSchema.describe('Draft message content'),
+})
+    .describe('Gmail draft object');
+// Define thread schema
+const GmailThreadSchema = z
+    .object({
+    id: z.string().describe('Unique thread identifier'),
+    historyId: z.string().optional().describe('Last history record ID'),
+    messages: z
+        .array(GmailMessageSchema)
+        .optional()
+        .describe('Messages in this thread'),
+    snippet: z.string().optional().describe('Thread snippet'),
+})
+    .describe('Gmail thread object');
+// Define the parameters schema for Gmail operations
+const GmailParamsSchema = z.discriminatedUnion('operation', [
+    // Send email operation
+    z.object({
+        operation: z.literal('send_email').describe('Send an email message'),
+        to: z
+            .array(z.string().email())
+            .min(1, 'At least one recipient is required')
+            .describe('List of recipient email addresses'),
+        cc: z
+            .array(z.string().email())
+            .optional()
+            .describe('List of CC recipient email addresses'),
+        bcc: z
+            .array(z.string().email())
+            .optional()
+            .describe('List of BCC recipient email addresses'),
+        subject: z
+            .string()
+            .min(1, 'Subject is required')
+            .describe('Email subject line'),
+        body_text: z.string().optional().describe('Plain text email body'),
+        body_html: z.string().optional().describe('HTML email body'),
+        reply_to: z.string().email().optional().describe('Reply-to email address'),
+        thread_id: z
+            .string()
+            .optional()
+            .describe('Thread ID to reply to (for threaded conversations)'),
+        credentials: z
+            .record(z.nativeEnum(CredentialType), z.string())
+            .optional()
+            .describe('Object mapping credential types to values (injected at runtime)'),
+    }),
+    // List emails operation
+    z.object({
+        operation: z
+            .literal('list_emails')
+            .describe('List emails in the user mailbox'),
+        query: z
+            .string()
+            .optional()
+            .describe('Gmail search query (e.g., "from:user@example.com is:unread")'),
+        label_ids: z
+            .array(z.string())
+            .optional()
+            .describe('Filter by specific label IDs'),
+        include_spam_trash: z
+            .boolean()
+            .optional()
+            .default(false)
+            .describe('Include messages from SPAM and TRASH'),
+        max_results: z
+            .number()
+            .min(1)
+            .max(500)
+            .optional()
+            .default(100)
+            .describe('Maximum number of messages to return'),
+        page_token: z
+            .string()
+            .optional()
+            .describe('Token for pagination to get next page'),
+        credentials: z
+            .record(z.nativeEnum(CredentialType), z.string())
+            .optional()
+            .describe('Object mapping credential types to values (injected at runtime)'),
+    }),
+    // Get email operation
+    z.object({
+        operation: z.literal('get_email').describe('Get a specific email message'),
+        message_id: z
+            .string()
+            .min(1, 'Message ID is required')
+            .describe('Gmail message ID to retrieve'),
+        format: z
+            .enum(['minimal', 'full', 'raw', 'metadata'])
+            .optional()
+            .default('full')
+            .describe('Format to return the message in'),
+        metadata_headers: z
+            .array(z.string())
+            .optional()
+            .describe('List of headers to include when format is metadata'),
+        credentials: z
+            .record(z.nativeEnum(CredentialType), z.string())
+            .optional()
+            .describe('Object mapping credential types to values (injected at runtime)'),
+    }),
+    // Search emails operation
+    z.object({
+        operation: z.literal('search_emails').describe('Search emails with query'),
+        query: z
+            .string()
+            .min(1, 'Search query is required')
+            .describe('Gmail search query string'),
+        max_results: z
+            .number()
+            .min(1)
+            .max(500)
+            .optional()
+            .default(50)
+            .describe('Maximum number of results to return'),
+        include_spam_trash: z
+            .boolean()
+            .optional()
+            .default(false)
+            .describe('Include messages from SPAM and TRASH'),
+        credentials: z
+            .record(z.nativeEnum(CredentialType), z.string())
+            .optional()
+            .describe('Object mapping credential types to values (injected at runtime)'),
+    }),
+    // Mark as read operation
+    z.object({
+        operation: z
+            .literal('mark_as_read')
+            .describe('Mark one or more messages as read'),
+        message_ids: z
+            .array(z.string())
+            .min(1, 'At least one message ID is required')
+            .describe('List of message IDs to mark as read'),
+        credentials: z
+            .record(z.nativeEnum(CredentialType), z.string())
+            .optional()
+            .describe('Object mapping credential types to values (injected at runtime)'),
+    }),
+    // Mark as unread operation
+    z.object({
+        operation: z
+            .literal('mark_as_unread')
+            .describe('Mark one or more messages as unread'),
+        message_ids: z
+            .array(z.string())
+            .min(1, 'At least one message ID is required')
+            .describe('List of message IDs to mark as unread'),
+        credentials: z
+            .record(z.nativeEnum(CredentialType), z.string())
+            .optional()
+            .describe('Object mapping credential types to values (injected at runtime)'),
+    }),
+    // Create draft operation
+    z.object({
+        operation: z.literal('create_draft').describe('Create a draft email'),
+        to: z
+            .array(z.string().email())
+            .min(1, 'At least one recipient is required')
+            .describe('List of recipient email addresses'),
+        cc: z
+            .array(z.string().email())
+            .optional()
+            .describe('List of CC recipient email addresses'),
+        bcc: z
+            .array(z.string().email())
+            .optional()
+            .describe('List of BCC recipient email addresses'),
+        subject: z
+            .string()
+            .min(1, 'Subject is required')
+            .describe('Email subject line'),
+        body_text: z.string().optional().describe('Plain text email body'),
+        body_html: z.string().optional().describe('HTML email body'),
+        reply_to: z.string().email().optional().describe('Reply-to email address'),
+        thread_id: z
+            .string()
+            .optional()
+            .describe('Thread ID to reply to (for threaded conversations)'),
+        credentials: z
+            .record(z.nativeEnum(CredentialType), z.string())
+            .optional()
+            .describe('Object mapping credential types to values (injected at runtime)'),
+    }),
+    // Send draft operation
+    z.object({
+        operation: z.literal('send_draft').describe('Send a draft email'),
+        draft_id: z
+            .string()
+            .min(1, 'Draft ID is required')
+            .describe('Gmail draft ID to send'),
+        credentials: z
+            .record(z.nativeEnum(CredentialType), z.string())
+            .optional()
+            .describe('Object mapping credential types to values (injected at runtime)'),
+    }),
+    // List drafts operation
+    z.object({
+        operation: z.literal('list_drafts').describe('List draft emails'),
+        query: z.string().optional().describe('Search query to filter drafts'),
+        max_results: z
+            .number()
+            .min(1)
+            .max(500)
+            .optional()
+            .default(100)
+            .describe('Maximum number of drafts to return'),
+        page_token: z
+            .string()
+            .optional()
+            .describe('Token for pagination to get next page'),
+        include_spam_trash: z
+            .boolean()
+            .optional()
+            .default(false)
+            .describe('Include drafts from SPAM and TRASH'),
+        credentials: z
+            .record(z.nativeEnum(CredentialType), z.string())
+            .optional()
+            .describe('Object mapping credential types to values (injected at runtime)'),
+    }),
+    // Delete email operation
+    z.object({
+        operation: z
+            .literal('delete_email')
+            .describe('Delete an email message permanently'),
+        message_id: z
+            .string()
+            .min(1, 'Message ID is required')
+            .describe('Gmail message ID to delete'),
+        credentials: z
+            .record(z.nativeEnum(CredentialType), z.string())
+            .optional()
+            .describe('Object mapping credential types to values (injected at runtime)'),
+    }),
+    // Trash email operation
+    z.object({
+        operation: z
+            .literal('trash_email')
+            .describe('Move an email message to trash'),
+        message_id: z
+            .string()
+            .min(1, 'Message ID is required')
+            .describe('Gmail message ID to move to trash'),
+        credentials: z
+            .record(z.nativeEnum(CredentialType), z.string())
+            .optional()
+            .describe('Object mapping credential types to values (injected at runtime)'),
+    }),
+    // List threads operation
+    z.object({
+        operation: z.literal('list_threads').describe('List email threads'),
+        query: z
+            .string()
+            .optional()
+            .describe('Gmail search query to filter threads'),
+        label_ids: z
+            .array(z.string())
+            .optional()
+            .describe('Filter by specific label IDs'),
+        include_spam_trash: z
+            .boolean()
+            .optional()
+            .default(false)
+            .describe('Include threads from SPAM and TRASH'),
+        max_results: z
+            .number()
+            .min(1)
+            .max(500)
+            .optional()
+            .default(100)
+            .describe('Maximum number of threads to return'),
+        page_token: z
+            .string()
+            .optional()
+            .describe('Token for pagination to get next page'),
+        credentials: z
+            .record(z.nativeEnum(CredentialType), z.string())
+            .optional()
+            .describe('Object mapping credential types to values (injected at runtime)'),
+    }),
+]);
+// Define result schemas for different operations
+const GmailResultSchema = z.discriminatedUnion('operation', [
+    z.object({
+        operation: z.literal('send_email').describe('Send an email message'),
+        success: z.boolean().describe('Whether the email was sent successfully'),
+        message_id: z.string().optional().describe('Sent message ID'),
+        thread_id: z.string().optional().describe('Thread ID'),
+        error: z.string().describe('Error message if operation failed'),
+    }),
+    z.object({
+        operation: z
+            .literal('list_emails')
+            .describe('List emails in the user mailbox'),
+        success: z
+            .boolean()
+            .describe('Whether the email list was retrieved successfully'),
+        messages: z
+            .array(GmailMessageSchema)
+            .optional()
+            .describe('List of email messages'),
+        next_page_token: z
+            .string()
+            .optional()
+            .describe('Token for fetching next page'),
+        result_size_estimate: z
+            .number()
+            .optional()
+            .describe('Estimated total number of results'),
+        error: z.string().describe('Error message if operation failed'),
+    }),
+    z.object({
+        operation: z.literal('get_email').describe('Get a specific email message'),
+        success: z
+            .boolean()
+            .describe('Whether the email was retrieved successfully'),
+        message: GmailMessageSchema.optional().describe('Email message details'),
+        error: z.string().describe('Error message if operation failed'),
+    }),
+    z.object({
+        operation: z.literal('search_emails').describe('Search emails with query'),
+        success: z
+            .boolean()
+            .describe('Whether the email search was completed successfully'),
+        messages: z
+            .array(GmailMessageSchema)
+            .optional()
+            .describe('List of matching email messages'),
+        result_size_estimate: z
+            .number()
+            .optional()
+            .describe('Estimated total number of results'),
+        error: z.string().describe('Error message if operation failed'),
+    }),
+    z.object({
+        operation: z
+            .literal('mark_as_read')
+            .describe('Mark one or more messages as read'),
+        success: z
+            .boolean()
+            .describe('Whether the messages were marked as read successfully'),
+        modified_messages: z
+            .array(z.string())
+            .optional()
+            .describe('IDs of messages that were modified'),
+        error: z.string().describe('Error message if operation failed'),
+    }),
+    z.object({
+        operation: z
+            .literal('mark_as_unread')
+            .describe('Mark one or more messages as unread'),
+        success: z
+            .boolean()
+            .describe('Whether the messages were marked as unread successfully'),
+        modified_messages: z
+            .array(z.string())
+            .optional()
+            .describe('IDs of messages that were modified'),
+        error: z.string().describe('Error message if operation failed'),
+    }),
+    z.object({
+        operation: z.literal('create_draft').describe('Create a draft email'),
+        success: z.boolean().describe('Whether the draft was created successfully'),
+        draft: GmailDraftSchema.optional().describe('Created draft'),
+        error: z.string().describe('Error message if operation failed'),
+    }),
+    z.object({
+        operation: z.literal('send_draft').describe('Send a draft email'),
+        success: z.boolean().describe('Whether the draft was sent successfully'),
+        message_id: z.string().optional().describe('Sent message ID'),
+        thread_id: z.string().optional().describe('Thread ID'),
+        error: z.string().describe('Error message if operation failed'),
+    }),
+    z.object({
+        operation: z.literal('list_drafts').describe('List draft emails'),
+        success: z
+            .boolean()
+            .describe('Whether the draft list was retrieved successfully'),
+        drafts: z.array(GmailDraftSchema).optional().describe('List of drafts'),
+        next_page_token: z
+            .string()
+            .optional()
+            .describe('Token for fetching next page'),
+        result_size_estimate: z
+            .number()
+            .optional()
+            .describe('Estimated total number of results'),
+        error: z.string().describe('Error message if operation failed'),
+    }),
+    z.object({
+        operation: z
+            .literal('delete_email')
+            .describe('Delete an email message permanently'),
+        success: z.boolean().describe('Whether the email was deleted successfully'),
+        deleted_message_id: z
+            .string()
+            .optional()
+            .describe('ID of the deleted message'),
+        error: z.string().describe('Error message if operation failed'),
+    }),
+    z.object({
+        operation: z
+            .literal('trash_email')
+            .describe('Move an email message to trash'),
+        success: z
+            .boolean()
+            .describe('Whether the email was moved to trash successfully'),
+        trashed_message_id: z
+            .string()
+            .optional()
+            .describe('ID of the trashed message'),
+        error: z.string().describe('Error message if operation failed'),
+    }),
+    z.object({
+        operation: z.literal('list_threads').describe('List email threads'),
+        success: z
+            .boolean()
+            .describe('Whether the thread list was retrieved successfully'),
+        threads: z
+            .array(GmailThreadSchema)
+            .optional()
+            .describe('List of email threads'),
+        next_page_token: z
+            .string()
+            .optional()
+            .describe('Token for fetching next page'),
+        result_size_estimate: z
+            .number()
+            .optional()
+            .describe('Estimated total number of results'),
+        error: z.string().describe('Error message if operation failed'),
+    }),
+]);
+export class GmailBubble extends ServiceBubble {
+    static type = 'service';
+    static service = 'gmail';
+    static authType = 'oauth';
+    static bubbleName = 'gmail';
+    static schema = GmailParamsSchema;
+    static resultSchema = GmailResultSchema;
+    static shortDescription = 'Gmail integration for email management';
+    static longDescription = `
+    Gmail service integration for comprehensive email management and automation.
+    Use cases:
+    - Send and receive emails with rich formatting
+    - Search and filter emails with advanced queries
+    - Manage drafts and email threads
+    - Mark messages as read/unread
+    - Organize emails with labels and folders
+    - Handle email attachments and metadata
+  `;
+    static alias = 'gmail';
+    constructor(params = {
+        operation: 'list_emails',
+        max_results: 10,
+    }, context) {
+        super(params, context);
+    }
+    async testCredential() {
+        const credential = this.chooseCredential();
+        if (!credential) {
+            throw new Error('Gmail credentials are required');
+        }
+        try {
+            // Test the credentials by making a simple API call
+            const response = await fetch('https://www.googleapis.com/gmail/v1/users/me/profile', {
+                headers: {
+                    Authorization: `Bearer ${credential}`,
+                    'Content-Type': 'application/json',
+                },
+            });
+            return response.ok;
+        }
+        catch {
+            return false;
+        }
+    }
+    async makeGmailApiRequest(endpoint, method = 'GET', body, headers = {}) {
+        const url = endpoint.startsWith('https://')
+            ? endpoint
+            : `https://www.googleapis.com/gmail/v1/users/me${endpoint}`;
+        const requestHeaders = {
+            Authorization: `Bearer ${this.chooseCredential()}`,
+            'Content-Type': 'application/json',
+            ...headers,
+        };
+        const requestInit = {
+            method,
+            headers: requestHeaders,
+        };
+        if (body && method !== 'GET') {
+            requestInit.body = JSON.stringify(body);
+        }
+        const response = await fetch(url, requestInit);
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Gmail API error: ${response.status} ${response.statusText} - ${errorText}`);
+        }
+        // Handle empty responses
+        const contentType = response.headers.get('content-type');
+        if (contentType && contentType.includes('application/json')) {
+            return await response.json();
+        }
+        else {
+            return await response.text();
+        }
+    }
+    async performAction(context) {
+        void context;
+        const { operation } = this.params;
+        try {
+            const result = await (async () => {
+                switch (operation) {
+                    case 'send_email':
+                        return await this.sendEmail(this.params);
+                    case 'list_emails':
+                        return await this.listEmails(this.params);
+                    case 'get_email':
+                        return await this.getEmail(this.params);
+                    case 'search_emails':
+                        return await this.searchEmails(this.params);
+                    case 'mark_as_read':
+                        return await this.markAsRead(this.params);
+                    case 'mark_as_unread':
+                        return await this.markAsUnread(this.params);
+                    case 'create_draft':
+                        return await this.createDraft(this.params);
+                    case 'send_draft':
+                        return await this.sendDraft(this.params);
+                    case 'list_drafts':
+                        return await this.listDrafts(this.params);
+                    case 'delete_email':
+                        return await this.deleteEmail(this.params);
+                    case 'trash_email':
+                        return await this.trashEmail(this.params);
+                    case 'list_threads':
+                        return await this.listThreads(this.params);
+                    default:
+                        throw new Error(`Unsupported operation: ${operation}`);
+                }
+            })();
+            return result;
+        }
+        catch (error) {
+            return {
+                operation,
+                success: false,
+                error: error instanceof Error ? error.message : 'Unknown error occurred',
+            };
+        }
+    }
+    createEmailMessage(params) {
+        const { to, cc, bcc, subject, body_text, body_html, reply_to, thread_id } = params;
+        let emailContent = '';
+        emailContent += `To: ${to.join(', ')}\r\n`;
+        if (cc && cc.length > 0) {
+            emailContent += `Cc: ${cc.join(', ')}\r\n`;
+        }
+        if (bcc && bcc.length > 0) {
+            emailContent += `Bcc: ${bcc.join(', ')}\r\n`;
+        }
+        emailContent += `Subject: ${subject}\r\n`;
+        if (reply_to) {
+            emailContent += `Reply-To: ${reply_to}\r\n`;
+        }
+        if (thread_id) {
+            emailContent += `In-Reply-To: ${thread_id}\r\n`;
+            emailContent += `References: ${thread_id}\r\n`;
+        }
+        // Handle multipart content
+        if (body_text && body_html) {
+            const boundary = '----=_Part_0_123456789.123456789';
+            emailContent += `Content-Type: multipart/alternative; boundary="${boundary}"\r\n`;
+            emailContent += `\r\n`;
+            emailContent += `--${boundary}\r\n`;
+            emailContent += `Content-Type: text/plain; charset=UTF-8\r\n`;
+            emailContent += `\r\n`;
+            emailContent += `${body_text}\r\n`;
+            emailContent += `--${boundary}\r\n`;
+            emailContent += `Content-Type: text/html; charset=UTF-8\r\n`;
+            emailContent += `\r\n`;
+            emailContent += `${body_html}\r\n`;
+            emailContent += `--${boundary}--\r\n`;
+        }
+        else if (body_html) {
+            emailContent += `Content-Type: text/html; charset=UTF-8\r\n`;
+            emailContent += `\r\n`;
+            emailContent += `${body_html}\r\n`;
+        }
+        else if (body_text) {
+            emailContent += `Content-Type: text/plain; charset=UTF-8\r\n`;
+            emailContent += `\r\n`;
+            emailContent += `${body_text}\r\n`;
+        }
+        // Convert to base64url encoding
+        return Buffer.from(emailContent)
+            .toString('base64')
+            .replace(/\+/g, '-')
+            .replace(/\//g, '_')
+            .replace(/=+$/, '');
+    }
+    async sendEmail(params) {
+        const { to, cc, bcc, subject, body_text, body_html, reply_to, thread_id } = params;
+        // Validate that at least one body type is provided
+        if (!body_text && !body_html) {
+            throw new Error('Either body_text or body_html must be provided');
+        }
+        const raw = this.createEmailMessage({
+            to,
+            cc,
+            bcc,
+            subject,
+            body_text,
+            body_html,
+            reply_to,
+            thread_id,
+        });
+        const messageData = { raw };
+        if (thread_id) {
+            messageData.threadId = thread_id;
+        }
+        const response = await this.makeGmailApiRequest('/messages/send', 'POST', messageData);
+        return {
+            operation: 'send_email',
+            success: true,
+            message_id: response.id,
+            thread_id: response.threadId,
+            error: '',
+        };
+    }
+    async listEmails(params) {
+        const { query, label_ids, include_spam_trash, max_results, page_token } = params;
+        const queryParams = new URLSearchParams({
+            maxResults: max_results.toString(),
+        });
+        if (query)
+            queryParams.set('q', query);
+        if (label_ids && label_ids.length > 0) {
+            label_ids.forEach((labelId) => queryParams.append('labelIds', labelId));
+        }
+        if (include_spam_trash)
+            queryParams.set('includeSpamTrash', 'true');
+        if (page_token)
+            queryParams.set('pageToken', page_token);
+        const response = await this.makeGmailApiRequest(`/messages?${queryParams.toString()}`);
+        return {
+            operation: 'list_emails',
+            success: true,
+            messages: response.messages || [],
+            next_page_token: response.nextPageToken,
+            result_size_estimate: response.resultSizeEstimate,
+            error: '',
+        };
+    }
+    async getEmail(params) {
+        const { message_id, format, metadata_headers } = params;
+        const queryParams = new URLSearchParams({
+            format: format,
+        });
+        if (metadata_headers && metadata_headers.length > 0) {
+            metadata_headers.forEach((header) => queryParams.append('metadataHeaders', header));
+        }
+        const response = await this.makeGmailApiRequest(`/messages/${message_id}?${queryParams.toString()}`);
+        return {
+            operation: 'get_email',
+            success: true,
+            message: response,
+            error: '',
+        };
+    }
+    async searchEmails(params) {
+        const { query, max_results, include_spam_trash } = params;
+        const queryParams = new URLSearchParams({
+            q: query,
+            maxResults: max_results.toString(),
+        });
+        if (include_spam_trash)
+            queryParams.set('includeSpamTrash', 'true');
+        const response = await this.makeGmailApiRequest(`/messages?${queryParams.toString()}`);
+        return {
+            operation: 'search_emails',
+            success: true,
+            messages: response.messages || [],
+            result_size_estimate: response.resultSizeEstimate,
+            error: '',
+        };
+    }
+    async markAsRead(params) {
+        const { message_ids } = params;
+        await this.makeGmailApiRequest('/messages/batchModify', 'POST', {
+            ids: message_ids,
+            removeLabelIds: ['UNREAD'],
+        });
+        return {
+            operation: 'mark_as_read',
+            success: true,
+            modified_messages: message_ids,
+            error: '',
+        };
+    }
+    async markAsUnread(params) {
+        const { message_ids } = params;
+        await this.makeGmailApiRequest('/messages/batchModify', 'POST', {
+            ids: message_ids,
+            addLabelIds: ['UNREAD'],
+        });
+        return {
+            operation: 'mark_as_unread',
+            success: true,
+            modified_messages: message_ids,
+            error: '',
+        };
+    }
+    async createDraft(params) {
+        const { to, cc, bcc, subject, body_text, body_html, reply_to, thread_id } = params;
+        // Validate that at least one body type is provided
+        if (!body_text && !body_html) {
+            throw new Error('Either body_text or body_html must be provided');
+        }
+        const raw = this.createEmailMessage({
+            to,
+            cc,
+            bcc,
+            subject,
+            body_text,
+            body_html,
+            reply_to,
+            thread_id,
+        });
+        const draftData = {
+            message: { raw },
+        };
+        if (thread_id) {
+            draftData.message.threadId = thread_id;
+        }
+        const response = await this.makeGmailApiRequest('/drafts', 'POST', draftData);
+        return {
+            operation: 'create_draft',
+            success: true,
+            draft: response,
+            error: '',
+        };
+    }
+    async sendDraft(params) {
+        const { draft_id } = params;
+        const response = await this.makeGmailApiRequest(`/drafts/${draft_id}/send`, 'POST', {});
+        return {
+            operation: 'send_draft',
+            success: true,
+            message_id: response.id,
+            thread_id: response.threadId,
+            error: '',
+        };
+    }
+    async listDrafts(params) {
+        const { query, max_results, page_token, include_spam_trash } = params;
+        const queryParams = new URLSearchParams({
+            maxResults: max_results.toString(),
+        });
+        if (query)
+            queryParams.set('q', query);
+        if (include_spam_trash)
+            queryParams.set('includeSpamTrash', 'true');
+        if (page_token)
+            queryParams.set('pageToken', page_token);
+        const response = await this.makeGmailApiRequest(`/drafts?${queryParams.toString()}`);
+        return {
+            operation: 'list_drafts',
+            success: true,
+            drafts: response.drafts || [],
+            next_page_token: response.nextPageToken,
+            result_size_estimate: response.resultSizeEstimate,
+            error: '',
+        };
+    }
+    async deleteEmail(params) {
+        const { message_id } = params;
+        await this.makeGmailApiRequest(`/messages/${message_id}`, 'DELETE');
+        return {
+            operation: 'delete_email',
+            success: true,
+            deleted_message_id: message_id,
+            error: '',
+        };
+    }
+    async trashEmail(params) {
+        const { message_id } = params;
+        await this.makeGmailApiRequest(`/messages/${message_id}/trash`, 'POST');
+        return {
+            operation: 'trash_email',
+            success: true,
+            trashed_message_id: message_id,
+            error: '',
+        };
+    }
+    async listThreads(params) {
+        const { query, label_ids, include_spam_trash, max_results, page_token } = params;
+        const queryParams = new URLSearchParams({
+            maxResults: max_results.toString(),
+        });
+        if (query)
+            queryParams.set('q', query);
+        if (label_ids && label_ids.length > 0) {
+            label_ids.forEach((labelId) => queryParams.append('labelIds', labelId));
+        }
+        if (include_spam_trash)
+            queryParams.set('includeSpamTrash', 'true');
+        if (page_token)
+            queryParams.set('pageToken', page_token);
+        const response = await this.makeGmailApiRequest(`/threads?${queryParams.toString()}`);
+        return {
+            operation: 'list_threads',
+            success: true,
+            threads: response.threads || [],
+            next_page_token: response.nextPageToken,
+            result_size_estimate: response.resultSizeEstimate,
+            error: '',
+        };
+    }
+    chooseCredential() {
+        const { credentials } = this.params;
+        if (!credentials || typeof credentials !== 'object') {
+            throw new Error('No Gmail credentials provided');
+        }
+        // Gmail bubble uses GMAIL_CRED credentials
+        return credentials[CredentialType.GMAIL_CRED];
+    }
+}
+//# sourceMappingURL=gmail.js.map