@rnsk/toolkits 0.0.1 → 0.0.3

package/dist/toolkits/google-sheets/manifest.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("../../index.js").ToolkitManifest;
+export default _default;
+//# sourceMappingURL=manifest.d.ts.map

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

@@ -0,0 +1,45 @@
+import { defineToolkit, defineTool } from '../../core/define.js';
+import { inferToolScope } from '../../core/scope.js';
+import { GSHEETS_ICON } from './icon.js';
+import { googleSheetsTools } from './tools/index.js';
+export default defineToolkit({
+    id: 'google-sheets',
+    displayName: 'Google Sheets',
+    shortDescription: 'Read, write, append, and manage Google Sheets spreadsheets and cell values.',
+    category: 'Document & File Management',
+    icon: GSHEETS_ICON,
+    auth: {
+        type: 'oauth2',
+        tokenField: 'googleSheetsToken',
+        provider: {
+            slug: 'google-sheets',
+            env: {
+                clientId: 'GOOGLE_CLIENT_ID',
+                clientSecret: 'GOOGLE_CLIENT_SECRET',
+                clientIdFallback: 'GMAIL_CLIENT_ID',
+                clientSecretFallback: 'GMAIL_CLIENT_SECRET',
+            },
+            authorizeUrl: 'https://accounts.google.com/o/oauth2/v2/auth',
+            tokenUrl: 'https://oauth2.googleapis.com/token',
+            scopes: [
+                'https://www.googleapis.com/auth/spreadsheets',
+                'https://www.googleapis.com/auth/drive.metadata.readonly',
+            ],
+            exchangeStyle: 'form',
+            extraAuthParams: { access_type: 'offline', prompt: 'consent' },
+            connectDescription: 'Connect Google Sheets to read and write spreadsheet data.',
+            callbackPath: '/api/auth/google-sheets/callback',
+            stateCookie: 'google_sheets_oauth_state',
+        },
+    },
+    allowedHosts: ['sheets.googleapis.com', 'www.googleapis.com'],
+    tools: googleSheetsTools.map((entry) => defineTool({
+        name: entry.name,
+        description: entry.description,
+        tool: entry.tool,
+        requiredAuth: entry.requiredAuth,
+        scope: entry.scope ?? inferToolScope(entry.name),
+    })),
+    meta: { since: '0.0.2' },
+});
+//# sourceMappingURL=manifest.js.map

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

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

@@ -0,0 +1,5 @@
+export declare const getSpreadsheet: import("ai").Tool<{
+    googleSheetsToken: string;
+    spreadsheetId: string;
+}, any>;
+//# sourceMappingURL=get-spreadsheet.d.ts.map

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

@@ -0,0 +1,33 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+export const getSpreadsheet = tool({
+    description: 'Get details and metadata of a specific Google Sheets spreadsheet by ID.',
+    inputSchema: z.object({
+        googleSheetsToken: z.string().describe('The Google Sheets access token'),
+        spreadsheetId: z.string().describe('The ID of the spreadsheet to retrieve'),
+    }),
+    execute: async ({ googleSheetsToken, spreadsheetId }) => {
+        try {
+            const url = `https://sheets.googleapis.com/v4/spreadsheets/${spreadsheetId}`;
+            const response = await fetch(url, {
+                headers: {
+                    Authorization: `Bearer ${googleSheetsToken}`,
+                },
+            });
+            if (!response.ok) {
+                const error = await response.json();
+                return { error: 'Failed to get spreadsheet', details: error };
+            }
+            const data = await response.json();
+            return data;
+        }
+        catch (error) {
+            return {
+                error: 'Error getting spreadsheet',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=get-spreadsheet.js.map

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

@@ -0,0 +1,6 @@
+export declare const getValues: import("ai").Tool<{
+    range: string;
+    googleSheetsToken: string;
+    spreadsheetId: string;
+}, any>;
+//# sourceMappingURL=get-values.d.ts.map

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

@@ -0,0 +1,34 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+export const getValues = tool({
+    description: 'Get values from a specific range in a Google Sheets spreadsheet.',
+    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 retrieve (e.g., "Sheet1!A1:B10")'),
+    }),
+    execute: async ({ googleSheetsToken, spreadsheetId, range }) => {
+        try {
+            const url = `https://sheets.googleapis.com/v4/spreadsheets/${spreadsheetId}/values/${encodeURIComponent(range)}`;
+            const response = await fetch(url, {
+                headers: {
+                    Authorization: `Bearer ${googleSheetsToken}`,
+                },
+            });
+            if (!response.ok) {
+                const error = await response.json();
+                return { error: 'Failed to get values', details: error };
+            }
+            const data = await response.json();
+            return data;
+        }
+        catch (error) {
+            return {
+                error: 'Error getting values',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=get-values.js.map

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

@@ -0,0 +1,209 @@
+import { listSpreadsheets } from './list-spreadsheets.js';
+import { getSpreadsheet } from './get-spreadsheet.js';
+import { getValues } from './get-values.js';
+import { appendValues } from './append-values.js';
+import { updateValues } from './update-values.js';
+import { clearValues } from './clear-values.js';
+import { createSpreadsheet } from './create-spreadsheet.js';
+export { listSpreadsheets, getSpreadsheet, getValues, appendValues, updateValues, clearValues, createSpreadsheet, };
+export declare const googleSheetsTools: ({
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        googleSheetsToken: string;
+        pageSize: number;
+        q?: string | undefined;
+    }, {
+        error: string;
+        details: any;
+        spreadsheets?: undefined;
+        message?: undefined;
+    } | {
+        spreadsheets: any;
+        error?: undefined;
+        details?: undefined;
+        message?: undefined;
+    } | {
+        error: string;
+        message: string;
+        details?: undefined;
+        spreadsheets?: undefined;
+    }>;
+    requiredAuth: "googleSheetsToken";
+    scope: "read";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        googleSheetsToken: string;
+        spreadsheetId: string;
+    }, any>;
+    requiredAuth: "googleSheetsToken";
+    scope: "read";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        range: string;
+        googleSheetsToken: string;
+        spreadsheetId: string;
+    }, any>;
+    requiredAuth: "googleSheetsToken";
+    scope: "read";
+} | {
+    name: string;
+    description: string;
+    tool: 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;
+    }>;
+    requiredAuth: "googleSheetsToken";
+    scope: "write";
+} | {
+    name: string;
+    description: string;
+    tool: 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;
+        updatedRange?: undefined;
+        updatedRows?: undefined;
+        updatedColumns?: undefined;
+        updatedCells?: undefined;
+        message?: undefined;
+    } | {
+        success: boolean;
+        spreadsheetId: 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;
+        updatedRange?: undefined;
+        updatedRows?: undefined;
+        updatedColumns?: undefined;
+        updatedCells?: undefined;
+    }>;
+    requiredAuth: "googleSheetsToken";
+    scope: "write";
+} | {
+    name: string;
+    description: string;
+    tool: 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;
+    }>;
+    requiredAuth: "googleSheetsToken";
+    scope: "delete";
+} | {
+    name: string;
+    description: string;
+    tool: 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;
+    }>;
+    requiredAuth: "googleSheetsToken";
+    scope: "write";
+})[];
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,61 @@
+// @ts-nocheck
+import { listSpreadsheets } from './list-spreadsheets.js';
+import { getSpreadsheet } from './get-spreadsheet.js';
+import { getValues } from './get-values.js';
+import { appendValues } from './append-values.js';
+import { updateValues } from './update-values.js';
+import { clearValues } from './clear-values.js';
+import { createSpreadsheet } from './create-spreadsheet.js';
+export { listSpreadsheets, getSpreadsheet, getValues, appendValues, updateValues, clearValues, createSpreadsheet, };
+export const googleSheetsTools = [
+    {
+        name: 'googleSheetsListSpreadsheets',
+        description: 'List or search for Google Sheets spreadsheets in the user\'s Drive.',
+        tool: listSpreadsheets,
+        requiredAuth: 'googleSheetsToken',
+        scope: 'read',
+    },
+    {
+        name: 'googleSheetsGetSpreadsheet',
+        description: 'Get details and metadata of a specific Google Sheets spreadsheet by ID.',
+        tool: getSpreadsheet,
+        requiredAuth: 'googleSheetsToken',
+        scope: 'read',
+    },
+    {
+        name: 'googleSheetsGetValues',
+        description: 'Get values from a specific range in a Google Sheets spreadsheet.',
+        tool: getValues,
+        requiredAuth: 'googleSheetsToken',
+        scope: 'read',
+    },
+    {
+        name: 'googleSheetsAppendValues',
+        description: 'Append rows of values to a Google Sheets spreadsheet range (e.g., adding new rows at the bottom of a table).',
+        tool: appendValues,
+        requiredAuth: 'googleSheetsToken',
+        scope: 'write',
+    },
+    {
+        name: 'googleSheetsUpdateValues',
+        description: 'Update or overwrite values in a specific range of a Google Sheets spreadsheet.',
+        tool: updateValues,
+        requiredAuth: 'googleSheetsToken',
+        scope: 'write',
+    },
+    {
+        name: 'googleSheetsClearValues',
+        description: 'Clear values from a specific range in a Google Sheets spreadsheet, leaving cell formatting intact.',
+        tool: clearValues,
+        requiredAuth: 'googleSheetsToken',
+        scope: 'delete',
+    },
+    {
+        name: 'googleSheetsCreateSpreadsheet',
+        description: 'Create a new Google Sheets spreadsheet with a specified title and optional sheet tabs.',
+        tool: createSpreadsheet,
+        requiredAuth: 'googleSheetsToken',
+        scope: 'write',
+    },
+];
+//# sourceMappingURL=index.js.map

package/dist/toolkits/google-sheets/tools/list-spreadsheets.d.ts

@@ -0,0 +1,21 @@
+export declare const listSpreadsheets: import("ai").Tool<{
+    googleSheetsToken: string;
+    pageSize: number;
+    q?: string | undefined;
+}, {
+    error: string;
+    details: any;
+    spreadsheets?: undefined;
+    message?: undefined;
+} | {
+    spreadsheets: any;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    spreadsheets?: undefined;
+}>;
+//# sourceMappingURL=list-spreadsheets.d.ts.map