@rnsk/toolkits 0.0.6 → 0.0.7

package/dist/toolkits/gmail/tools/get-attachment.js

@@ -0,0 +1,41 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+export const getAttachment = tool({
+    description: 'Retrieve a Gmail message attachment by message ID and attachment ID.',
+    inputSchema: z.object({
+        gmailToken: z.string().optional().describe('Injected by system; do not provide'),
+        messageId: z.string().describe('The message ID containing the attachment'),
+        attachmentId: z.string().describe('The attachment ID from the message payload part'),
+        fileName: z.string().optional().describe('Optional filename to include in the response'),
+    }),
+    execute: async ({ gmailToken, messageId, attachmentId, fileName }) => {
+        try {
+            const response = await fetch(`https://gmail.googleapis.com/gmail/v1/users/me/messages/${messageId}/attachments/${attachmentId}`, {
+                headers: {
+                    Authorization: `Bearer ${gmailToken}`,
+                },
+            });
+            if (!response.ok) {
+                const error = await response.json();
+                return { error: 'Failed to get attachment', details: error };
+            }
+            const data = await response.json();
+            return {
+                success: true,
+                messageId,
+                attachmentId,
+                fileName,
+                size: data.size,
+                data: data.data,
+                encoding: 'base64url',
+            };
+        }
+        catch (error) {
+            return {
+                error: 'Error getting attachment',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=get-attachment.js.map

package/dist/toolkits/gmail/tools/get-auto-forwarding.d.ts

@@ -0,0 +1,22 @@
+export declare const getAutoForwarding: import("ai").Tool<{
+    gmailToken?: string | undefined;
+}, {
+    error: string;
+    details: any;
+    success?: undefined;
+    autoForwarding?: undefined;
+    message?: undefined;
+} | {
+    success: boolean;
+    autoForwarding: any;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    success?: undefined;
+    autoForwarding?: undefined;
+}>;
+//# sourceMappingURL=get-auto-forwarding.d.ts.map

package/dist/toolkits/gmail/tools/get-auto-forwarding.js

@@ -0,0 +1,30 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+export const getAutoForwarding = tool({
+    description: 'Get Gmail auto-forwarding settings for the authenticated mailbox.',
+    inputSchema: z.object({
+        gmailToken: z.string().optional().describe('Injected by system; do not provide'),
+    }),
+    execute: async ({ gmailToken }) => {
+        try {
+            const response = await fetch('https://gmail.googleapis.com/gmail/v1/users/me/settings/autoForwarding', {
+                headers: {
+                    Authorization: `Bearer ${gmailToken}`,
+                },
+            });
+            if (!response.ok) {
+                const error = await response.json();
+                return { error: 'Failed to get auto-forwarding settings', details: error };
+            }
+            const data = await response.json();
+            return { success: true, autoForwarding: data };
+        }
+        catch (error) {
+            return {
+                error: 'Error getting auto-forwarding settings',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=get-auto-forwarding.js.map

package/dist/toolkits/gmail/tools/get-contacts.d.ts

@@ -0,0 +1,8 @@
+export declare const getContacts: import("ai").Tool<{
+    personFields: string;
+    includeOtherContacts: boolean;
+    gmailToken?: string | undefined;
+    pageToken?: string | undefined;
+    resourceName?: string | undefined;
+}, any>;
+//# sourceMappingURL=get-contacts.d.ts.map

package/dist/toolkits/gmail/tools/get-contacts.js

@@ -0,0 +1,50 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+export const getContacts = tool({
+    description: 'Fetch Google contacts for the authenticated account using the People API.',
+    inputSchema: z.object({
+        gmailToken: z.string().optional().describe('Injected by system; do not provide'),
+        resourceName: z.string().optional().describe('Optional contact resource name to fetch, e.g. people/c123'),
+        personFields: z.string().optional().default('names,emailAddresses,phoneNumbers,organizations').describe('Comma-separated person fields to return'),
+        pageToken: z.string().optional().describe('Pagination token for connection lists'),
+        includeOtherContacts: z.boolean().optional().default(false).describe('Whether to fetch Other Contacts instead of saved contacts'),
+    }),
+    execute: async ({ gmailToken, resourceName, personFields, pageToken, includeOtherContacts }) => {
+        try {
+            let url;
+            if (resourceName) {
+                url = new URL(`https://people.googleapis.com/v1/${resourceName}`);
+                url.searchParams.append('personFields', personFields);
+            }
+            else if (includeOtherContacts) {
+                url = new URL('https://people.googleapis.com/v1/otherContacts');
+                url.searchParams.append('readMask', personFields);
+            }
+            else {
+                url = new URL('https://people.googleapis.com/v1/people/me/connections');
+                url.searchParams.append('personFields', personFields);
+            }
+            if (pageToken && !resourceName) {
+                url.searchParams.append('pageToken', pageToken);
+            }
+            const response = await fetch(url.toString(), {
+                headers: {
+                    Authorization: `Bearer ${gmailToken}`,
+                },
+            });
+            if (!response.ok) {
+                const error = await response.json();
+                return { error: 'Failed to get contacts', details: error };
+            }
+            const data = await response.json();
+            return { success: true, ...data };
+        }
+        catch (error) {
+            return {
+                error: 'Error getting contacts',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=get-contacts.js.map

package/dist/toolkits/gmail/tools/get-filter.d.ts

@@ -0,0 +1,23 @@
+export declare const getFilter: import("ai").Tool<{
+    id: string;
+    gmailToken?: string | undefined;
+}, {
+    error: string;
+    details: any;
+    success?: undefined;
+    filter?: undefined;
+    message?: undefined;
+} | {
+    success: boolean;
+    filter: any;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    success?: undefined;
+    filter?: undefined;
+}>;
+//# sourceMappingURL=get-filter.d.ts.map

package/dist/toolkits/gmail/tools/get-filter.js

@@ -0,0 +1,31 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+export const getFilter = tool({
+    description: 'Retrieve a Gmail filter by ID.',
+    inputSchema: z.object({
+        gmailToken: z.string().optional().describe('Injected by system; do not provide'),
+        id: z.string().describe('The filter ID to retrieve'),
+    }),
+    execute: async ({ gmailToken, id }) => {
+        try {
+            const response = await fetch(`https://gmail.googleapis.com/gmail/v1/users/me/settings/filters/${id}`, {
+                headers: {
+                    Authorization: `Bearer ${gmailToken}`,
+                },
+            });
+            if (!response.ok) {
+                const error = await response.json();
+                return { error: 'Failed to get filter', details: error };
+            }
+            const data = await response.json();
+            return { success: true, filter: data };
+        }
+        catch (error) {
+            return {
+                error: 'Error getting filter',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=get-filter.js.map

package/dist/toolkits/gmail/tools/index.d.ts

@@ -14,4 +14,17 @@ export * from './list-labels.js';
 export * from './modify-message-labels.js';
 export * from './trash-message.js';
 export * from './untrash-message.js';
+export * from './batch-delete-messages.js';
+export * from './batch-modify-messages.js';
+export * from './create-filter.js';
+export * from './create-label.js';
+export * from './delete-filter.js';
+export * from './delete-label.js';
+export * from './delete-message.js';
+export * from './delete-thread.js';
+export * from './forward-message.js';
+export * from './get-attachment.js';
+export * from './get-auto-forwarding.js';
+export * from './get-contacts.js';
+export * from './get-filter.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/toolkits/gmail/tools/index.js

@@ -14,4 +14,17 @@ export * from './list-labels.js';
 export * from './modify-message-labels.js';
 export * from './trash-message.js';
 export * from './untrash-message.js';
+export * from './batch-delete-messages.js';
+export * from './batch-modify-messages.js';
+export * from './create-filter.js';
+export * from './create-label.js';
+export * from './delete-filter.js';
+export * from './delete-label.js';
+export * from './delete-message.js';
+export * from './delete-thread.js';
+export * from './forward-message.js';
+export * from './get-attachment.js';
+export * from './get-auto-forwarding.js';
+export * from './get-contacts.js';
+export * from './get-filter.js';
 //# sourceMappingURL=index.js.map

package/dist/toolkits/gmail/tools/utils.d.ts

@@ -38,4 +38,27 @@ export declare function extractMessageDetails(data: any, maxBodyLength?: number)
     messageIdHeader: any;
     body: string;
 } | null;
+export declare function encodeBase64Mime(data: string): string;
+export declare function chunkBase64(data: string): string;
+export declare function getHeaderValue(headers: Array<{
+    name?: string;
+    value?: string;
+}> | undefined, name: string): string | undefined;
+export declare function collectAttachments(payload: any): Array<{
+    attachmentId: string;
+    filename: string;
+    mimeType: string;
+}>;
+export declare function encodeMultipartMessage(params: {
+    to: string;
+    subject: string;
+    body: string;
+    cc?: string;
+    bcc?: string;
+    attachments?: Array<{
+        filename: string;
+        mimeType: string;
+        data: string;
+    }>;
+}): string;
 //# sourceMappingURL=utils.d.ts.map

package/dist/toolkits/gmail/tools/utils.js

@@ -94,4 +94,55 @@ export function extractMessageDetails(data, maxBodyLength = 4000) {
         body,
     };
 }
+export function encodeBase64Mime(data) {
+    return data.replace(/-/g, '+').replace(/_/g, '/').replace(/\s/g, '');
+}
+export function chunkBase64(data) {
+    return data.match(/.{1,76}/g)?.join('\r\n') || data;
+}
+export function getHeaderValue(headers, name) {
+    return headers?.find((header) => header.name?.toLowerCase() === name.toLowerCase())?.value;
+}
+export function collectAttachments(payload) {
+    const attachments = [];
+    const walk = (part) => {
+        const attachmentId = part?.body?.attachmentId;
+        const filename = part?.filename;
+        if (attachmentId && filename) {
+            attachments.push({
+                attachmentId,
+                filename,
+                mimeType: part.mimeType || 'application/octet-stream',
+            });
+        }
+        for (const child of part?.parts || []) {
+            walk(child);
+        }
+    };
+    walk(payload);
+    return attachments;
+}
+export function encodeMultipartMessage(params) {
+    const boundary = `rnsk-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+    const headers = [
+        `To: ${params.to}`,
+        params.cc ? `Cc: ${params.cc}` : '',
+        params.bcc ? `Bcc: ${params.bcc}` : '',
+        `Subject: ${params.subject}`,
+        'MIME-Version: 1.0',
+        `Content-Type: multipart/mixed; boundary="${boundary}"`,
+    ].filter(Boolean);
+    const parts = [
+        `--${boundary}`,
+        'Content-Type: text/plain; charset="UTF-8"',
+        'Content-Transfer-Encoding: 7bit',
+        '',
+        params.body,
+    ];
+    for (const attachment of params.attachments || []) {
+        parts.push(`--${boundary}`, `Content-Type: ${attachment.mimeType}; name="${attachment.filename}"`, 'Content-Transfer-Encoding: base64', `Content-Disposition: attachment; filename="${attachment.filename}"`, '', chunkBase64(encodeBase64Mime(attachment.data)));
+    }
+    parts.push(`--${boundary}--`);
+    return encodeBase64Url([...headers, '', ...parts].join('\r\n'));
+}
 //# sourceMappingURL=utils.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