@rnsk/toolkits 0.0.2 → 0.0.4

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

package/dist/toolkits/google-calendar/tools/index.d.ts

@@ -1,7 +1,185 @@
-export declare const googleCalendarTools: {
+import { listEvents } from './list-events.js';
+import { createEvent } from './create-event.js';
+import { getEvent } from './get-event.js';
+import { updateEvent } from './update-event.js';
+import { deleteEvent } from './delete-event.js';
+import { searchEvents } from './search-events.js';
+export { listEvents, createEvent, getEvent, updateEvent, deleteEvent, searchEvents };
+export declare const googleCalendarTools: ({
     name: string;
     description: string;
-    tool: any;
+    tool: import("ai").Tool<{
+        maxResults: number;
+        googleCalendarToken: string;
+        timeMin?: string | undefined;
+    }, {
+        error: string;
+        details: any;
+        events?: undefined;
+        summary?: undefined;
+        message?: undefined;
+    } | {
+        events: any;
+        summary: any;
+        error?: undefined;
+        details?: undefined;
+        message?: undefined;
+    } | {
+        error: string;
+        message: string;
+        details?: undefined;
+        events?: undefined;
+        summary?: undefined;
+    }>;
     requiredAuth: string;
-}[];
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        summary: string;
+        googleCalendarToken: string;
+        start: string;
+        end: string;
+        description?: string | undefined;
+        location?: string | undefined;
+    }, {
+        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;
+    }>;
+    requiredAuth: string;
+} | {
+    name: string;
+    description: string;
+    tool: 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;
+    }>;
+    requiredAuth: string;
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        googleCalendarToken: string;
+        eventId: string;
+        calendarId: string;
+        description?: string | undefined;
+        location?: string | undefined;
+        summary?: string | undefined;
+        start?: string | undefined;
+        end?: string | undefined;
+    }, {
+        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;
+    }>;
+    requiredAuth: string;
+} | {
+    name: string;
+    description: string;
+    tool: 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;
+    }>;
+    requiredAuth: string;
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        maxResults: number;
+        googleCalendarToken: string;
+        calendarId: string;
+        q?: string | undefined;
+        timeMin?: string | undefined;
+        timeMax?: string | undefined;
+    }, {
+        error: string;
+        details: any;
+        events?: undefined;
+        summary?: undefined;
+        message?: undefined;
+    } | {
+        events: any;
+        summary: any;
+        error?: undefined;
+        details?: undefined;
+        message?: undefined;
+    } | {
+        error: string;
+        message: string;
+        details?: undefined;
+        events?: undefined;
+        summary?: undefined;
+    }>;
+    requiredAuth: string;
+})[];
 //# sourceMappingURL=index.d.ts.map

package/dist/toolkits/google-calendar/tools/index.js

@@ -1,6 +1,11 @@
 // @ts-nocheck
-import { listEvents } from './list-events';
-import { createEvent } from './create-event';
+import { listEvents } from './list-events.js';
+import { createEvent } from './create-event.js';
+import { getEvent } from './get-event.js';
+import { updateEvent } from './update-event.js';
+import { deleteEvent } from './delete-event.js';
+import { searchEvents } from './search-events.js';
+export { listEvents, createEvent, getEvent, updateEvent, deleteEvent, searchEvents };
 export const googleCalendarTools = [
     {
         name: 'listEvents',
@@ -14,5 +19,29 @@ export const googleCalendarTools = [
         tool: createEvent,
         requiredAuth: 'googleCalendarToken',
     },
+    {
+        name: 'getEvent',
+        description: 'Get details of a specific event from Google Calendar by event ID.',
+        tool: getEvent,
+        requiredAuth: 'googleCalendarToken',
+    },
+    {
+        name: 'updateEvent',
+        description: 'Update or reschedule an existing event in Google Calendar (e.g., change summary, start/end time, description, or location).',
+        tool: updateEvent,
+        requiredAuth: 'googleCalendarToken',
+    },
+    {
+        name: 'deleteEvent',
+        description: 'Delete or cancel an event from Google Calendar by event ID.',
+        tool: deleteEvent,
+        requiredAuth: 'googleCalendarToken',
+    },
+    {
+        name: 'searchEvents',
+        description: 'Search for events in Google Calendar matching a free text query and/or date range.',
+        tool: searchEvents,
+        requiredAuth: 'googleCalendarToken',
+    },
 ];
 //# sourceMappingURL=index.js.map

package/dist/toolkits/google-calendar/tools/search-events.d.ts

@@ -0,0 +1,27 @@
+export declare const searchEvents: import("ai").Tool<{
+    maxResults: number;
+    googleCalendarToken: string;
+    calendarId: string;
+    q?: string | undefined;
+    timeMin?: string | undefined;
+    timeMax?: string | undefined;
+}, {
+    error: string;
+    details: any;
+    events?: undefined;
+    summary?: undefined;
+    message?: undefined;
+} | {
+    events: any;
+    summary: any;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    events?: undefined;
+    summary?: undefined;
+}>;
+//# sourceMappingURL=search-events.d.ts.map

package/dist/toolkits/google-calendar/tools/search-events.js

@@ -0,0 +1,49 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+export const searchEvents = tool({
+    description: 'Search for events in Google Calendar matching a free text query and/or date range.',
+    inputSchema: z.object({
+        googleCalendarToken: z.string().describe('The Google Calendar access token'),
+        q: z.string().optional().describe('Free text search terms to find events (e.g. "team sync", "meeting with Alice")'),
+        calendarId: z.string().optional().default('primary').describe('Calendar identifier. Default is "primary".'),
+        timeMin: z.string().optional().describe('Lower bound (exclusive) for event end times (RFC3339 timestamp)'),
+        timeMax: z.string().optional().describe('Upper bound (exclusive) for event start times (RFC3339 timestamp)'),
+        maxResults: z.number().optional().default(10).describe('Maximum number of events to return'),
+    }),
+    execute: async ({ googleCalendarToken, q, calendarId = 'primary', timeMin, timeMax, maxResults }) => {
+        try {
+            const url = new URL(`https://www.googleapis.com/calendar/v3/calendars/${encodeURIComponent(calendarId)}/events`);
+            url.searchParams.append('maxResults', maxResults.toString());
+            url.searchParams.append('singleEvents', 'true');
+            url.searchParams.append('orderBy', 'startTime');
+            if (q)
+                url.searchParams.append('q', q);
+            if (timeMin)
+                url.searchParams.append('timeMin', timeMin);
+            if (timeMax)
+                url.searchParams.append('timeMax', timeMax);
+            const response = await fetch(url.toString(), {
+                headers: {
+                    Authorization: `Bearer ${googleCalendarToken}`,
+                },
+            });
+            if (!response.ok) {
+                const error = await response.json();
+                return { error: 'Failed to search events', details: error };
+            }
+            const data = await response.json();
+            return {
+                events: data.items || [],
+                summary: data.summary,
+            };
+        }
+        catch (error) {
+            return {
+                error: 'Error searching events',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=search-events.js.map

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

@@ -0,0 +1,29 @@
+export declare const updateEvent: import("ai").Tool<{
+    googleCalendarToken: string;
+    eventId: string;
+    calendarId: string;
+    description?: string | undefined;
+    location?: string | undefined;
+    summary?: string | undefined;
+    start?: string | undefined;
+    end?: string | undefined;
+}, {
+    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=update-event.d.ts.map

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

@@ -0,0 +1,56 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+export const updateEvent = tool({
+    description: 'Update or reschedule an existing event in Google Calendar (e.g., change summary, start/end time, description, or location).',
+    inputSchema: z.object({
+        googleCalendarToken: z.string().describe('The Google Calendar access token'),
+        eventId: z.string().describe('The unique ID of the event to update'),
+        calendarId: z.string().optional().default('primary').describe('Calendar identifier. Default is "primary".'),
+        summary: z.string().optional().describe('New summary/title of the event'),
+        description: z.string().optional().describe('New description of the event'),
+        start: z.string().optional().describe('New start time (RFC3339 timestamp, e.g., 2026-09-10T10:00:00Z)'),
+        end: z.string().optional().describe('New end time (RFC3339 timestamp, e.g., 2026-09-10T11:00:00Z)'),
+        location: z.string().optional().describe('New location of the event'),
+    }),
+    execute: async ({ googleCalendarToken, eventId, calendarId = 'primary', summary, description, start, end, location }) => {
+        try {
+            const url = `https://www.googleapis.com/calendar/v3/calendars/${encodeURIComponent(calendarId)}/events/${encodeURIComponent(eventId)}`;
+            const updatePayload = {};
+            if (summary !== undefined)
+                updatePayload.summary = summary;
+            if (description !== undefined)
+                updatePayload.description = description;
+            if (location !== undefined)
+                updatePayload.location = location;
+            if (start !== undefined)
+                updatePayload.start = { dateTime: start };
+            if (end !== undefined)
+                updatePayload.end = { dateTime: end };
+            const response = await fetch(url, {
+                method: 'PATCH',
+                headers: {
+                    Authorization: `Bearer ${googleCalendarToken}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify(updatePayload),
+            });
+            if (!response.ok) {
+                const error = await response.json();
+                return { error: 'Failed to update event', details: error };
+            }
+            const data = await response.json();
+            return {
+                success: true,
+                event: data,
+            };
+        }
+        catch (error) {
+            return {
+                error: 'Error updating event',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=update-event.js.map

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

@@ -5,7 +5,7 @@ import { googleSheetsTools } from './tools/index.js';
 export default defineToolkit({
     id: 'google-sheets',
     displayName: 'Google Sheets',
-    shortDescription: 'Spreadsheets, ranges, and values.',
+    shortDescription: 'Read, write, append, and manage Google Sheets spreadsheets and cell values.',
     category: 'Document & File Management',
     icon: GSHEETS_ICON,
     auth: {
@@ -38,7 +38,7 @@ export default defineToolkit({
         description: entry.description,
         tool: entry.tool,
         requiredAuth: entry.requiredAuth,
-        scope: inferToolScope(entry.name),
+        scope: entry.scope ?? inferToolScope(entry.name),
     })),
     meta: { since: '0.0.2' },
 });