@rnsk/toolkits 0.0.7 → 0.0.8

package/dist/toolkits/google-classroom/tools/roster.js

@@ -0,0 +1,180 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { classroomRequest, googleClassroomTokenField } from './client.js';
+export const addStudentToCourse = tool({
+    description: 'Enrolls a user as a student. Admins enroll directly; others need the enrollment code.',
+    inputSchema: z.object({
+        googleClassroomToken: googleClassroomTokenField,
+        courseId: z.string().describe('Course ID or alias'),
+        userId: z.string().describe("User ID, email, or 'me'"),
+        enrollmentCode: z.string().optional().describe('Required for self-enrollment'),
+    }),
+    execute: async ({ googleClassroomToken, courseId, userId, enrollmentCode }) => {
+        try {
+            const body = { userId };
+            if (enrollmentCode)
+                body.enrollmentCode = enrollmentCode;
+            const result = await classroomRequest(googleClassroomToken, `/courses/${courseId}/students`, {
+                method: 'POST',
+                body,
+            });
+            if (!result.ok)
+                return { error: 'Failed to add student', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error adding student', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const deleteCourseStudent = tool({
+    description: 'Removes a student enrollment, revoking access to materials and participation.',
+    inputSchema: z.object({
+        googleClassroomToken: googleClassroomTokenField,
+        courseId: z.string().describe('Course ID or alias'),
+        userId: z.string().describe("Student ID, email, or 'me'"),
+    }),
+    execute: async ({ googleClassroomToken, courseId, userId }) => {
+        try {
+            const result = await classroomRequest(googleClassroomToken, `/courses/${courseId}/students/${userId}`, {
+                method: 'DELETE',
+            });
+            if (!result.ok)
+                return { error: 'Failed to delete student', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error deleting student', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const getCourseStudent = tool({
+    description: 'Gets a student enrollment with profile and Drive folder details.',
+    inputSchema: z.object({
+        googleClassroomToken: googleClassroomTokenField,
+        courseId: z.string().describe('Course ID or alias'),
+        userId: z.string().describe("Student ID, email, or 'me'"),
+    }),
+    execute: async ({ googleClassroomToken, courseId, userId }) => {
+        try {
+            const result = await classroomRequest(googleClassroomToken, `/courses/${courseId}/students/${userId}`);
+            if (!result.ok)
+                return { error: 'Failed to get student', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error getting student', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const listCourseStudents = tool({
+    description: 'Pages through enrolled students in a course.',
+    inputSchema: z.object({
+        googleClassroomToken: googleClassroomTokenField,
+        courseId: z.string().describe('Course ID or alias'),
+        pageSize: z.number().min(1).max(100).optional(),
+        pageToken: z.string().optional(),
+    }),
+    execute: async ({ googleClassroomToken, courseId, pageSize, pageToken }) => {
+        try {
+            const result = await classroomRequest(googleClassroomToken, `/courses/${courseId}/students`, {
+                query: { pageSize, pageToken },
+            });
+            if (!result.ok)
+                return { error: 'Failed to list students', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error listing students', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const listStudentGuardians = tool({
+    description: 'Lists guardians linked to a student in a course, with pagination.',
+    inputSchema: z.object({
+        googleClassroomToken: googleClassroomTokenField,
+        courseId: z.string().describe('Course ID or alias'),
+        studentId: z.string().describe("Student ID, email, or 'me'"),
+        pageSize: z.number().min(1).max(100).optional(),
+        pageToken: z.string().optional(),
+    }),
+    execute: async ({ googleClassroomToken, courseId, studentId, pageSize, pageToken }) => {
+        try {
+            const result = await classroomRequest(googleClassroomToken, `/courses/${courseId}/students/${studentId}/guardians`, { query: { pageSize, pageToken } });
+            if (!result.ok)
+                return { error: 'Failed to list student guardians', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error listing student guardians', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const deleteCourseTeacher = tool({
+    description: 'Removes a teacher enrollment, revoking teaching access. The course owner cannot be removed this way.',
+    inputSchema: z.object({
+        googleClassroomToken: googleClassroomTokenField,
+        courseId: z.string().describe('Course ID or alias'),
+        userId: z.string().describe("Teacher ID, email, or 'me'"),
+    }),
+    execute: async ({ googleClassroomToken, courseId, userId }) => {
+        try {
+            const result = await classroomRequest(googleClassroomToken, `/courses/${courseId}/teachers/${userId}`, {
+                method: 'DELETE',
+            });
+            if (!result.ok)
+                return { error: 'Failed to delete teacher', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error deleting teacher', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const getTeacher = tool({
+    description: 'Gets a teacher enrollment with profile details.',
+    inputSchema: z.object({
+        googleClassroomToken: googleClassroomTokenField,
+        courseId: z.string().describe('Course ID or alias'),
+        userId: z.string().describe('Teacher ID or email'),
+        fields: z.string().optional().describe('Partial-response field selector'),
+        quotaUser: z.string().optional().describe('Quota attribution string (server-side apps)'),
+    }),
+    execute: async ({ googleClassroomToken, courseId, userId, fields, quotaUser }) => {
+        try {
+            const result = await classroomRequest(googleClassroomToken, `/courses/${courseId}/teachers/${userId}`, {
+                query: { fields, quotaUser },
+            });
+            if (!result.ok)
+                return { error: 'Failed to get teacher', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error getting teacher', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const listCourseTeachers = tool({
+    description: 'Pages through enrolled teachers in a course.',
+    inputSchema: z.object({
+        googleClassroomToken: googleClassroomTokenField,
+        courseId: z.string(),
+        pageSize: z.number().min(1).max(100).optional(),
+        pageToken: z.string().optional(),
+    }),
+    execute: async ({ googleClassroomToken, courseId, pageSize, pageToken }) => {
+        try {
+            const result = await classroomRequest(googleClassroomToken, `/courses/${courseId}/teachers`, {
+                query: { pageSize, pageToken },
+            });
+            if (!result.ok)
+                return { error: 'Failed to list teachers', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error listing teachers', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=roster.js.map

package/dist/toolkits/google-classroom/tools/topics.d.ts

@@ -0,0 +1,29 @@
+export declare const createCourseTopic: import("ai").Tool<{
+    name: string;
+    googleClassroomToken: string;
+    courseId: string;
+}, any>;
+export declare const deleteCourseTopic: import("ai").Tool<{
+    id: string;
+    googleClassroomToken: string;
+    courseId: string;
+}, any>;
+export declare const getCourseTopic: import("ai").Tool<{
+    id: string;
+    googleClassroomToken: string;
+    courseId: string;
+}, any>;
+export declare const listCourseTopics: import("ai").Tool<{
+    googleClassroomToken: string;
+    courseId: string;
+    pageToken?: string | undefined;
+    pageSize?: number | undefined;
+}, any>;
+export declare const patchCourseTopic: import("ai").Tool<{
+    id: string;
+    googleClassroomToken: string;
+    courseId: string;
+    name?: string | undefined;
+    updateMask?: string | undefined;
+}, any>;
+//# sourceMappingURL=topics.d.ts.map

package/dist/toolkits/google-classroom/tools/topics.js

@@ -0,0 +1,117 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { classroomRequest, googleClassroomTokenField } from './client.js';
+export const createCourseTopic = tool({
+    description: 'Creates a named topic section to organize course content.',
+    inputSchema: z.object({
+        googleClassroomToken: googleClassroomTokenField,
+        courseId: z.string(),
+        name: z.string().describe('Topic name, e.g. Homework'),
+    }),
+    execute: async ({ googleClassroomToken, courseId, name }) => {
+        try {
+            const result = await classroomRequest(googleClassroomToken, `/courses/${courseId}/topics`, {
+                method: 'POST',
+                body: { name },
+            });
+            if (!result.ok)
+                return { error: 'Failed to create topic', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error creating topic', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const deleteCourseTopic = tool({
+    description: 'Deletes a topic. Confirm course and topic IDs first.',
+    inputSchema: z.object({
+        googleClassroomToken: googleClassroomTokenField,
+        courseId: z.string(),
+        id: z.string().describe('Topic ID to delete'),
+    }),
+    execute: async ({ googleClassroomToken, courseId, id }) => {
+        try {
+            const result = await classroomRequest(googleClassroomToken, `/courses/${courseId}/topics/${id}`, {
+                method: 'DELETE',
+            });
+            if (!result.ok)
+                return { error: 'Failed to delete topic', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error deleting topic', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const getCourseTopic = tool({
+    description: 'Gets a topic by course and topic ID.',
+    inputSchema: z.object({
+        googleClassroomToken: googleClassroomTokenField,
+        courseId: z.string().describe('Course ID or alias'),
+        id: z.string().describe('Topic ID'),
+    }),
+    execute: async ({ googleClassroomToken, courseId, id }) => {
+        try {
+            const result = await classroomRequest(googleClassroomToken, `/courses/${courseId}/topics/${id}`);
+            if (!result.ok)
+                return { error: 'Failed to get topic', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error getting topic', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const listCourseTopics = tool({
+    description: 'Lists topics in a course with pagination.',
+    inputSchema: z.object({
+        googleClassroomToken: googleClassroomTokenField,
+        courseId: z.string().describe('Course ID or alias'),
+        pageSize: z.number().min(0).optional(),
+        pageToken: z.string().optional(),
+    }),
+    execute: async ({ googleClassroomToken, courseId, pageSize, pageToken }) => {
+        try {
+            const result = await classroomRequest(googleClassroomToken, `/courses/${courseId}/topics`, {
+                query: { pageSize, pageToken },
+            });
+            if (!result.ok)
+                return { error: 'Failed to list topics', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error listing topics', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+export const patchCourseTopic = tool({
+    description: "Renames a topic. Currently only 'name' is updatable via updateMask.",
+    inputSchema: z.object({
+        googleClassroomToken: googleClassroomTokenField,
+        courseId: z.string(),
+        id: z.string().describe('Topic ID'),
+        name: z.string().optional().describe('New topic name'),
+        updateMask: z.string().optional().describe("Fields to update, e.g. 'name'"),
+    }),
+    execute: async ({ googleClassroomToken, courseId, id, name, updateMask }) => {
+        try {
+            const body = {};
+            if (name !== undefined)
+                body.name = name;
+            const result = await classroomRequest(googleClassroomToken, `/courses/${courseId}/topics/${id}`, {
+                method: 'PATCH',
+                query: { updateMask: updateMask ?? 'name' },
+                body,
+            });
+            if (!result.ok)
+                return { error: 'Failed to patch topic', details: result.error };
+            return result.data;
+        }
+        catch (error) {
+            return { error: 'Error patching topic', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=topics.js.map

package/dist/toolkits/google-tasks/icon.d.ts

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

package/dist/toolkits/google-tasks/icon.js

@@ -0,0 +1,6 @@
+const SVG = `<svg xmlns="http://www.w3.org/2000/svg" width="192" height="192" fill="none" viewBox="0 0 192 192"><g clip-path="url(#a)"><rect width="152" height="130" x="20" y="52" fill="#bbe2ff" rx="65"/><rect width="172" height="152" x="10" y="14" fill="#3186ff" rx="74"/><mask id="d" width="172" height="152" x="10" y="14" maskUnits="userSpaceOnUse" style="mask-type:alpha"><rect width="172" height="152" x="10" y="14" fill="#3c90ff" rx="74"/></mask><g filter="url(#b)" mask="url(#d)"><rect width="152" height="130" x="20" y="52" fill="url(#e)" rx="65"/></g><g clip-path="url(#f)"><path stroke="#fff" stroke-linecap="round" stroke-linejoin="round" stroke-width="12" d="m61 90 22.172 22.172a4 4 0 0 0 5.656 0L138 63"/></g></g><defs><clipPath id="a"><path fill="#fff" d="M0 0h192v192H0z"/></clipPath><clipPath id="f"><path fill="#fff" d="M44 38h104v104H44z"/></clipPath><linearGradient id="e" x1="96" x2="100.64" y1="166.9" y2="67.25" gradientUnits="userSpaceOnUse"><stop offset=".01" stop-color="#a9a8ff"/><stop offset=".79" stop-color="#a9a8ff" stop-opacity="0"/></linearGradient><filter id="b" width="176" height="154" x="8" y="40" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_37601_9976" stdDeviation="6"/></filter></defs></svg>`;
+export const GTASKS_ICON = {
+    kind: 'svg',
+    dataUri: `data:image/svg+xml;base64,${Buffer.from(SVG).toString('base64')}`,
+};
+//# sourceMappingURL=icon.js.map

package/dist/toolkits/google-tasks/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-tasks/manifest.js

@@ -0,0 +1,40 @@
+import { defineToolkit, defineTool } from '../../core/define.js';
+import { inferToolScope } from '../../core/scope.js';
+import { GTASKS_ICON } from './icon.js';
+import { googleTasksTools } from './tools/index.js';
+export default defineToolkit({
+    id: 'google-tasks',
+    displayName: 'Google Tasks',
+    shortDescription: 'List, create, update, and organize Google Tasks lists and to-dos.',
+    category: 'Productivity & Project Management',
+    icon: GTASKS_ICON,
+    auth: {
+        type: 'oauth2',
+        tokenField: 'googleTasksToken',
+        provider: {
+            slug: 'google-tasks',
+            env: { clientId: 'GOOGLE_TASKS_CLIENT_ID', clientSecret: 'GOOGLE_TASKS_CLIENT_SECRET' },
+            authorizeUrl: 'https://accounts.google.com/o/oauth2/v2/auth',
+            tokenUrl: 'https://oauth2.googleapis.com/token',
+            scopes: [
+                'https://www.googleapis.com/auth/tasks',
+                'https://www.googleapis.com/auth/tasks.readonly',
+            ],
+            exchangeStyle: 'form',
+            extraAuthParams: { access_type: 'offline', prompt: 'consent' },
+            connectDescription: 'Connect Google Tasks to view lists, manage to-dos, and track due dates.',
+            callbackPath: '/api/auth/google-tasks/callback',
+            stateCookie: 'google_tasks_oauth_state',
+        },
+    },
+    allowedHosts: ['tasks.googleapis.com', 'www.googleapis.com'],
+    tools: googleTasksTools.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.7' },
+});
+//# sourceMappingURL=manifest.js.map

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