@rnsk/toolkits 0.0.6 → 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-forms/icon.d.ts

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

package/dist/toolkits/google-forms/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"><rect width="102" height="50" x="70" y="121" fill="#969dff" rx="25"/><rect width="50" height="50" x="20" y="121" fill="#b8c0ff" rx="25"/><rect width="50" height="50" x="20" y="71" fill="#5746e3" rx="25"/><rect width="102" height="50" x="70" y="71" fill="#5746e3" rx="25"/><mask id="a" width="102" height="50" x="70" y="21" maskUnits="userSpaceOnUse" style="mask-type:alpha"><rect width="102" height="50" x="70" y="21" fill="#5f54f4" rx="25"/></mask><g mask="url(#a)"><rect width="102" height="50" x="70" y="21" fill="#7372fe" rx="25"/><g filter="url(#b)"><circle cx="56" cy="46" r="36" fill="#64afff"/></g></g><rect width="50" height="50" x="20" y="21" fill="#7372fe" rx="25"/><path stroke="#fff" stroke-linecap="round" stroke-width="12" d="M95 46h52"/><circle cx="45" cy="46" r="12" fill="#fff"/><defs><filter id="b" width="111.47" height="111.47" x=".27" y="-9.74" color-interpolation-filters="sRGB" filterUnits="userSpaceOnUse"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur result="effect1_foregroundBlur_37586_9489" stdDeviation="9.87"/></filter></defs></svg>`;
+export const GFORMS_ICON = {
+    kind: 'svg',
+    dataUri: `data:image/svg+xml;base64,${Buffer.from(SVG).toString('base64')}`,
+};
+//# sourceMappingURL=icon.js.map

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

@@ -0,0 +1,43 @@
+import { defineToolkit, defineTool } from '../../core/define.js';
+import { inferToolScope } from '../../core/scope.js';
+import { GFORMS_ICON } from './icon.js';
+import { googleFormsTools } from './tools/index.js';
+export default defineToolkit({
+    id: 'google-forms',
+    displayName: 'Google Forms',
+    shortDescription: 'Create, read, update, and manage Google Forms and their responses.',
+    category: 'Document & File Management',
+    icon: GFORMS_ICON,
+    auth: {
+        type: 'oauth2',
+        tokenField: 'googleFormsToken',
+        provider: {
+            slug: 'google-forms',
+            env: { clientId: 'GOOGLE_FORMS_CLIENT_ID', clientSecret: 'GOOGLE_FORMS_CLIENT_SECRET' },
+            authorizeUrl: 'https://accounts.google.com/o/oauth2/v2/auth',
+            tokenUrl: 'https://oauth2.googleapis.com/token',
+            scopes: [
+                'https://www.googleapis.com/auth/drive',
+                'https://www.googleapis.com/auth/drive.file',
+                'https://www.googleapis.com/auth/forms.body',
+                'https://www.googleapis.com/auth/forms.body.readonly',
+                'https://www.googleapis.com/auth/forms.responses.readonly',
+            ],
+            exchangeStyle: 'form',
+            extraAuthParams: { access_type: 'offline', prompt: 'consent' },
+            connectDescription: 'Connect Google Forms to create forms, manage questions, and read responses.',
+            callbackPath: '/api/auth/google-forms/callback',
+            stateCookie: 'google_forms_oauth_state',
+        },
+    },
+    allowedHosts: ['forms.googleapis.com', 'www.googleapis.com'],
+    tools: googleFormsTools.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.6' },
+});
+//# sourceMappingURL=manifest.js.map

package/dist/toolkits/google-forms/tools/batch-update-form.d.ts

@@ -0,0 +1,11 @@
+export declare const batchUpdateForm: import("ai").Tool<{
+    googleFormsToken: string;
+    formId: string;
+    requests: Record<string, any>[];
+    writeControl?: {
+        targetRevisionId?: string | undefined;
+        requiredRevisionId?: string | undefined;
+    } | undefined;
+    includeFormInResponse?: boolean | undefined;
+}, any>;
+//# sourceMappingURL=batch-update-form.d.ts.map

package/dist/toolkits/google-forms/tools/batch-update-form.js

@@ -0,0 +1,49 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { formsApiRequest } from './utils.js';
+export const batchUpdateForm = tool({
+    description: 'Applies a batch of update operations to a Google Form in a single atomic transaction. Use to add, update, or delete questions, modify form metadata, update settings, or reorganize items.',
+    inputSchema: z.object({
+        googleFormsToken: z.string().describe('The Google Forms access token'),
+        formId: z.string().describe('The ID of the form to update'),
+        requests: z
+            .array(z.record(z.any()))
+            .describe('Update requests to apply. Each request contains one operation such as createItem, updateFormInfo, updateSettings, updateItem, moveItem, or deleteItem.'),
+        writeControl: z
+            .object({
+            targetRevisionId: z.string().optional(),
+            requiredRevisionId: z.string().optional(),
+        })
+            .optional()
+            .describe('Optional write control for optimistic concurrency'),
+        includeFormInResponse: z
+            .boolean()
+            .optional()
+            .describe('Whether to return the updated form in the response'),
+    }),
+    execute: async ({ googleFormsToken, formId, requests, writeControl, includeFormInResponse }) => {
+        try {
+            const body = { requests };
+            if (writeControl)
+                body.writeControl = writeControl;
+            if (includeFormInResponse !== undefined)
+                body.includeFormInResponse = includeFormInResponse;
+            const result = await formsApiRequest(googleFormsToken, `/forms/${formId}:batchUpdate`, {
+                method: 'POST',
+                body,
+            });
+            if (!result.ok) {
+                return { error: 'Failed to batch update form', details: result.error };
+            }
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error batch updating form',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=batch-update-form.js.map

package/dist/toolkits/google-forms/tools/create-form.d.ts

@@ -0,0 +1,8 @@
+export declare const createForm: import("ai").Tool<{
+    title: string;
+    googleFormsToken: string;
+    description?: string | undefined;
+    documentTitle?: string | undefined;
+    unpublished?: boolean | undefined;
+}, any>;
+//# sourceMappingURL=create-form.d.ts.map

package/dist/toolkits/google-forms/tools/create-form.js

@@ -0,0 +1,44 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { formsApiRequest } from './utils.js';
+export const createForm = tool({
+    description: 'Creates a new Google Form with the specified title. After creation, use batchUpdate to add questions and other items.',
+    inputSchema: z.object({
+        googleFormsToken: z.string().describe('The Google Forms access token'),
+        title: z.string().describe('The visible title of the form shown to respondents'),
+        description: z.string().optional().describe('Optional description text displayed with the form title'),
+        documentTitle: z.string().optional().describe('Optional Drive-visible document title'),
+        unpublished: z
+            .boolean()
+            .optional()
+            .describe('Whether the form is unpublished and does not accept responses'),
+    }),
+    execute: async ({ googleFormsToken, title, description, documentTitle, unpublished }) => {
+        try {
+            const info = { title };
+            if (description)
+                info.description = description;
+            if (documentTitle)
+                info.documentTitle = documentTitle;
+            const body = { info };
+            if (unpublished !== undefined)
+                body.unpublished = unpublished;
+            const result = await formsApiRequest(googleFormsToken, '/forms', {
+                method: 'POST',
+                body,
+            });
+            if (!result.ok) {
+                return { error: 'Failed to create form', details: result.error };
+            }
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error creating form',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=create-form.js.map

package/dist/toolkits/google-forms/tools/create-watch.d.ts

@@ -0,0 +1,8 @@
+export declare const createWatch: import("ai").Tool<{
+    googleFormsToken: string;
+    formId: string;
+    eventType: "EVENT_TYPE_UNSPECIFIED" | "SCHEMA" | "RESPONSES";
+    topicName: string;
+    watchId?: string | undefined;
+}, any>;
+//# sourceMappingURL=create-watch.d.ts.map

package/dist/toolkits/google-forms/tools/create-watch.js

@@ -0,0 +1,48 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { formsApiRequest } from './utils.js';
+export const createWatch = tool({
+    description: 'Creates a watch on a Google Form to receive push notifications via Cloud Pub/Sub when form schema or responses change.',
+    inputSchema: z.object({
+        googleFormsToken: z.string().describe('The Google Forms access token'),
+        formId: z.string().describe('The ID of the form to watch'),
+        eventType: z
+            .enum(['EVENT_TYPE_UNSPECIFIED', 'SCHEMA', 'RESPONSES'])
+            .describe('Type of event to watch for: SCHEMA or RESPONSES'),
+        topicName: z
+            .string()
+            .describe('Fully qualified Cloud Pub/Sub topic name, e.g. projects/my-project/topics/my-topic'),
+        watchId: z
+            .string()
+            .optional()
+            .describe('Optional unique ID to assign to this watch (4-63 characters)'),
+    }),
+    execute: async ({ googleFormsToken, formId, eventType, topicName, watchId }) => {
+        try {
+            const body = {
+                eventType,
+                target: {
+                    topic: { topicName },
+                },
+            };
+            if (watchId)
+                body.watchId = watchId;
+            const result = await formsApiRequest(googleFormsToken, `/forms/${formId}/watches`, {
+                method: 'POST',
+                body,
+            });
+            if (!result.ok) {
+                return { error: 'Failed to create form watch', details: result.error };
+            }
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error creating form watch',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=create-watch.js.map

package/dist/toolkits/google-forms/tools/delete-watch.d.ts

@@ -0,0 +1,21 @@
+export declare const deleteWatch: import("ai").Tool<{
+    googleFormsToken: string;
+    formId: string;
+    watchId: string;
+}, {
+    error: string;
+    details: any;
+    success?: undefined;
+    message?: undefined;
+} | {
+    success: boolean;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    success?: undefined;
+}>;
+//# sourceMappingURL=delete-watch.d.ts.map

package/dist/toolkits/google-forms/tools/delete-watch.js

@@ -0,0 +1,28 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { formsApiRequest } from './utils.js';
+export const deleteWatch = tool({
+    description: 'Deletes a watch from a Google Form, stopping push notifications for that watch.',
+    inputSchema: z.object({
+        googleFormsToken: z.string().describe('The Google Forms access token'),
+        formId: z.string().describe('The ID of the form that contains the watch'),
+        watchId: z.string().describe('The ID of the watch to delete'),
+    }),
+    execute: async ({ googleFormsToken, formId, watchId }) => {
+        try {
+            const result = await formsApiRequest(googleFormsToken, `/forms/${formId}/watches/${watchId}`, { method: 'DELETE' });
+            if (!result.ok) {
+                return { error: 'Failed to delete form watch', details: result.error };
+            }
+            return { success: true };
+        }
+        catch (error) {
+            return {
+                error: 'Error deleting form watch',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=delete-watch.js.map

package/dist/toolkits/google-forms/tools/get-form.d.ts

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

package/dist/toolkits/google-forms/tools/get-form.js

@@ -0,0 +1,27 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { formsApiRequest } from './utils.js';
+export const getForm = tool({
+    description: 'Retrieves the complete structure and metadata of a Google Form including title, description, items, settings, and publishing state.',
+    inputSchema: z.object({
+        googleFormsToken: z.string().describe('The Google Forms access token'),
+        formId: z.string().describe('The unique ID of the form to retrieve'),
+    }),
+    execute: async ({ googleFormsToken, formId }) => {
+        try {
+            const result = await formsApiRequest(googleFormsToken, `/forms/${formId}`);
+            if (!result.ok) {
+                return { error: 'Failed to get form', details: result.error };
+            }
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error getting form',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=get-form.js.map

package/dist/toolkits/google-forms/tools/get-response.d.ts

@@ -0,0 +1,6 @@
+export declare const getResponse: import("ai").Tool<{
+    googleFormsToken: string;
+    formId: string;
+    responseId: string;
+}, any>;
+//# sourceMappingURL=get-response.d.ts.map