@rnsk/toolkits 0.0.2 → 0.0.4

package/dist/toolkits/gmail/tools/list-labels.js

@@ -0,0 +1,46 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+export const listLabels = tool({
+    description: 'List all labels in the Gmail mailbox (e.g., INBOX, UNREAD, STARRED, IMPORTANT, and user custom labels).',
+    inputSchema: z.object({
+        gmailToken: z.string().optional().describe('Injected by system; do not provide'),
+        type: z.enum(['all', 'system', 'user']).optional().default('all').describe('Filter labels by type: system, user, or all'),
+    }),
+    execute: async ({ gmailToken, type }) => {
+        try {
+            const response = await fetch('https://gmail.googleapis.com/gmail/v1/users/me/labels', {
+                headers: {
+                    Authorization: `Bearer ${gmailToken}`,
+                },
+            });
+            if (!response.ok) {
+                const error = await response.json();
+                return { error: 'Failed to list labels', details: error };
+            }
+            const data = await response.json();
+            let labels = data.labels || [];
+            if (type === 'system') {
+                labels = labels.filter((l) => l.type === 'system');
+            }
+            else if (type === 'user') {
+                labels = labels.filter((l) => l.type === 'user');
+            }
+            return {
+                labels: labels.map((l) => ({
+                    id: l.id,
+                    name: l.name,
+                    type: l.type,
+                    messageListVisibility: l.messageListVisibility,
+                    labelListVisibility: l.labelListVisibility,
+                })),
+            };
+        }
+        catch (error) {
+            return {
+                error: 'Error listing labels',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=list-labels.js.map

package/dist/toolkits/gmail/tools/list-threads.d.ts

@@ -0,0 +1,28 @@
+export declare const listThreads: import("ai").Tool<{
+    maxResults: number;
+    gmailToken?: string | undefined;
+    q?: string | undefined;
+    pageToken?: string | undefined;
+}, {
+    error: string;
+    details: any;
+    threads?: undefined;
+    resultSizeEstimate?: undefined;
+    nextPageToken?: undefined;
+    message?: undefined;
+} | {
+    threads: any;
+    resultSizeEstimate: any;
+    nextPageToken: any;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    threads?: undefined;
+    resultSizeEstimate?: undefined;
+    nextPageToken?: undefined;
+}>;
+//# sourceMappingURL=list-threads.d.ts.map

package/dist/toolkits/gmail/tools/list-threads.js

@@ -0,0 +1,43 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+export const listThreads = tool({
+    description: 'List or search email conversation threads in Gmail. Filter by search query (e.g., from:someone@example.com, is:unread).',
+    inputSchema: z.object({
+        gmailToken: z.string().optional().describe('Injected by system; do not provide'),
+        q: z.string().optional().describe('Search query (same format as Gmail search box)'),
+        maxResults: z.number().optional().default(10).describe('Maximum number of threads to return'),
+        pageToken: z.string().optional().describe('Token for retrieving the next page of threads'),
+    }),
+    execute: async ({ gmailToken, q, maxResults, pageToken }) => {
+        try {
+            const url = new URL('https://gmail.googleapis.com/gmail/v1/users/me/threads');
+            if (q)
+                url.searchParams.append('q', q);
+            url.searchParams.append('maxResults', maxResults.toString());
+            if (pageToken)
+                url.searchParams.append('pageToken', pageToken);
+            const response = await fetch(url.toString(), {
+                headers: {
+                    Authorization: `Bearer ${gmailToken}`,
+                },
+            });
+            if (!response.ok) {
+                const error = await response.json();
+                return { error: 'Failed to list threads', details: error };
+            }
+            const data = await response.json();
+            return {
+                threads: data.threads || [],
+                resultSizeEstimate: data.resultSizeEstimate,
+                nextPageToken: data.nextPageToken,
+            };
+        }
+        catch (error) {
+            return {
+                error: 'Error listing threads',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=list-threads.js.map

package/dist/toolkits/gmail/tools/modify-message-labels.d.ts

@@ -0,0 +1,31 @@
+export declare const modifyMessageLabels: import("ai").Tool<{
+    messageId: string;
+    gmailToken?: string | undefined;
+    addLabelIds?: string[] | undefined;
+    removeLabelIds?: string[] | undefined;
+}, {
+    error: string;
+    details: any;
+    success?: undefined;
+    messageId?: undefined;
+    threadId?: undefined;
+    labelIds?: undefined;
+    message?: undefined;
+} | {
+    success: boolean;
+    messageId: any;
+    threadId: any;
+    labelIds: any;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    success?: undefined;
+    messageId?: undefined;
+    threadId?: undefined;
+    labelIds?: undefined;
+}>;
+//# sourceMappingURL=modify-message-labels.d.ts.map

package/dist/toolkits/gmail/tools/modify-message-labels.js

@@ -0,0 +1,44 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+export const modifyMessageLabels = tool({
+    description: 'Add or remove labels from a Gmail message. Used to mark emails as read/unread, star/unstar, archive (remove INBOX), or assign folders/labels.',
+    inputSchema: z.object({
+        gmailToken: z.string().optional().describe('Injected by system; do not provide'),
+        messageId: z.string().describe('The ID of the message to modify'),
+        addLabelIds: z.array(z.string()).optional().describe('Array of label IDs to add (e.g., ["STARRED", "IMPORTANT"])'),
+        removeLabelIds: z.array(z.string()).optional().describe('Array of label IDs to remove (e.g., ["UNREAD"] to mark as read, or ["INBOX"] to archive)'),
+    }),
+    execute: async ({ gmailToken, messageId, addLabelIds = [], removeLabelIds = [] }) => {
+        try {
+            const response = await fetch(`https://gmail.googleapis.com/gmail/v1/users/me/messages/${messageId}/modify`, {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${gmailToken}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    addLabelIds,
+                    removeLabelIds,
+                }),
+            });
+            if (!response.ok) {
+                const error = await response.json();
+                return { error: 'Failed to modify message labels', details: error };
+            }
+            const data = await response.json();
+            return {
+                success: true,
+                messageId: data.id,
+                threadId: data.threadId,
+                labelIds: data.labelIds || [],
+            };
+        }
+        catch (error) {
+            return {
+                error: 'Error modifying message labels',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=modify-message-labels.js.map

package/dist/toolkits/gmail/tools/reply-to-thread.d.ts

@@ -0,0 +1,33 @@
+export declare const replyToThread: import("ai").Tool<{
+    body: string;
+    threadId: string;
+    subject: string;
+    to: string;
+    gmailToken?: string | undefined;
+    cc?: string | undefined;
+    bcc?: string | undefined;
+    inReplyTo?: string | undefined;
+    references?: string | undefined;
+}, {
+    error: string;
+    details: any;
+    success?: undefined;
+    messageId?: undefined;
+    threadId?: undefined;
+    message?: undefined;
+} | {
+    success: boolean;
+    messageId: any;
+    threadId: any;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    success?: undefined;
+    messageId?: undefined;
+    threadId?: undefined;
+}>;
+//# sourceMappingURL=reply-to-thread.d.ts.map

package/dist/toolkits/gmail/tools/reply-to-thread.js

@@ -0,0 +1,58 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+import { encodeRFC822Message } from './utils.js';
+export const replyToThread = tool({
+    description: 'Reply to an existing Gmail conversation thread, ensuring the message stays grouped in the same thread.',
+    inputSchema: z.object({
+        gmailToken: z.string().optional().describe('Injected by system; do not provide'),
+        threadId: z.string().describe('The ID of the thread to reply to'),
+        to: z.string().describe('Recipient email address'),
+        subject: z.string().describe('Email subject (typically prefixed with "Re: ")'),
+        body: z.string().describe('Reply body (plain text)'),
+        cc: z.string().optional().describe('Optional CC recipient email address(es), comma-separated'),
+        bcc: z.string().optional().describe('Optional BCC recipient email address(es), comma-separated'),
+        inReplyTo: z.string().optional().describe('Optional Message-ID header of the email being replied to'),
+        references: z.string().optional().describe('Optional References header string for email threading continuity'),
+    }),
+    execute: async ({ gmailToken, threadId, to, subject, body, cc, bcc, inReplyTo, references }) => {
+        try {
+            const encodedMessage = encodeRFC822Message({
+                to,
+                subject,
+                body,
+                cc,
+                bcc,
+                inReplyTo,
+                references: references || inReplyTo,
+            });
+            const response = await fetch('https://gmail.googleapis.com/gmail/v1/users/me/messages/send', {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${gmailToken}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    raw: encodedMessage,
+                    threadId,
+                }),
+            });
+            if (!response.ok) {
+                const error = await response.json();
+                return { error: 'Failed to reply to thread', details: error };
+            }
+            const data = await response.json();
+            return {
+                success: true,
+                messageId: data.id,
+                threadId: data.threadId,
+            };
+        }
+        catch (error) {
+            return {
+                error: 'Error replying to thread',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=reply-to-thread.js.map

package/dist/toolkits/gmail/tools/send-draft.d.ts

@@ -0,0 +1,29 @@
+export declare const sendDraft: import("ai").Tool<{
+    id: string;
+    gmailToken?: string | undefined;
+}, {
+    error: string;
+    details: any;
+    success?: undefined;
+    messageId?: undefined;
+    threadId?: undefined;
+    labelIds?: undefined;
+    message?: undefined;
+} | {
+    success: boolean;
+    messageId: any;
+    threadId: any;
+    labelIds: any;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    success?: undefined;
+    messageId?: undefined;
+    threadId?: undefined;
+    labelIds?: undefined;
+}>;
+//# sourceMappingURL=send-draft.d.ts.map

package/dist/toolkits/gmail/tools/send-draft.js

@@ -0,0 +1,41 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+export const sendDraft = tool({
+    description: 'Send an existing Gmail draft by its draft ID.',
+    inputSchema: z.object({
+        gmailToken: z.string().optional().describe('Injected by system; do not provide'),
+        id: z.string().describe('The ID of the draft to send'),
+    }),
+    execute: async ({ gmailToken, id }) => {
+        try {
+            const response = await fetch('https://gmail.googleapis.com/gmail/v1/users/me/drafts/send', {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${gmailToken}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    id,
+                }),
+            });
+            if (!response.ok) {
+                const error = await response.json();
+                return { error: 'Failed to send draft', details: error };
+            }
+            const data = await response.json();
+            return {
+                success: true,
+                messageId: data.id,
+                threadId: data.threadId,
+                labelIds: data.labelIds || [],
+            };
+        }
+        catch (error) {
+            return {
+                error: 'Error sending draft',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=send-draft.js.map

package/dist/toolkits/gmail/tools/send-message.d.ts

@@ -1,8 +1,11 @@
 export declare const sendMessage: import("ai").Tool<{
-    subject: string;
     body: string;
+    subject: string;
     to: string;
     gmailToken?: string | undefined;
+    threadId?: string | undefined;
+    cc?: string | undefined;
+    bcc?: string | undefined;
 }, {
     error: string;
     details: any;

package/dist/toolkits/gmail/tools/send-message.js

@@ -1,5 +1,6 @@
 import { tool } from 'ai';
 import { z } from 'zod';
+import { encodeRFC822Message } from './utils.js';
 export const sendMessage = tool({
     description: 'Send an email via Gmail.',
     inputSchema: z.object({
@@ -7,31 +8,32 @@ export const sendMessage = tool({
         to: z.string().describe('Recipient email address'),
         subject: z.string().describe('Email subject'),
         body: z.string().describe('Email body (plain text)'),
+        cc: z.string().optional().describe('Optional CC recipient email address(es), comma-separated'),
+        bcc: z.string().optional().describe('Optional BCC recipient email address(es), comma-separated'),
+        threadId: z.string().optional().describe('Optional thread ID to reply or append this message to an existing conversation thread'),
     }),
-    execute: async ({ gmailToken, to, subject, body }) => {
+    execute: async ({ gmailToken, to, subject, body, cc, bcc, threadId }) => {
         try {
-            const message = [
-                `To: ${to}`,
-                `Subject: ${subject}`,
-                'Content-Type: text/plain; charset="UTF-8"',
-                'MIME-Version: 1.0',
-                '',
+            const encodedMessage = encodeRFC822Message({
+                to,
+                subject,
                 body,
-            ].join('\n');
-            const encodedMessage = Buffer.from(message)
-                .toString('base64')
-                .replace(/\+/g, '-')
-                .replace(/\//g, '_')
-                .replace(/=+$/, '');
+                cc,
+                bcc,
+            });
+            const payload = {
+                raw: encodedMessage,
+            };
+            if (threadId) {
+                payload.threadId = threadId;
+            }
             const response = await fetch('https://gmail.googleapis.com/gmail/v1/users/me/messages/send', {
                 method: 'POST',
                 headers: {
                     Authorization: `Bearer ${gmailToken}`,
                     'Content-Type': 'application/json',
                 },
-                body: JSON.stringify({
-                    raw: encodedMessage,
-                }),
+                body: JSON.stringify(payload),
             });
             if (!response.ok) {
                 const error = await response.json();

package/dist/toolkits/gmail/tools/trash-message.d.ts

@@ -0,0 +1,29 @@
+export declare const trashMessage: import("ai").Tool<{
+    id: string;
+    gmailToken?: string | undefined;
+}, {
+    error: string;
+    details: any;
+    success?: undefined;
+    messageId?: undefined;
+    threadId?: undefined;
+    labelIds?: undefined;
+    message?: undefined;
+} | {
+    success: boolean;
+    messageId: any;
+    threadId: any;
+    labelIds: any;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    success?: undefined;
+    messageId?: undefined;
+    threadId?: undefined;
+    labelIds?: undefined;
+}>;
+//# sourceMappingURL=trash-message.d.ts.map

package/dist/toolkits/gmail/tools/trash-message.js

@@ -0,0 +1,37 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+export const trashMessage = tool({
+    description: 'Move a Gmail message to the Trash folder (safe recoverable deletion).',
+    inputSchema: z.object({
+        gmailToken: z.string().optional().describe('Injected by system; do not provide'),
+        id: z.string().describe('The ID of the message to move to Trash'),
+    }),
+    execute: async ({ gmailToken, id }) => {
+        try {
+            const response = await fetch(`https://gmail.googleapis.com/gmail/v1/users/me/messages/${id}/trash`, {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${gmailToken}`,
+                },
+            });
+            if (!response.ok) {
+                const error = await response.json();
+                return { error: 'Failed to trash message', details: error };
+            }
+            const data = await response.json();
+            return {
+                success: true,
+                messageId: data.id,
+                threadId: data.threadId,
+                labelIds: data.labelIds || [],
+            };
+        }
+        catch (error) {
+            return {
+                error: 'Error moving message to trash',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=trash-message.js.map

package/dist/toolkits/gmail/tools/untrash-message.d.ts

@@ -0,0 +1,29 @@
+export declare const untrashMessage: import("ai").Tool<{
+    id: string;
+    gmailToken?: string | undefined;
+}, {
+    error: string;
+    details: any;
+    success?: undefined;
+    messageId?: undefined;
+    threadId?: undefined;
+    labelIds?: undefined;
+    message?: undefined;
+} | {
+    success: boolean;
+    messageId: any;
+    threadId: any;
+    labelIds: any;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    success?: undefined;
+    messageId?: undefined;
+    threadId?: undefined;
+    labelIds?: undefined;
+}>;
+//# sourceMappingURL=untrash-message.d.ts.map

package/dist/toolkits/gmail/tools/untrash-message.js

@@ -0,0 +1,37 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+export const untrashMessage = tool({
+    description: 'Restore a Gmail message from the Trash folder back to the mailbox.',
+    inputSchema: z.object({
+        gmailToken: z.string().optional().describe('Injected by system; do not provide'),
+        id: z.string().describe('The ID of the message to restore from Trash'),
+    }),
+    execute: async ({ gmailToken, id }) => {
+        try {
+            const response = await fetch(`https://gmail.googleapis.com/gmail/v1/users/me/messages/${id}/untrash`, {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${gmailToken}`,
+                },
+            });
+            if (!response.ok) {
+                const error = await response.json();
+                return { error: 'Failed to untrash message', details: error };
+            }
+            const data = await response.json();
+            return {
+                success: true,
+                messageId: data.id,
+                threadId: data.threadId,
+                labelIds: data.labelIds || [],
+            };
+        }
+        catch (error) {
+            return {
+                error: 'Error restoring message from trash',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=untrash-message.js.map

package/dist/toolkits/gmail/tools/utils.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Base64URL encodes a string in accordance with RFC 4648 §5.
+ */
+export declare function encodeBase64Url(str: string): string;
+/**
+ * Base64URL decodes a string back to UTF-8.
+ */
+export declare function decodeBase64Url(data: string): string;
+/**
+ * Encodes an email with standard RFC 2822 headers into Base64URL format.
+ */
+export declare function encodeRFC822Message(params: {
+    to: string;
+    subject: string;
+    body: string;
+    cc?: string;
+    bcc?: string;
+    inReplyTo?: string;
+    references?: string;
+}): string;
+/**
+ * Recursively extracts plain text (or HTML fallback) body from a Gmail message payload.
+ */
+export declare function extractBodyFromPayload(payload: any): string;
+/**
+ * Extracts structured message details and headers from a Gmail message API response.
+ */
+export declare function extractMessageDetails(data: any, maxBodyLength?: number): {
+    id: any;
+    threadId: any;
+    labelIds: any;
+    snippet: any;
+    subject: any;
+    from: any;
+    to: any;
+    cc: any;
+    date: any;
+    messageIdHeader: any;
+    body: string;
+} | null;
+//# sourceMappingURL=utils.d.ts.map