@rnsk/toolkits 0.0.2 → 0.0.3

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' },
 });

package/dist/toolkits/google-sheets/tools/append-values.d.ts

@@ -0,0 +1,41 @@
+export declare const appendValues: import("ai").Tool<{
+    values: (string | number | boolean | null)[][];
+    range: string;
+    googleSheetsToken: string;
+    spreadsheetId: string;
+    valueInputOption: "RAW" | "USER_ENTERED";
+}, {
+    error: string;
+    details: any;
+    success?: undefined;
+    spreadsheetId?: undefined;
+    tableRange?: undefined;
+    updatedRange?: undefined;
+    updatedRows?: undefined;
+    updatedColumns?: undefined;
+    updatedCells?: undefined;
+    message?: undefined;
+} | {
+    success: boolean;
+    spreadsheetId: any;
+    tableRange: any;
+    updatedRange: any;
+    updatedRows: any;
+    updatedColumns: any;
+    updatedCells: any;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    success?: undefined;
+    spreadsheetId?: undefined;
+    tableRange?: undefined;
+    updatedRange?: undefined;
+    updatedRows?: undefined;
+    updatedColumns?: undefined;
+    updatedCells?: undefined;
+}>;
+//# sourceMappingURL=append-values.d.ts.map

package/dist/toolkits/google-sheets/tools/append-values.js

@@ -0,0 +1,51 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+export const appendValues = tool({
+    description: 'Append rows of values to a Google Sheets spreadsheet range (e.g., adding new rows at the bottom of a table).',
+    inputSchema: z.object({
+        googleSheetsToken: z.string().describe('The Google Sheets access token'),
+        spreadsheetId: z.string().describe('The ID of the spreadsheet'),
+        range: z.string().describe('The A1 notation of a range where values should be appended (e.g., "Sheet1!A:E")'),
+        values: z.array(z.array(z.union([z.string(), z.number(), z.boolean(), z.null()]))).describe('A 2D array of row data to append (e.g., [["Alice", 30, true], ["Bob", 25, false]])'),
+        valueInputOption: z.enum(['RAW', 'USER_ENTERED']).optional().default('USER_ENTERED').describe('How the input data should be interpreted. USER_ENTERED parses values like user typing into UI.'),
+    }),
+    execute: async ({ googleSheetsToken, spreadsheetId, range, values, valueInputOption = 'USER_ENTERED' }) => {
+        try {
+            const url = `https://sheets.googleapis.com/v4/spreadsheets/${spreadsheetId}/values/${encodeURIComponent(range)}:append?valueInputOption=${valueInputOption}`;
+            const response = await fetch(url, {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${googleSheetsToken}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    range,
+                    majorDimension: 'ROWS',
+                    values,
+                }),
+            });
+            if (!response.ok) {
+                const error = await response.json();
+                return { error: 'Failed to append values', details: error };
+            }
+            const data = await response.json();
+            return {
+                success: true,
+                spreadsheetId: data.spreadsheetId,
+                tableRange: data.tableRange,
+                updatedRange: data.updates?.updatedRange,
+                updatedRows: data.updates?.updatedRows,
+                updatedColumns: data.updates?.updatedColumns,
+                updatedCells: data.updates?.updatedCells,
+            };
+        }
+        catch (error) {
+            return {
+                error: 'Error appending values',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=append-values.js.map

package/dist/toolkits/google-sheets/tools/clear-values.d.ts

@@ -0,0 +1,27 @@
+export declare const clearValues: import("ai").Tool<{
+    range: string;
+    googleSheetsToken: string;
+    spreadsheetId: string;
+}, {
+    error: string;
+    details: any;
+    success?: undefined;
+    spreadsheetId?: undefined;
+    clearedRange?: undefined;
+    message?: undefined;
+} | {
+    success: boolean;
+    spreadsheetId: any;
+    clearedRange: any;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    success?: undefined;
+    spreadsheetId?: undefined;
+    clearedRange?: undefined;
+}>;
+//# sourceMappingURL=clear-values.d.ts.map

package/dist/toolkits/google-sheets/tools/clear-values.js

@@ -0,0 +1,41 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+export const clearValues = tool({
+    description: 'Clear values from a specific range in a Google Sheets spreadsheet, leaving cell formatting intact.',
+    inputSchema: z.object({
+        googleSheetsToken: z.string().describe('The Google Sheets access token'),
+        spreadsheetId: z.string().describe('The ID of the spreadsheet'),
+        range: z.string().describe('The A1 notation of the values to clear (e.g., "Sheet1!A1:B10")'),
+    }),
+    execute: async ({ googleSheetsToken, spreadsheetId, range }) => {
+        try {
+            const url = `https://sheets.googleapis.com/v4/spreadsheets/${spreadsheetId}/values/${encodeURIComponent(range)}:clear`;
+            const response = await fetch(url, {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${googleSheetsToken}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({}),
+            });
+            if (!response.ok) {
+                const error = await response.json();
+                return { error: 'Failed to clear values', details: error };
+            }
+            const data = await response.json();
+            return {
+                success: true,
+                spreadsheetId: data.spreadsheetId,
+                clearedRange: data.clearedRange,
+            };
+        }
+        catch (error) {
+            return {
+                error: 'Error clearing values',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=clear-values.js.map

package/dist/toolkits/google-sheets/tools/create-spreadsheet.d.ts

@@ -0,0 +1,33 @@
+export declare const createSpreadsheet: import("ai").Tool<{
+    title: string;
+    googleSheetsToken: string;
+    sheetTitles?: string[] | undefined;
+}, {
+    error: string;
+    details: any;
+    success?: undefined;
+    spreadsheetId?: undefined;
+    spreadsheetUrl?: undefined;
+    title?: undefined;
+    sheets?: undefined;
+    message?: undefined;
+} | {
+    success: boolean;
+    spreadsheetId: any;
+    spreadsheetUrl: any;
+    title: any;
+    sheets: any;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    success?: undefined;
+    spreadsheetId?: undefined;
+    spreadsheetUrl?: undefined;
+    title?: undefined;
+    sheets?: undefined;
+}>;
+//# sourceMappingURL=create-spreadsheet.d.ts.map

package/dist/toolkits/google-sheets/tools/create-spreadsheet.js

@@ -0,0 +1,59 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+export const createSpreadsheet = tool({
+    description: 'Create a new Google Sheets spreadsheet with a specified title and optional sheet tabs.',
+    inputSchema: z.object({
+        googleSheetsToken: z.string().describe('The Google Sheets access token'),
+        title: z.string().describe('The title of the new spreadsheet'),
+        sheetTitles: z.array(z.string()).optional().describe('Optional list of initial sheet tab titles to create (e.g., ["Summary", "Data"])'),
+    }),
+    execute: async ({ googleSheetsToken, title, sheetTitles }) => {
+        try {
+            const url = 'https://sheets.googleapis.com/v4/spreadsheets';
+            const payload = {
+                properties: {
+                    title,
+                },
+            };
+            if (sheetTitles && sheetTitles.length > 0) {
+                payload.sheets = sheetTitles.map((sheetTitle) => ({
+                    properties: {
+                        title: sheetTitle,
+                    },
+                }));
+            }
+            const response = await fetch(url, {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${googleSheetsToken}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify(payload),
+            });
+            if (!response.ok) {
+                const error = await response.json();
+                return { error: 'Failed to create spreadsheet', details: error };
+            }
+            const data = await response.json();
+            return {
+                success: true,
+                spreadsheetId: data.spreadsheetId,
+                spreadsheetUrl: data.spreadsheetUrl,
+                title: data.properties?.title,
+                sheets: data.sheets?.map((s) => ({
+                    sheetId: s.properties?.sheetId,
+                    title: s.properties?.title,
+                    index: s.properties?.index,
+                })),
+            };
+        }
+        catch (error) {
+            return {
+                error: 'Error creating spreadsheet',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=create-spreadsheet.js.map