@rnsk/toolkits 0.0.6 → 0.0.8

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

@@ -0,0 +1,125 @@
+// @ts-nocheck
+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 const googleTasksTools = [
+    {
+        name: 'googleTasksListTaskLists',
+        description: 'Lists all task lists owned by the authenticated user. Use to discover available task lists before reading or managing tasks.',
+        tool: listTaskLists,
+        requiredAuth: 'googleTasksToken',
+        scope: 'read',
+    },
+    {
+        name: 'googleTasksGetTaskList',
+        description: 'Retrieves a single task list by ID, including its title, ID, and last-updated timestamp.',
+        tool: getTaskList,
+        requiredAuth: 'googleTasksToken',
+        scope: 'read',
+    },
+    {
+        name: 'googleTasksCreateTaskList',
+        description: 'Creates a new task list with the given title. Use when the user wants a new list to organize tasks.',
+        tool: createTaskList,
+        requiredAuth: 'googleTasksToken',
+        scope: 'write',
+    },
+    {
+        name: 'googleTasksUpdateTaskList',
+        description: 'Renames an existing task list. Use PATCH semantics — only the title is updated.',
+        tool: updateTaskList,
+        requiredAuth: 'googleTasksToken',
+        scope: 'write',
+    },
+    {
+        name: 'googleTasksDeleteTaskList',
+        description: 'Deletes a task list and all tasks it contains. Use only when the user explicitly asks to remove a list.',
+        tool: deleteTaskList,
+        requiredAuth: 'googleTasksToken',
+        scope: 'delete',
+    },
+    {
+        name: 'googleTasksListTasks',
+        description: 'Lists tasks in a task list with optional filters. Use to view open tasks, completed tasks, or tasks due within a range.',
+        tool: listTasks,
+        requiredAuth: 'googleTasksToken',
+        scope: 'read',
+    },
+    {
+        name: 'googleTasksGetTask',
+        description: 'Retrieves a single task by ID, including title, notes, status, due date, and position.',
+        tool: getTask,
+        requiredAuth: 'googleTasksToken',
+        scope: 'read',
+    },
+    {
+        name: 'googleTasksCreateTask',
+        description: 'Creates a new task in a task list. Use to add to-dos with optional notes, due date, subtask parent, or position.',
+        tool: createTask,
+        requiredAuth: 'googleTasksToken',
+        scope: 'write',
+    },
+    {
+        name: 'googleTasksUpdateTask',
+        description: 'Updates a task title, notes, due date, or status. Use to rename, reschedule, complete, or reopen a task.',
+        tool: updateTask,
+        requiredAuth: 'googleTasksToken',
+        scope: 'write',
+    },
+    {
+        name: 'googleTasksDeleteTask',
+        description: 'Deletes a task and all of its subtasks. Use only when the user explicitly asks to remove a task.',
+        tool: deleteTask,
+        requiredAuth: 'googleTasksToken',
+        scope: 'delete',
+    },
+    {
+        name: 'googleTasksMoveTask',
+        description: 'Moves a task to a new position, optionally under a different parent or to a different task list. Use to reorder tasks, convert a task into a subtask, or move across lists.',
+        tool: moveTask,
+        requiredAuth: 'googleTasksToken',
+        scope: 'write',
+    },
+    {
+        name: 'googleTasksUpdateTaskFull',
+        description: 'Fully replaces a task via PUT (requires id and title). Use when you need to rewrite the entire task resource instead of patching individual fields.',
+        tool: updateTaskFull,
+        requiredAuth: 'googleTasksToken',
+        scope: 'write',
+    },
+    {
+        name: 'googleTasksListAllTasks',
+        description: 'Lists all tasks across all task lists with optional filters. Use when you need a global view without knowing which list to query first.',
+        tool: listAllTasks,
+        requiredAuth: 'googleTasksToken',
+        scope: 'read',
+    },
+    {
+        name: 'googleTasksBatchExecute',
+        description: 'Executes multiple Google Tasks API operations in a single tool call. Use for bulk updates, moves, or deletes to reduce tool invocations.',
+        tool: batchExecute,
+        requiredAuth: 'googleTasksToken',
+        scope: 'write',
+    },
+    {
+        name: 'googleTasksClearTasks',
+        description: 'Clears all completed tasks from a task list. Use to tidy up a list after tasks are done.',
+        tool: clearTasks,
+        requiredAuth: 'googleTasksToken',
+        scope: 'delete',
+    },
+];
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,41 @@
+export declare const listAllTasks: 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;
+}>;
+//# sourceMappingURL=list-all-tasks.d.ts.map

package/dist/toolkits/google-tasks/tools/list-all-tasks.js

@@ -0,0 +1,106 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { tasksApiRequest } from './utils.js';
+export const listAllTasks = tool({
+    description: 'Lists all tasks across all task lists with optional filters. Use when you need to see everything without knowing which list to query first. Each task is annotated with tasklistId and tasklistTitle.',
+    inputSchema: z.object({
+        googleTasksToken: z.string().describe('The Google Tasks access token'),
+        showCompleted: z.boolean().optional().describe('Include completed tasks (default true)'),
+        showDeleted: z.boolean().optional().describe('Include deleted tasks (default false)'),
+        showHidden: z.boolean().optional().describe('Include hidden tasks (default false)'),
+        showAssigned: z.boolean().optional().describe('Include tasks assigned from Docs/Chat (default false)'),
+        dueMin: z.string().optional().describe('Only include tasks due on or after this RFC 3339 timestamp'),
+        dueMax: z.string().optional().describe('Only include tasks due on or before this RFC 3339 timestamp'),
+        completedMin: z.string().optional().describe('Only include tasks completed on or after this RFC 3339 timestamp'),
+        completedMax: z.string().optional().describe('Only include tasks completed on or before this RFC 3339 timestamp'),
+        updatedMin: z.string().optional().describe('Only include tasks updated on or after this RFC 3339 timestamp'),
+        maxTasksTotal: z
+            .number()
+            .min(1)
+            .max(100000)
+            .optional()
+            .describe('Hard limit on total tasks returned across all lists (default 1000)'),
+    }),
+    execute: async ({ googleTasksToken, showCompleted, showDeleted, showHidden, showAssigned, dueMin, dueMax, completedMin, completedMax, updatedMin, maxTasksTotal, }) => {
+        try {
+            const limit = maxTasksTotal ?? 1000;
+            // 1. Fetch all task lists (paginate).
+            const tasklists = [];
+            let pageToken;
+            do {
+                const listsResult = await tasksApiRequest(googleTasksToken, '/users/@me/lists', {
+                    searchParams: { maxResults: 100, pageToken },
+                });
+                if (!listsResult.ok) {
+                    return { error: 'Failed to list task lists', details: listsResult.error };
+                }
+                const data = listsResult.data;
+                for (const item of data.items ?? []) {
+                    if (item?.id)
+                        tasklists.push({ id: item.id, title: item.title });
+                }
+                pageToken = data.nextPageToken;
+            } while (pageToken);
+            // 2. Fetch tasks per list with the same filters.
+            const tasks = [];
+            const listsMeta = [];
+            let truncated = false;
+            for (const list of tasklists) {
+                let listPageToken;
+                let countForList = 0;
+                do {
+                    if (tasks.length >= limit) {
+                        truncated = true;
+                        break;
+                    }
+                    const result = await tasksApiRequest(googleTasksToken, `/lists/${list.id}/tasks`, {
+                        searchParams: {
+                            showCompleted: showCompleted ?? true,
+                            showDeleted,
+                            showHidden,
+                            showAssigned,
+                            dueMin,
+                            dueMax,
+                            completedMin,
+                            completedMax,
+                            updatedMin,
+                            maxResults: 100,
+                            pageToken: listPageToken,
+                        },
+                    });
+                    if (!result.ok) {
+                        return { error: `Failed to list tasks for list ${list.id}`, details: result.error };
+                    }
+                    const data = result.data;
+                    for (const item of data.items ?? []) {
+                        if (tasks.length >= limit) {
+                            truncated = true;
+                            break;
+                        }
+                        tasks.push({ ...item, tasklistId: list.id, tasklistTitle: list.title });
+                        countForList += 1;
+                    }
+                    listPageToken = data.nextPageToken;
+                } while (listPageToken && !truncated);
+                listsMeta.push({ id: list.id, title: list.title, taskCount: countForList });
+                if (truncated)
+                    break;
+            }
+            return {
+                tasks,
+                tasklists: listsMeta,
+                totalTasks: tasks.length,
+                totalLists: tasklists.length,
+                truncated,
+            };
+        }
+        catch (error) {
+            return {
+                error: 'Error listing all tasks',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=list-all-tasks.js.map

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

@@ -0,0 +1,6 @@
+export declare const listTaskLists: import("ai").Tool<{
+    googleTasksToken: string;
+    maxResults?: number | undefined;
+    pageToken?: string | undefined;
+}, any>;
+//# sourceMappingURL=list-task-lists.d.ts.map

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

@@ -0,0 +1,30 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { tasksApiRequest } from './utils.js';
+export const listTaskLists = tool({
+    description: 'Lists all task lists owned by the authenticated user. Use to discover available task lists before reading or managing tasks.',
+    inputSchema: z.object({
+        googleTasksToken: z.string().describe('The Google Tasks access token'),
+        maxResults: z.number().optional().describe('Maximum number of task lists to return (max 100)'),
+        pageToken: z.string().optional().describe('Token for fetching the next page of results'),
+    }),
+    execute: async ({ googleTasksToken, maxResults, pageToken }) => {
+        try {
+            const result = await tasksApiRequest(googleTasksToken, '/users/@me/lists', {
+                searchParams: { maxResults, pageToken },
+            });
+            if (!result.ok) {
+                return { error: 'Failed to list task lists', details: result.error };
+            }
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error listing task lists',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=list-task-lists.js.map

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

@@ -0,0 +1,15 @@
+export declare const listTasks: 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>;
+//# sourceMappingURL=list-tasks.d.ts.map

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

@@ -0,0 +1,50 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { tasksApiRequest } from './utils.js';
+export const listTasks = tool({
+    description: 'Lists tasks in a task list with optional filters. Use to view open tasks, completed tasks, or tasks due within a range. Defaults to hiding completed and deleted tasks.',
+    inputSchema: z.object({
+        googleTasksToken: z.string().describe('The Google Tasks access token'),
+        taskListId: z.string().describe('The ID of the task list to list tasks from'),
+        showCompleted: z.boolean().optional().describe('Include completed tasks (default false)'),
+        showDeleted: z.boolean().optional().describe('Include deleted tasks (default false)'),
+        showHidden: z.boolean().optional().describe('Include hidden tasks (default false)'),
+        maxResults: z.number().optional().describe('Maximum number of tasks to return (max 100)'),
+        pageToken: z.string().optional().describe('Token for fetching the next page of results'),
+        updatedMin: z.string().optional().describe('Only return tasks updated after this RFC 3339 timestamp'),
+        dueMin: z.string().optional().describe('Only return tasks due after this RFC 3339 timestamp'),
+        dueMax: z.string().optional().describe('Only return tasks due before this RFC 3339 timestamp'),
+        completedMin: z.string().optional().describe('Only return tasks completed after this RFC 3339 timestamp (requires showCompleted true)'),
+        completedMax: z.string().optional().describe('Only return tasks completed before this RFC 3339 timestamp (requires showCompleted true)'),
+    }),
+    execute: async ({ googleTasksToken, taskListId, showCompleted, showDeleted, showHidden, maxResults, pageToken, updatedMin, dueMin, dueMax, completedMin, completedMax, }) => {
+        try {
+            const result = await tasksApiRequest(googleTasksToken, `/lists/${taskListId}/tasks`, {
+                searchParams: {
+                    showCompleted,
+                    showDeleted,
+                    showHidden,
+                    maxResults,
+                    pageToken,
+                    updatedMin,
+                    dueMin,
+                    dueMax,
+                    completedMin,
+                    completedMax,
+                },
+            });
+            if (!result.ok) {
+                return { error: 'Failed to list tasks', details: result.error };
+            }
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error listing tasks',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=list-tasks.js.map

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

@@ -0,0 +1,9 @@
+export declare const moveTask: import("ai").Tool<{
+    googleTasksToken: string;
+    taskListId: string;
+    taskId: string;
+    parent?: string | undefined;
+    previous?: string | undefined;
+    destinationTaskListId?: string | undefined;
+}, any>;
+//# sourceMappingURL=move-task.d.ts.map

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

@@ -0,0 +1,37 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { tasksApiRequest } from './utils.js';
+export const moveTask = tool({
+    description: 'Moves a task to a new position, optionally under a different parent or to a different task list. Use to reorder tasks, convert a task into a subtask, or move across lists (set destinationTaskListId).',
+    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 move'),
+        parent: z.string().optional().describe('New parent task ID to nest under (omit for top level)'),
+        previous: z.string().optional().describe('Sibling task ID to place this task after'),
+        destinationTaskListId: z
+            .string()
+            .optional()
+            .describe('Destination task list ID to move across lists (omit to reorder within the same list)'),
+    }),
+    execute: async ({ googleTasksToken, taskListId, taskId, parent, previous, destinationTaskListId }) => {
+        try {
+            const result = await tasksApiRequest(googleTasksToken, `/lists/${taskListId}/tasks/${taskId}/move`, {
+                method: 'POST',
+                searchParams: { parent, previous, destinationTasklist: destinationTaskListId },
+            });
+            if (!result.ok) {
+                return { error: 'Failed to move task', details: result.error };
+            }
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error moving task',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=move-task.js.map

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

@@ -0,0 +1,14 @@
+export declare const updateTaskFull: 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>;
+//# sourceMappingURL=update-task-full.d.ts.map

package/dist/toolkits/google-tasks/tools/update-task-full.js

@@ -0,0 +1,55 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { tasksApiRequest } from './utils.js';
+export const updateTaskFull = tool({
+    description: 'Fully replaces a task via PUT. Use when you need to rewrite the entire task resource, not just patch fields. Requires id (must match taskId) and title; unlike PATCH, omitted optional fields are cleared to defaults.',
+    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 fully replace'),
+        id: z.string().describe('Task identifier for the request body (REQUIRED, must match taskId)'),
+        title: z.string().min(1).max(1024).describe('Title of the task (REQUIRED)'),
+        notes: z.string().max(8192).optional().describe('Notes for the task (plain text)'),
+        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('Task status'),
+        deleted: z.boolean().optional().describe('Whether the task is marked deleted'),
+        etag: z.string().optional().describe('ETag for optimistic concurrency control'),
+    }),
+    execute: async ({ googleTasksToken, taskListId, taskId, id, title, notes, due, completed, status, deleted, etag }) => {
+        try {
+            if (id !== taskId) {
+                return { error: `Body id '${id}' must match taskId '${taskId}' for full replacement` };
+            }
+            const body = { id, 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;
+            if (deleted !== undefined)
+                body.deleted = deleted;
+            if (etag !== undefined)
+                body.etag = etag;
+            const result = await tasksApiRequest(googleTasksToken, `/lists/${taskListId}/tasks/${taskId}`, {
+                method: 'PUT',
+                body,
+            });
+            if (!result.ok) {
+                return { error: 'Failed to fully update task', details: result.error };
+            }
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error fully updating task',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=update-task-full.js.map

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

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

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

@@ -0,0 +1,31 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { tasksApiRequest } from './utils.js';
+export const updateTaskList = tool({
+    description: 'Renames an existing task list. Use PATCH semantics — only the title is updated.',
+    inputSchema: z.object({
+        googleTasksToken: z.string().describe('The Google Tasks access token'),
+        taskListId: z.string().describe('The ID of the task list to update'),
+        title: z.string().describe('New title for the task list'),
+    }),
+    execute: async ({ googleTasksToken, taskListId, title }) => {
+        try {
+            const result = await tasksApiRequest(googleTasksToken, `/users/@me/lists/${taskListId}`, {
+                method: 'PATCH',
+                body: { title },
+            });
+            if (!result.ok) {
+                return { error: 'Failed to update task list', details: result.error };
+            }
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error updating task list',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=update-task-list.js.map

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

@@ -0,0 +1,11 @@
+export declare const updateTask: 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>;
+//# sourceMappingURL=update-task.d.ts.map

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

@@ -0,0 +1,47 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { tasksApiRequest } from './utils.js';
+export const updateTask = tool({
+    description: 'Updates a task title, notes, due date, or status. Use to rename, reschedule, complete (status completed), or reopen (status needsAction) a task. Only provided fields are changed.',
+    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 update'),
+        title: z.string().optional().describe('New title for the task'),
+        notes: z.string().optional().describe('New notes for the task'),
+        due: z.string().optional().describe('New 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('Set completed to finish, needsAction to reopen'),
+    }),
+    execute: async ({ googleTasksToken, taskListId, taskId, title, notes, due, completed, status }) => {
+        try {
+            const body = {};
+            if (title !== undefined)
+                body.title = 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/${taskId}`, {
+                method: 'PATCH',
+                body,
+            });
+            if (!result.ok) {
+                return { error: 'Failed to update task', details: result.error };
+            }
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error updating task',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=update-task.js.map

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

@@ -0,0 +1,15 @@
+export declare const TASKS_API_BASE = "https://tasks.googleapis.com/tasks/v1";
+export declare function tasksApiRequest(googleTasksToken: string, path: string, options?: {
+    method?: string;
+    body?: Record<string, unknown>;
+    searchParams?: Record<string, string | number | boolean | undefined>;
+}): Promise<{
+    ok: false;
+    error: any;
+    data?: undefined;
+} | {
+    ok: true;
+    data: any;
+    error?: undefined;
+}>;
+//# sourceMappingURL=utils.d.ts.map

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

@@ -0,0 +1,33 @@
+// @ts-nocheck
+export const TASKS_API_BASE = 'https://tasks.googleapis.com/tasks/v1';
+export async function tasksApiRequest(googleTasksToken, path, options) {
+    const url = new URL(`${TASKS_API_BASE}${path}`);
+    if (options?.searchParams) {
+        for (const [key, value] of Object.entries(options.searchParams)) {
+            if (value !== undefined) {
+                url.searchParams.set(key, String(value));
+            }
+        }
+    }
+    const fetchOptions = {
+        method: options?.method ?? 'GET',
+        headers: {
+            Authorization: `Bearer ${googleTasksToken}`,
+            ...(options?.body ? { 'Content-Type': 'application/json' } : {}),
+        },
+    };
+    if (options?.body) {
+        fetchOptions.body = JSON.stringify(options.body);
+    }
+    const response = await fetch(url.toString(), fetchOptions);
+    if (!response.ok) {
+        const error = await response.json().catch(() => ({}));
+        return { ok: false, error };
+    }
+    if (response.status === 204) {
+        return { ok: true, data: { success: true } };
+    }
+    const data = await response.json();
+    return { ok: true, data };
+}
+//# sourceMappingURL=utils.js.map

package/dist/toolkits/grafana/icon.d.ts

@@ -0,0 +1,5 @@
+export declare const GRAFANA_ICON: {
+    kind: "svg";
+    dataUri: string;
+};
+//# sourceMappingURL=icon.d.ts.map