@rnsk/toolkits 0.0.6 → 0.0.7

package/dist/toolkits/gmail/tools/batch-delete-messages.js

@@ -0,0 +1,33 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+export const batchDeleteMessages = tool({
+    description: 'Permanently delete multiple Gmail messages in one request. This bypasses Trash and cannot be undone.',
+    inputSchema: z.object({
+        gmailToken: z.string().optional().describe('Injected by system; do not provide'),
+        messageIds: z.array(z.string()).min(1).max(1000).describe('Message IDs to permanently delete'),
+    }),
+    execute: async ({ gmailToken, messageIds }) => {
+        try {
+            const response = await fetch('https://gmail.googleapis.com/gmail/v1/users/me/messages/batchDelete', {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${gmailToken}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({ ids: messageIds }),
+            });
+            if (!response.ok) {
+                const error = await response.json();
+                return { error: 'Failed to batch delete messages', details: error };
+            }
+            return { success: true, deletedCount: messageIds.length, messageIds };
+        }
+        catch (error) {
+            return {
+                error: 'Error batch deleting messages',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=batch-delete-messages.js.map

package/dist/toolkits/gmail/tools/batch-modify-messages.d.ts

@@ -0,0 +1,34 @@
+export declare const batchModifyMessages: import("ai").Tool<{
+    messageIds: string[];
+    gmailToken?: string | undefined;
+    addLabelIds?: string[] | undefined;
+    removeLabelIds?: string[] | undefined;
+}, {
+    error: string;
+    details: any;
+    success?: undefined;
+    modifiedCount?: undefined;
+    messageIds?: undefined;
+    addLabelIds?: undefined;
+    removeLabelIds?: undefined;
+    message?: undefined;
+} | {
+    success: boolean;
+    modifiedCount: number;
+    messageIds: string[];
+    addLabelIds: string[];
+    removeLabelIds: string[];
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    success?: undefined;
+    modifiedCount?: undefined;
+    messageIds?: undefined;
+    addLabelIds?: undefined;
+    removeLabelIds?: undefined;
+}>;
+//# sourceMappingURL=batch-modify-messages.d.ts.map

package/dist/toolkits/gmail/tools/batch-modify-messages.js

@@ -0,0 +1,39 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+export const batchModifyMessages = tool({
+    description: 'Add or remove labels on multiple Gmail messages in one request.',
+    inputSchema: z.object({
+        gmailToken: z.string().optional().describe('Injected by system; do not provide'),
+        messageIds: z.array(z.string()).min(1).max(1000).describe('Message IDs to modify'),
+        addLabelIds: z.array(z.string()).optional().describe('Label IDs to add'),
+        removeLabelIds: z.array(z.string()).optional().describe('Label IDs to remove'),
+    }),
+    execute: async ({ gmailToken, messageIds, addLabelIds = [], removeLabelIds = [] }) => {
+        try {
+            const response = await fetch('https://gmail.googleapis.com/gmail/v1/users/me/messages/batchModify', {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${gmailToken}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    ids: messageIds,
+                    addLabelIds,
+                    removeLabelIds,
+                }),
+            });
+            if (!response.ok) {
+                const error = await response.json();
+                return { error: 'Failed to batch modify messages', details: error };
+            }
+            return { success: true, modifiedCount: messageIds.length, messageIds, addLabelIds, removeLabelIds };
+        }
+        catch (error) {
+            return {
+                error: 'Error batch modifying messages',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=batch-modify-messages.js.map

package/dist/toolkits/gmail/tools/create-filter.d.ts

@@ -0,0 +1,24 @@
+export declare const createFilter: import("ai").Tool<{
+    criteria: Record<string, any>;
+    action: Record<string, any>;
+    gmailToken?: string | undefined;
+}, {
+    error: string;
+    details: any;
+    success?: undefined;
+    filter?: undefined;
+    message?: undefined;
+} | {
+    success: boolean;
+    filter: any;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    success?: undefined;
+    filter?: undefined;
+}>;
+//# sourceMappingURL=create-filter.d.ts.map

package/dist/toolkits/gmail/tools/create-filter.js

@@ -0,0 +1,35 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+export const createFilter = tool({
+    description: 'Create a Gmail filter with criteria and actions such as applying labels, forwarding, archiving, or marking read.',
+    inputSchema: z.object({
+        gmailToken: z.string().optional().describe('Injected by system; do not provide'),
+        criteria: z.record(z.any()).describe('Gmail filter criteria object, e.g. { from, to, subject, query, negatedQuery }'),
+        action: z.record(z.any()).describe('Gmail filter action object, e.g. { addLabelIds, removeLabelIds, forward }'),
+    }),
+    execute: async ({ gmailToken, criteria, action }) => {
+        try {
+            const response = await fetch('https://gmail.googleapis.com/gmail/v1/users/me/settings/filters', {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${gmailToken}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({ criteria, action }),
+            });
+            if (!response.ok) {
+                const error = await response.json();
+                return { error: 'Failed to create filter', details: error };
+            }
+            const data = await response.json();
+            return { success: true, filter: data };
+        }
+        catch (error) {
+            return {
+                error: 'Error creating filter',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=create-filter.js.map

package/dist/toolkits/gmail/tools/create-label.d.ts

@@ -0,0 +1,27 @@
+export declare const createLabel: import("ai").Tool<{
+    labelName: string;
+    gmailToken?: string | undefined;
+    labelListVisibility?: "labelShow" | "labelShowIfUnread" | "labelHide" | undefined;
+    messageListVisibility?: "show" | "hide" | undefined;
+    textColor?: string | undefined;
+    backgroundColor?: string | undefined;
+}, {
+    error: string;
+    details: any;
+    success?: undefined;
+    label?: undefined;
+    message?: undefined;
+} | {
+    success: boolean;
+    label: any;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    success?: undefined;
+    label?: undefined;
+}>;
+//# sourceMappingURL=create-label.d.ts.map

package/dist/toolkits/gmail/tools/create-label.js

@@ -0,0 +1,46 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+const visibilitySchema = z.enum(['labelShow', 'labelShowIfUnread', 'labelHide']).optional();
+const messageVisibilitySchema = z.enum(['show', 'hide']).optional();
+export const createLabel = tool({
+    description: 'Create a new user label in Gmail.',
+    inputSchema: z.object({
+        gmailToken: z.string().optional().describe('Injected by system; do not provide'),
+        labelName: z.string().min(1).describe('Display name for the new label'),
+        labelListVisibility: visibilitySchema.describe('How the label appears in the label list'),
+        messageListVisibility: messageVisibilitySchema.describe('How messages with this label appear in message lists'),
+        textColor: z.string().optional().describe('Optional label text color hex code'),
+        backgroundColor: z.string().optional().describe('Optional label background color hex code'),
+    }),
+    execute: async ({ gmailToken, labelName, labelListVisibility, messageListVisibility, textColor, backgroundColor }) => {
+        try {
+            const color = textColor || backgroundColor ? { textColor, backgroundColor } : undefined;
+            const response = await fetch('https://gmail.googleapis.com/gmail/v1/users/me/labels', {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${gmailToken}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    name: labelName,
+                    labelListVisibility,
+                    messageListVisibility,
+                    color,
+                }),
+            });
+            if (!response.ok) {
+                const error = await response.json();
+                return { error: 'Failed to create label', details: error };
+            }
+            const data = await response.json();
+            return { success: true, label: data };
+        }
+        catch (error) {
+            return {
+                error: 'Error creating label',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=create-label.js.map

package/dist/toolkits/gmail/tools/delete-filter.d.ts

@@ -0,0 +1,23 @@
+export declare const deleteFilter: import("ai").Tool<{
+    filterId: string;
+    gmailToken?: string | undefined;
+}, {
+    error: string;
+    details: any;
+    success?: undefined;
+    filterId?: undefined;
+    message?: undefined;
+} | {
+    success: boolean;
+    filterId: string;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    success?: undefined;
+    filterId?: undefined;
+}>;
+//# sourceMappingURL=delete-filter.d.ts.map

package/dist/toolkits/gmail/tools/delete-filter.js

@@ -0,0 +1,31 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+export const deleteFilter = tool({
+    description: 'Permanently delete a Gmail filter by ID.',
+    inputSchema: z.object({
+        gmailToken: z.string().optional().describe('Injected by system; do not provide'),
+        filterId: z.string().describe('The filter ID to delete'),
+    }),
+    execute: async ({ gmailToken, filterId }) => {
+        try {
+            const response = await fetch(`https://gmail.googleapis.com/gmail/v1/users/me/settings/filters/${filterId}`, {
+                method: 'DELETE',
+                headers: {
+                    Authorization: `Bearer ${gmailToken}`,
+                },
+            });
+            if (!response.ok) {
+                const error = await response.json();
+                return { error: 'Failed to delete filter', details: error };
+            }
+            return { success: true, filterId };
+        }
+        catch (error) {
+            return {
+                error: 'Error deleting filter',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=delete-filter.js.map

package/dist/toolkits/gmail/tools/delete-label.d.ts

@@ -0,0 +1,23 @@
+export declare const deleteLabel: import("ai").Tool<{
+    labelId: string;
+    gmailToken?: string | undefined;
+}, {
+    error: string;
+    details: any;
+    success?: undefined;
+    labelId?: undefined;
+    message?: undefined;
+} | {
+    success: boolean;
+    labelId: string;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    success?: undefined;
+    labelId?: undefined;
+}>;
+//# sourceMappingURL=delete-label.d.ts.map

package/dist/toolkits/gmail/tools/delete-label.js

@@ -0,0 +1,31 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+export const deleteLabel = tool({
+    description: 'Permanently delete a user-created Gmail label from the account.',
+    inputSchema: z.object({
+        gmailToken: z.string().optional().describe('Injected by system; do not provide'),
+        labelId: z.string().describe('The label ID to delete, e.g. Label_123'),
+    }),
+    execute: async ({ gmailToken, labelId }) => {
+        try {
+            const response = await fetch(`https://gmail.googleapis.com/gmail/v1/users/me/labels/${labelId}`, {
+                method: 'DELETE',
+                headers: {
+                    Authorization: `Bearer ${gmailToken}`,
+                },
+            });
+            if (!response.ok) {
+                const error = await response.json();
+                return { error: 'Failed to delete label', details: error };
+            }
+            return { success: true, labelId };
+        }
+        catch (error) {
+            return {
+                error: 'Error deleting label',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=delete-label.js.map

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

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

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

@@ -0,0 +1,31 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+export const deleteMessage = tool({
+    description: 'Permanently delete a Gmail message by ID. This bypasses Trash and cannot be undone.',
+    inputSchema: z.object({
+        gmailToken: z.string().optional().describe('Injected by system; do not provide'),
+        id: z.string().describe('The message ID to permanently delete'),
+    }),
+    execute: async ({ gmailToken, id }) => {
+        try {
+            const response = await fetch(`https://gmail.googleapis.com/gmail/v1/users/me/messages/${id}`, {
+                method: 'DELETE',
+                headers: {
+                    Authorization: `Bearer ${gmailToken}`,
+                },
+            });
+            if (!response.ok) {
+                const error = await response.json();
+                return { error: 'Failed to delete message', details: error };
+            }
+            return { success: true, messageId: id };
+        }
+        catch (error) {
+            return {
+                error: 'Error deleting message',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=delete-message.js.map

package/dist/toolkits/gmail/tools/delete-thread.d.ts

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

package/dist/toolkits/gmail/tools/delete-thread.js

@@ -0,0 +1,31 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+export const deleteThread = tool({
+    description: 'Permanently delete a Gmail thread and all of its messages. This cannot be undone.',
+    inputSchema: z.object({
+        gmailToken: z.string().optional().describe('Injected by system; do not provide'),
+        id: z.string().describe('The thread ID to permanently delete'),
+    }),
+    execute: async ({ gmailToken, id }) => {
+        try {
+            const response = await fetch(`https://gmail.googleapis.com/gmail/v1/users/me/threads/${id}`, {
+                method: 'DELETE',
+                headers: {
+                    Authorization: `Bearer ${gmailToken}`,
+                },
+            });
+            if (!response.ok) {
+                const error = await response.json();
+                return { error: 'Failed to delete thread', details: error };
+            }
+            return { success: true, threadId: id };
+        }
+        catch (error) {
+            return {
+                error: 'Error deleting thread',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=delete-thread.js.map

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

@@ -0,0 +1,37 @@
+export declare const forwardMessage: import("ai").Tool<{
+    messageId: string;
+    recipients: string;
+    includeAttachments: boolean;
+    gmailToken?: string | undefined;
+    cc?: string | undefined;
+    bcc?: string | undefined;
+    additionalText?: string | undefined;
+}, {
+    error: string;
+    details: any;
+    success?: undefined;
+    messageId?: undefined;
+    threadId?: undefined;
+    forwardedMessageId?: undefined;
+    attachmentCount?: undefined;
+    message?: undefined;
+} | {
+    success: boolean;
+    messageId: any;
+    threadId: any;
+    forwardedMessageId: string;
+    attachmentCount: number;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    success?: undefined;
+    messageId?: undefined;
+    threadId?: undefined;
+    forwardedMessageId?: undefined;
+    attachmentCount?: undefined;
+}>;
+//# sourceMappingURL=forward-message.d.ts.map

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

@@ -0,0 +1,112 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+import { collectAttachments, encodeMultipartMessage, encodeRFC822Message, extractBodyFromPayload, getHeaderValue, } from './utils.js';
+export const forwardMessage = tool({
+    description: 'Forward an existing Gmail message to one or more recipients, optionally preserving attachments.',
+    inputSchema: z.object({
+        gmailToken: z.string().optional().describe('Injected by system; do not provide'),
+        messageId: z.string().describe('The message ID to forward'),
+        recipients: z.string().describe('Recipient email address(es), comma-separated'),
+        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'),
+        additionalText: z.string().optional().describe('Optional text to add above the forwarded message'),
+        includeAttachments: z.boolean().optional().default(true).describe('Whether to copy original attachments into the forwarded message'),
+    }),
+    execute: async ({ gmailToken, messageId, recipients, cc, bcc, additionalText, includeAttachments }) => {
+        try {
+            const messageResponse = await fetch(`https://gmail.googleapis.com/gmail/v1/users/me/messages/${messageId}?format=full`, {
+                headers: {
+                    Authorization: `Bearer ${gmailToken}`,
+                },
+            });
+            if (!messageResponse.ok) {
+                const error = await messageResponse.json();
+                return { error: 'Failed to fetch message to forward', details: error };
+            }
+            const originalMessage = await messageResponse.json();
+            const headers = originalMessage.payload?.headers || [];
+            const originalSubject = getHeaderValue(headers, 'subject') || '(no subject)';
+            const originalFrom = getHeaderValue(headers, 'from') || '';
+            const originalTo = getHeaderValue(headers, 'to') || '';
+            const originalDate = getHeaderValue(headers, 'date') || '';
+            const originalBody = extractBodyFromPayload(originalMessage.payload);
+            const subject = originalSubject.toLowerCase().startsWith('fwd:')
+                ? originalSubject
+                : `Fwd: ${originalSubject}`;
+            const body = [
+                additionalText || '',
+                additionalText ? '' : null,
+                '---------- Forwarded message ---------',
+                originalFrom ? `From: ${originalFrom}` : null,
+                originalDate ? `Date: ${originalDate}` : null,
+                originalSubject ? `Subject: ${originalSubject}` : null,
+                originalTo ? `To: ${originalTo}` : null,
+                '',
+                originalBody,
+            ].filter((line) => line !== null).join('\n');
+            const attachments = [];
+            if (includeAttachments) {
+                for (const attachment of collectAttachments(originalMessage.payload)) {
+                    const attachmentResponse = await fetch(`https://gmail.googleapis.com/gmail/v1/users/me/messages/${messageId}/attachments/${attachment.attachmentId}`, {
+                        headers: {
+                            Authorization: `Bearer ${gmailToken}`,
+                        },
+                    });
+                    if (!attachmentResponse.ok) {
+                        const error = await attachmentResponse.json();
+                        return { error: `Failed to fetch attachment ${attachment.filename}`, details: error };
+                    }
+                    const attachmentData = await attachmentResponse.json();
+                    attachments.push({
+                        filename: attachment.filename,
+                        mimeType: attachment.mimeType,
+                        data: attachmentData.data,
+                    });
+                }
+            }
+            const raw = attachments.length > 0
+                ? encodeMultipartMessage({
+                    to: recipients,
+                    subject,
+                    body,
+                    cc,
+                    bcc,
+                    attachments,
+                })
+                : encodeRFC822Message({
+                    to: recipients,
+                    subject,
+                    body,
+                    cc,
+                    bcc,
+                });
+            const sendResponse = 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 }),
+            });
+            if (!sendResponse.ok) {
+                const error = await sendResponse.json();
+                return { error: 'Failed to forward message', details: error };
+            }
+            const data = await sendResponse.json();
+            return {
+                success: true,
+                messageId: data.id,
+                threadId: data.threadId,
+                forwardedMessageId: messageId,
+                attachmentCount: attachments.length,
+            };
+        }
+        catch (error) {
+            return {
+                error: 'Error forwarding message',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=forward-message.js.map

package/dist/toolkits/gmail/tools/get-attachment.d.ts

@@ -0,0 +1,40 @@
+export declare const getAttachment: import("ai").Tool<{
+    messageId: string;
+    attachmentId: string;
+    gmailToken?: string | undefined;
+    fileName?: string | undefined;
+}, {
+    error: string;
+    details: any;
+    success?: undefined;
+    messageId?: undefined;
+    attachmentId?: undefined;
+    fileName?: undefined;
+    size?: undefined;
+    data?: undefined;
+    encoding?: undefined;
+    message?: undefined;
+} | {
+    success: boolean;
+    messageId: string;
+    attachmentId: string;
+    fileName: string | undefined;
+    size: any;
+    data: any;
+    encoding: string;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    success?: undefined;
+    messageId?: undefined;
+    attachmentId?: undefined;
+    fileName?: undefined;
+    size?: undefined;
+    data?: undefined;
+    encoding?: undefined;
+}>;
+//# sourceMappingURL=get-attachment.d.ts.map