@rnsk/toolkits 0.0.6 → 0.0.8

package/dist/toolkits/google-tasks/tools/batch-execute.d.ts

@@ -0,0 +1,34 @@
+export declare const batchExecute: import("ai").Tool<{
+    requests: {
+        path: string;
+        id: string;
+        method: "POST" | "DELETE" | "GET" | "PATCH" | "PUT";
+        query?: Record<string, string | number | boolean> | undefined;
+        headers?: Record<string, string> | undefined;
+        jsonBody?: Record<string, any> | undefined;
+    }[];
+    googleTasksToken: string;
+    maxRequests?: number | undefined;
+}, {
+    error: string;
+    results?: undefined;
+    totalRequests?: undefined;
+    successfulCount?: undefined;
+    failedCount?: undefined;
+    message?: undefined;
+} | {
+    results: Record<string, unknown>[];
+    totalRequests: number;
+    successfulCount: number;
+    failedCount: number;
+    error?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    results?: undefined;
+    totalRequests?: undefined;
+    successfulCount?: undefined;
+    failedCount?: undefined;
+}>;
+//# sourceMappingURL=batch-execute.d.ts.map

package/dist/toolkits/google-tasks/tools/batch-execute.js

@@ -0,0 +1,95 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { tasksApiRequest } from './utils.js';
+const ALLOWED_METHODS = ['GET', 'POST', 'PATCH', 'PUT', 'DELETE'];
+export const batchExecute = tool({
+    description: 'Executes multiple Google Tasks API operations in a single tool call and returns structured per-item results. Use to reduce LLM tool invocations when doing bulk updates, moves, or deletes. Each sub-request still counts toward API quota.',
+    inputSchema: z.object({
+        googleTasksToken: z.string().describe('The Google Tasks access token'),
+        requests: z
+            .array(z.object({
+            id: z.string().describe("Client-chosen unique id for this sub-request, e.g. 'task1'"),
+            method: z.enum(ALLOWED_METHODS).describe('HTTP method, must be uppercase'),
+            path: z
+                .string()
+                .describe("API endpoint path starting with '/tasks/v1/', e.g. '/tasks/v1/lists/@default/tasks'"),
+            query: z.record(z.union([z.string(), z.number(), z.boolean()])).optional().describe('Query params as key-value pairs'),
+            headers: z.record(z.string()).optional().describe('Optional per-request headers'),
+            jsonBody: z.record(z.any()).optional().describe('JSON body for POST/PATCH/PUT requests'),
+        }))
+            .min(1)
+            .describe('Array of sub-requests to execute. Each returns its own result.'),
+        maxRequests: z
+            .number()
+            .min(1)
+            .max(1000)
+            .optional()
+            .describe('Maximum sub-requests allowed in a single batch (default 1000, caps response size)'),
+    }),
+    execute: async ({ googleTasksToken, requests, maxRequests }) => {
+        try {
+            const limit = maxRequests ?? 1000;
+            if (requests.length > limit) {
+                return { error: `Too many sub-requests: got ${requests.length}, max is ${limit}` };
+            }
+            const results = [];
+            for (const sub of requests) {
+                const method = String(sub.method).toUpperCase();
+                if (!ALLOWED_METHODS.includes(method)) {
+                    results.push({ id: sub.id, status: 400, error: { message: `Unsupported method: ${sub.method}` } });
+                    continue;
+                }
+                let path = sub.path;
+                if (!path.startsWith('/tasks/v1/')) {
+                    results.push({
+                        id: sub.id,
+                        status: 400,
+                        error: { message: "path must start with '/tasks/v1/'" },
+                    });
+                    continue;
+                }
+                // Strip the '/tasks/v1' prefix since TASKS_API_BASE already includes it.
+                path = path.slice('/tasks/v1'.length) || '/';
+                const searchParams = {};
+                if (sub.query) {
+                    for (const [k, v] of Object.entries(sub.query)) {
+                        searchParams[k] = v;
+                    }
+                }
+                const result = await tasksApiRequest(googleTasksToken, path, {
+                    method,
+                    body: method === 'GET' || method === 'DELETE' ? undefined : sub.jsonBody,
+                    searchParams,
+                });
+                if (!result.ok) {
+                    const details = result.error;
+                    const status = typeof details?.status === 'number'
+                        ? details.status
+                        : typeof details?.code === 'number'
+                            ? details.code
+                            : 400;
+                    results.push({ id: sub.id, status, error: details });
+                }
+                else {
+                    const status = method === 'POST' ? 201 : 200;
+                    results.push({ id: sub.id, status, jsonBody: result.data });
+                }
+            }
+            const successfulCount = results.filter((r) => typeof r.status === 'number' && r.status >= 200 && r.status < 300).length;
+            return {
+                results,
+                totalRequests: results.length,
+                successfulCount,
+                failedCount: results.length - successfulCount,
+            };
+        }
+        catch (error) {
+            return {
+                error: 'Error executing batch',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=batch-execute.js.map

package/dist/toolkits/google-tasks/tools/clear-tasks.d.ts

@@ -0,0 +1,5 @@
+export declare const clearTasks: import("ai").Tool<{
+    googleTasksToken: string;
+    taskListId: string;
+}, any>;
+//# sourceMappingURL=clear-tasks.d.ts.map

package/dist/toolkits/google-tasks/tools/clear-tasks.js

@@ -0,0 +1,29 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { tasksApiRequest } from './utils.js';
+export const clearTasks = tool({
+    description: 'Clears all completed tasks from a task list. Use to tidy up a list after tasks are done.',
+    inputSchema: z.object({
+        googleTasksToken: z.string().describe('The Google Tasks access token'),
+        taskListId: z.string().describe('The ID of the task list to clear completed tasks from'),
+    }),
+    execute: async ({ googleTasksToken, taskListId }) => {
+        try {
+            const result = await tasksApiRequest(googleTasksToken, `/lists/${taskListId}/clear`, {
+                method: 'POST',
+            });
+            if (!result.ok) {
+                return { error: 'Failed to clear completed tasks', details: result.error };
+            }
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error clearing completed tasks',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=clear-tasks.js.map

package/dist/toolkits/google-tasks/tools/create-task-list.d.ts

@@ -0,0 +1,5 @@
+export declare const createTaskList: import("ai").Tool<{
+    title: string;
+    googleTasksToken: string;
+}, any>;
+//# sourceMappingURL=create-task-list.d.ts.map

package/dist/toolkits/google-tasks/tools/create-task-list.js

@@ -0,0 +1,30 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { tasksApiRequest } from './utils.js';
+export const createTaskList = tool({
+    description: 'Creates a new task list with the given title. Use when the user wants a new list to organize tasks.',
+    inputSchema: z.object({
+        googleTasksToken: z.string().describe('The Google Tasks access token'),
+        title: z.string().describe('Title of the new task list'),
+    }),
+    execute: async ({ googleTasksToken, title }) => {
+        try {
+            const result = await tasksApiRequest(googleTasksToken, '/users/@me/lists', {
+                method: 'POST',
+                body: { title },
+            });
+            if (!result.ok) {
+                return { error: 'Failed to create task list', details: result.error };
+            }
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error creating task list',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=create-task-list.js.map

package/dist/toolkits/google-tasks/tools/create-task.d.ts

@@ -0,0 +1,12 @@
+export declare const createTask: import("ai").Tool<{
+    title: string;
+    googleTasksToken: string;
+    taskListId: string;
+    status?: "completed" | "needsAction" | undefined;
+    completed?: string | undefined;
+    parent?: string | undefined;
+    notes?: string | undefined;
+    due?: string | undefined;
+    previous?: string | undefined;
+}, any>;
+//# sourceMappingURL=create-task.d.ts.map

package/dist/toolkits/google-tasks/tools/create-task.js

@@ -0,0 +1,47 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { tasksApiRequest } from './utils.js';
+export const createTask = tool({
+    description: 'Creates a new task in a task list. Use to add to-dos with optional notes, due date, subtask parent, or position.',
+    inputSchema: z.object({
+        googleTasksToken: z.string().describe('The Google Tasks access token'),
+        taskListId: z.string().describe('The ID of the task list to create the task in'),
+        title: z.string().describe('Title of the task'),
+        notes: z.string().optional().describe('Notes or details for the task'),
+        due: z.string().optional().describe('Due date in RFC 3339 format, e.g. 2026-09-20T00:00:00Z'),
+        completed: z.string().optional().describe('Completion timestamp in RFC 3339 format (only with status completed)'),
+        status: z.enum(['needsAction', 'completed']).optional().describe('Initial status (default needsAction)'),
+        parent: z.string().optional().describe('Parent task ID to create this as a subtask'),
+        previous: z.string().optional().describe('Sibling task ID to insert this task after'),
+    }),
+    execute: async ({ googleTasksToken, taskListId, title, notes, due, completed, status, parent, previous, }) => {
+        try {
+            const body = { title };
+            if (notes !== undefined)
+                body.notes = notes;
+            if (due !== undefined)
+                body.due = due;
+            if (completed !== undefined)
+                body.completed = completed;
+            if (status !== undefined)
+                body.status = status;
+            const result = await tasksApiRequest(googleTasksToken, `/lists/${taskListId}/tasks`, {
+                method: 'POST',
+                body,
+                searchParams: { parent, previous },
+            });
+            if (!result.ok) {
+                return { error: 'Failed to create task', details: result.error };
+            }
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error creating task',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=create-task.js.map

package/dist/toolkits/google-tasks/tools/delete-task-list.d.ts

@@ -0,0 +1,5 @@
+export declare const deleteTaskList: import("ai").Tool<{
+    googleTasksToken: string;
+    taskListId: string;
+}, any>;
+//# sourceMappingURL=delete-task-list.d.ts.map

package/dist/toolkits/google-tasks/tools/delete-task-list.js

@@ -0,0 +1,29 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { tasksApiRequest } from './utils.js';
+export const deleteTaskList = tool({
+    description: 'Deletes a task list and all tasks it contains. Use only when the user explicitly asks to remove a list.',
+    inputSchema: z.object({
+        googleTasksToken: z.string().describe('The Google Tasks access token'),
+        taskListId: z.string().describe('The ID of the task list to delete'),
+    }),
+    execute: async ({ googleTasksToken, taskListId }) => {
+        try {
+            const result = await tasksApiRequest(googleTasksToken, `/users/@me/lists/${taskListId}`, {
+                method: 'DELETE',
+            });
+            if (!result.ok) {
+                return { error: 'Failed to delete task list', details: result.error };
+            }
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error deleting task list',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=delete-task-list.js.map

package/dist/toolkits/google-tasks/tools/delete-task.d.ts

@@ -0,0 +1,6 @@
+export declare const deleteTask: import("ai").Tool<{
+    googleTasksToken: string;
+    taskListId: string;
+    taskId: string;
+}, any>;
+//# sourceMappingURL=delete-task.d.ts.map

package/dist/toolkits/google-tasks/tools/delete-task.js

@@ -0,0 +1,28 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { tasksApiRequest } from './utils.js';
+export const deleteTask = tool({
+    description: 'Deletes a task and all of its subtasks. Use only when the user explicitly asks to remove a task.',
+    inputSchema: z.object({
+        googleTasksToken: z.string().describe('The Google Tasks access token'),
+        taskListId: z.string().describe('The ID of the task list containing the task'),
+        taskId: z.string().describe('The ID of the task to delete'),
+    }),
+    execute: async ({ googleTasksToken, taskListId, taskId }) => {
+        try {
+            const result = await tasksApiRequest(googleTasksToken, `/lists/${taskListId}/tasks/${taskId}`, { method: 'DELETE' });
+            if (!result.ok) {
+                return { error: 'Failed to delete task', details: result.error };
+            }
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error deleting task',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=delete-task.js.map

package/dist/toolkits/google-tasks/tools/get-task-list.d.ts

@@ -0,0 +1,5 @@
+export declare const getTaskList: import("ai").Tool<{
+    googleTasksToken: string;
+    taskListId: string;
+}, any>;
+//# sourceMappingURL=get-task-list.d.ts.map

package/dist/toolkits/google-tasks/tools/get-task-list.js

@@ -0,0 +1,27 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { tasksApiRequest } from './utils.js';
+export const getTaskList = tool({
+    description: 'Retrieves a single task list by ID, including its title, ID, and last-updated timestamp.',
+    inputSchema: z.object({
+        googleTasksToken: z.string().describe('The Google Tasks access token'),
+        taskListId: z.string().describe('The ID of the task list to retrieve'),
+    }),
+    execute: async ({ googleTasksToken, taskListId }) => {
+        try {
+            const result = await tasksApiRequest(googleTasksToken, `/users/@me/lists/${taskListId}`);
+            if (!result.ok) {
+                return { error: 'Failed to get task list', details: result.error };
+            }
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error getting task list',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=get-task-list.js.map

package/dist/toolkits/google-tasks/tools/get-task.d.ts

@@ -0,0 +1,6 @@
+export declare const getTask: import("ai").Tool<{
+    googleTasksToken: string;
+    taskListId: string;
+    taskId: string;
+}, any>;
+//# sourceMappingURL=get-task.d.ts.map

package/dist/toolkits/google-tasks/tools/get-task.js

@@ -0,0 +1,28 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { tasksApiRequest } from './utils.js';
+export const getTask = tool({
+    description: 'Retrieves a single task by ID, including title, notes, status, due date, and position.',
+    inputSchema: z.object({
+        googleTasksToken: z.string().describe('The Google Tasks access token'),
+        taskListId: z.string().describe('The ID of the task list containing the task'),
+        taskId: z.string().describe('The ID of the task to retrieve'),
+    }),
+    execute: async ({ googleTasksToken, taskListId, taskId }) => {
+        try {
+            const result = await tasksApiRequest(googleTasksToken, `/lists/${taskListId}/tasks/${taskId}`);
+            if (!result.ok) {
+                return { error: 'Failed to get task', details: result.error };
+            }
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error getting task',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=get-task.js.map

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

@@ -0,0 +1,249 @@
+import { batchExecute } from './batch-execute.js';
+import { clearTasks } from './clear-tasks.js';
+import { createTask } from './create-task.js';
+import { createTaskList } from './create-task-list.js';
+import { deleteTask } from './delete-task.js';
+import { deleteTaskList } from './delete-task-list.js';
+import { getTask } from './get-task.js';
+import { getTaskList } from './get-task-list.js';
+import { listAllTasks } from './list-all-tasks.js';
+import { listTaskLists } from './list-task-lists.js';
+import { listTasks } from './list-tasks.js';
+import { moveTask } from './move-task.js';
+import { updateTask } from './update-task.js';
+import { updateTaskFull } from './update-task-full.js';
+import { updateTaskList } from './update-task-list.js';
+export { batchExecute, clearTasks, createTask, createTaskList, deleteTask, deleteTaskList, getTask, getTaskList, listAllTasks, listTaskLists, listTasks, moveTask, updateTask, updateTaskFull, updateTaskList, };
+export declare const googleTasksTools: ({
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        googleTasksToken: string;
+        maxResults?: number | undefined;
+        pageToken?: string | undefined;
+    }, any>;
+    requiredAuth: "googleTasksToken";
+    scope: "read";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        googleTasksToken: string;
+        taskListId: string;
+    }, any>;
+    requiredAuth: "googleTasksToken";
+    scope: "read";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        title: string;
+        googleTasksToken: string;
+    }, any>;
+    requiredAuth: "googleTasksToken";
+    scope: "write";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        title: string;
+        googleTasksToken: string;
+        taskListId: string;
+    }, any>;
+    requiredAuth: "googleTasksToken";
+    scope: "write";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        googleTasksToken: string;
+        taskListId: string;
+    }, any>;
+    requiredAuth: "googleTasksToken";
+    scope: "delete";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        googleTasksToken: string;
+        taskListId: string;
+        maxResults?: number | undefined;
+        pageToken?: string | undefined;
+        showCompleted?: boolean | undefined;
+        showDeleted?: boolean | undefined;
+        showHidden?: boolean | undefined;
+        updatedMin?: string | undefined;
+        dueMin?: string | undefined;
+        dueMax?: string | undefined;
+        completedMin?: string | undefined;
+        completedMax?: string | undefined;
+    }, any>;
+    requiredAuth: "googleTasksToken";
+    scope: "read";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        googleTasksToken: string;
+        taskListId: string;
+        taskId: string;
+    }, any>;
+    requiredAuth: "googleTasksToken";
+    scope: "read";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        title: string;
+        googleTasksToken: string;
+        taskListId: string;
+        status?: "completed" | "needsAction" | undefined;
+        completed?: string | undefined;
+        parent?: string | undefined;
+        notes?: string | undefined;
+        due?: string | undefined;
+        previous?: string | undefined;
+    }, any>;
+    requiredAuth: "googleTasksToken";
+    scope: "write";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        googleTasksToken: string;
+        taskListId: string;
+        taskId: string;
+        status?: "completed" | "needsAction" | undefined;
+        title?: string | undefined;
+        completed?: string | undefined;
+        notes?: string | undefined;
+        due?: string | undefined;
+    }, any>;
+    requiredAuth: "googleTasksToken";
+    scope: "write";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        googleTasksToken: string;
+        taskListId: string;
+        taskId: string;
+    }, any>;
+    requiredAuth: "googleTasksToken";
+    scope: "delete";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        googleTasksToken: string;
+        taskListId: string;
+        taskId: string;
+        parent?: string | undefined;
+        previous?: string | undefined;
+        destinationTaskListId?: string | undefined;
+    }, any>;
+    requiredAuth: "googleTasksToken";
+    scope: "write";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        title: string;
+        id: string;
+        googleTasksToken: string;
+        taskListId: string;
+        taskId: string;
+        status?: "completed" | "needsAction" | undefined;
+        completed?: string | undefined;
+        deleted?: boolean | undefined;
+        notes?: string | undefined;
+        due?: string | undefined;
+        etag?: string | undefined;
+    }, any>;
+    requiredAuth: "googleTasksToken";
+    scope: "write";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        googleTasksToken: string;
+        showCompleted?: boolean | undefined;
+        showDeleted?: boolean | undefined;
+        showHidden?: boolean | undefined;
+        updatedMin?: string | undefined;
+        dueMin?: string | undefined;
+        dueMax?: string | undefined;
+        completedMin?: string | undefined;
+        completedMax?: string | undefined;
+        showAssigned?: boolean | undefined;
+        maxTasksTotal?: number | undefined;
+    }, {
+        error: string;
+        details: any;
+        tasks?: undefined;
+        tasklists?: undefined;
+        totalTasks?: undefined;
+        totalLists?: undefined;
+        truncated?: undefined;
+        message?: undefined;
+    } | {
+        tasks: Record<string, unknown>[];
+        tasklists: Record<string, unknown>[];
+        totalTasks: number;
+        totalLists: number;
+        truncated: boolean;
+        error?: undefined;
+        details?: undefined;
+        message?: undefined;
+    } | {
+        error: string;
+        message: string;
+        details?: undefined;
+        tasks?: undefined;
+        tasklists?: undefined;
+        totalTasks?: undefined;
+        totalLists?: undefined;
+        truncated?: undefined;
+    }>;
+    requiredAuth: "googleTasksToken";
+    scope: "read";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        requests: {
+            path: string;
+            id: string;
+            method: "POST" | "DELETE" | "GET" | "PATCH" | "PUT";
+            query?: Record<string, string | number | boolean> | undefined;
+            headers?: Record<string, string> | undefined;
+            jsonBody?: Record<string, any> | undefined;
+        }[];
+        googleTasksToken: string;
+        maxRequests?: number | undefined;
+    }, {
+        error: string;
+        results?: undefined;
+        totalRequests?: undefined;
+        successfulCount?: undefined;
+        failedCount?: undefined;
+        message?: undefined;
+    } | {
+        results: Record<string, unknown>[];
+        totalRequests: number;
+        successfulCount: number;
+        failedCount: number;
+        error?: undefined;
+        message?: undefined;
+    } | {
+        error: string;
+        message: string;
+        results?: undefined;
+        totalRequests?: undefined;
+        successfulCount?: undefined;
+        failedCount?: undefined;
+    }>;
+    requiredAuth: "googleTasksToken";
+    scope: "write";
+})[];
+//# sourceMappingURL=index.d.ts.map