@rnsk/toolkits 0.0.2 → 0.0.3

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;
     to: string;
+    body: 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

package/dist/toolkits/gmail/tools/utils.js

@@ -0,0 +1,97 @@
+// @ts-nocheck
+/**
+ * Base64URL encodes a string in accordance with RFC 4648 §5.
+ */
+export function encodeBase64Url(str) {
+    return Buffer.from(str, 'utf-8')
+        .toString('base64')
+        .replace(/\+/g, '-')
+        .replace(/\//g, '_')
+        .replace(/=+$/, '');
+}
+/**
+ * Base64URL decodes a string back to UTF-8.
+ */
+export function decodeBase64Url(data) {
+    const base64 = data.replace(/-/g, '+').replace(/_/g, '/');
+    return Buffer.from(base64, 'base64').toString('utf-8');
+}
+/**
+ * Encodes an email with standard RFC 2822 headers into Base64URL format.
+ */
+export function encodeRFC822Message(params) {
+    const headerLines = [
+        `To: ${params.to}`,
+        params.cc ? `Cc: ${params.cc}` : null,
+        params.bcc ? `Bcc: ${params.bcc}` : null,
+        `Subject: ${params.subject}`,
+        params.inReplyTo ? `In-Reply-To: ${params.inReplyTo}` : null,
+        params.references ? `References: ${params.references}` : null,
+        'Content-Type: text/plain; charset="UTF-8"',
+        'MIME-Version: 1.0',
+    ].filter(Boolean);
+    const raw = `${headerLines.join('\n')}\n\n${params.body}`;
+    return encodeBase64Url(raw);
+}
+/**
+ * Recursively extracts plain text (or HTML fallback) body from a Gmail message payload.
+ */
+export function extractBodyFromPayload(payload) {
+    if (!payload)
+        return '';
+    if (payload.body?.data) {
+        return decodeBase64Url(payload.body.data);
+    }
+    if (payload.parts && Array.isArray(payload.parts)) {
+        // Look for text/plain first
+        const plainPart = payload.parts.find((p) => p.mimeType === 'text/plain');
+        if (plainPart?.body?.data) {
+            return decodeBase64Url(plainPart.body.data);
+        }
+        // Check nested parts (multipart/alternative, multipart/mixed, etc.)
+        for (const part of payload.parts) {
+            if (part.parts) {
+                const nested = extractBodyFromPayload(part);
+                if (nested)
+                    return nested;
+            }
+        }
+        // Fallback to text/html if plain text not available
+        const htmlPart = payload.parts.find((p) => p.mimeType === 'text/html');
+        if (htmlPart?.body?.data) {
+            return decodeBase64Url(htmlPart.body.data);
+        }
+    }
+    return '';
+}
+/**
+ * Extracts structured message details and headers from a Gmail message API response.
+ */
+export function extractMessageDetails(data, maxBodyLength = 4000) {
+    if (!data)
+        return null;
+    const headers = data.payload?.headers || [];
+    const getHeader = (name) => headers.find((h) => h.name.toLowerCase() === name.toLowerCase())?.value;
+    const subject = getHeader('subject');
+    const from = getHeader('from');
+    const to = getHeader('to');
+    const cc = getHeader('cc');
+    const date = getHeader('date');
+    const messageIdHeader = getHeader('message-id');
+    const rawBody = extractBodyFromPayload(data.payload);
+    const body = rawBody ? rawBody.substring(0, maxBodyLength) : '';
+    return {
+        id: data.id,
+        threadId: data.threadId,
+        labelIds: data.labelIds || [],
+        snippet: data.snippet,
+        subject,
+        from,
+        to,
+        cc,
+        date,
+        messageIdHeader,
+        body,
+    };
+}
+//# sourceMappingURL=utils.js.map

package/dist/toolkits/google-calendar/manifest.js

@@ -5,7 +5,7 @@ import { googleCalendarTools } from './tools/index.js';
 export default defineToolkit({
     id: 'google-calendar',
     displayName: 'Google Calendar',
-    shortDescription: 'List and create calendar events.',
+    shortDescription: 'List, search, create, update, and delete calendar events.',
     category: 'Scheduling & Booking',
     icon: GCAL_ICON,
     auth: {

package/dist/toolkits/google-calendar/tools/delete-event.d.ts

@@ -0,0 +1,27 @@
+export declare const deleteEvent: import("ai").Tool<{
+    googleCalendarToken: string;
+    eventId: string;
+    calendarId: string;
+}, {
+    error: string;
+    details: any;
+    success?: undefined;
+    eventId?: undefined;
+    calendarId?: undefined;
+    message?: undefined;
+} | {
+    success: boolean;
+    eventId: string;
+    calendarId: string;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    success?: undefined;
+    eventId?: undefined;
+    calendarId?: undefined;
+}>;
+//# sourceMappingURL=delete-event.d.ts.map

package/dist/toolkits/google-calendar/tools/delete-event.js

@@ -0,0 +1,38 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+export const deleteEvent = tool({
+    description: 'Delete or cancel an event from Google Calendar by event ID.',
+    inputSchema: z.object({
+        googleCalendarToken: z.string().describe('The Google Calendar access token'),
+        eventId: z.string().describe('The unique ID of the event to delete'),
+        calendarId: z.string().optional().default('primary').describe('Calendar identifier. Default is "primary".'),
+    }),
+    execute: async ({ googleCalendarToken, eventId, calendarId = 'primary' }) => {
+        try {
+            const url = `https://www.googleapis.com/calendar/v3/calendars/${encodeURIComponent(calendarId)}/events/${encodeURIComponent(eventId)}`;
+            const response = await fetch(url, {
+                method: 'DELETE',
+                headers: {
+                    Authorization: `Bearer ${googleCalendarToken}`,
+                },
+            });
+            if (!response.ok && response.status !== 204) {
+                const error = await response.json().catch(() => ({ status: response.status }));
+                return { error: 'Failed to delete event', details: error };
+            }
+            return {
+                success: true,
+                eventId,
+                calendarId,
+            };
+        }
+        catch (error) {
+            return {
+                error: 'Error deleting event',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=delete-event.js.map

package/dist/toolkits/google-calendar/tools/get-event.d.ts

@@ -0,0 +1,24 @@
+export declare const getEvent: import("ai").Tool<{
+    googleCalendarToken: string;
+    eventId: string;
+    calendarId: string;
+}, {
+    error: string;
+    details: any;
+    success?: undefined;
+    event?: undefined;
+    message?: undefined;
+} | {
+    success: boolean;
+    event: any;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    success?: undefined;
+    event?: undefined;
+}>;
+//# sourceMappingURL=get-event.d.ts.map

package/dist/toolkits/google-calendar/tools/get-event.js

@@ -0,0 +1,37 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+export const getEvent = tool({
+    description: 'Get details of a specific event from Google Calendar by event ID.',
+    inputSchema: z.object({
+        googleCalendarToken: z.string().describe('The Google Calendar access token'),
+        eventId: z.string().describe('The unique ID of the event to retrieve'),
+        calendarId: z.string().optional().default('primary').describe('Calendar identifier. Default is "primary".'),
+    }),
+    execute: async ({ googleCalendarToken, eventId, calendarId = 'primary' }) => {
+        try {
+            const url = `https://www.googleapis.com/calendar/v3/calendars/${encodeURIComponent(calendarId)}/events/${encodeURIComponent(eventId)}`;
+            const response = await fetch(url, {
+                headers: {
+                    Authorization: `Bearer ${googleCalendarToken}`,
+                },
+            });
+            if (!response.ok) {
+                const error = await response.json();
+                return { error: 'Failed to get event', details: error };
+            }
+            const data = await response.json();
+            return {
+                success: true,
+                event: data,
+            };
+        }
+        catch (error) {
+            return {
+                error: 'Error getting event',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=get-event.js.map