@rnsk/toolkits 0.0.5 → 0.0.7

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

@@ -0,0 +1,130 @@
+import { batchUpdateForm } from './batch-update-form.js';
+import { createForm } from './create-form.js';
+import { createWatch } from './create-watch.js';
+import { deleteWatch } from './delete-watch.js';
+import { getForm } from './get-form.js';
+import { getResponse } from './get-response.js';
+import { listResponses } from './list-responses.js';
+import { listWatches } from './list-watches.js';
+import { renewWatch } from './renew-watch.js';
+import { setPublishSettings } from './set-publish-settings.js';
+export { batchUpdateForm, createForm, createWatch, deleteWatch, getForm, getResponse, listResponses, listWatches, renewWatch, setPublishSettings, };
+export declare const googleFormsTools: ({
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        googleFormsToken: string;
+        formId: string;
+        requests: Record<string, any>[];
+        writeControl?: {
+            targetRevisionId?: string | undefined;
+            requiredRevisionId?: string | undefined;
+        } | undefined;
+        includeFormInResponse?: boolean | undefined;
+    }, any>;
+    requiredAuth: "googleFormsToken";
+    scope: "write";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        title: string;
+        googleFormsToken: string;
+        description?: string | undefined;
+        documentTitle?: string | undefined;
+        unpublished?: boolean | undefined;
+    }, any>;
+    requiredAuth: "googleFormsToken";
+    scope: "write";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        googleFormsToken: string;
+        formId: string;
+        eventType: "EVENT_TYPE_UNSPECIFIED" | "SCHEMA" | "RESPONSES";
+        topicName: string;
+        watchId?: string | undefined;
+    }, any>;
+    requiredAuth: "googleFormsToken";
+    scope: "write";
+} | {
+    name: string;
+    description: string;
+    tool: 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;
+    }>;
+    requiredAuth: "googleFormsToken";
+    scope: "delete";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        googleFormsToken: string;
+        formId: string;
+    }, any>;
+    requiredAuth: "googleFormsToken";
+    scope: "read";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        googleFormsToken: string;
+        formId: string;
+        responseId: string;
+    }, any>;
+    requiredAuth: "googleFormsToken";
+    scope: "read";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        googleFormsToken: string;
+        formId: string;
+        filter?: string | undefined;
+        pageToken?: string | undefined;
+        pageSize?: number | undefined;
+    }, any>;
+    requiredAuth: "googleFormsToken";
+    scope: "read";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        googleFormsToken: string;
+        formId: string;
+        watchId: string;
+    }, any>;
+    requiredAuth: "googleFormsToken";
+    scope: "write";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        googleFormsToken: string;
+        formId: string;
+        isPublished: boolean;
+        isAcceptingResponses: boolean;
+        updateMask?: string | undefined;
+    }, any>;
+    requiredAuth: "googleFormsToken";
+    scope: "write";
+})[];
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,85 @@
+// @ts-nocheck
+import { batchUpdateForm } from './batch-update-form.js';
+import { createForm } from './create-form.js';
+import { createWatch } from './create-watch.js';
+import { deleteWatch } from './delete-watch.js';
+import { getForm } from './get-form.js';
+import { getResponse } from './get-response.js';
+import { listResponses } from './list-responses.js';
+import { listWatches } from './list-watches.js';
+import { renewWatch } from './renew-watch.js';
+import { setPublishSettings } from './set-publish-settings.js';
+export { batchUpdateForm, createForm, createWatch, deleteWatch, getForm, getResponse, listResponses, listWatches, renewWatch, setPublishSettings, };
+export const googleFormsTools = [
+    {
+        name: 'googleFormsBatchUpdateForm',
+        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.',
+        tool: batchUpdateForm,
+        requiredAuth: 'googleFormsToken',
+        scope: 'write',
+    },
+    {
+        name: 'googleFormsCreateForm',
+        description: 'Creates a new Google Form with the specified title. After creation, use batchUpdate to add questions and other items.',
+        tool: createForm,
+        requiredAuth: 'googleFormsToken',
+        scope: 'write',
+    },
+    {
+        name: 'googleFormsCreateWatch',
+        description: 'Creates a watch on a Google Form to receive push notifications via Cloud Pub/Sub when form schema or responses change.',
+        tool: createWatch,
+        requiredAuth: 'googleFormsToken',
+        scope: 'write',
+    },
+    {
+        name: 'googleFormsDeleteWatch',
+        description: 'Deletes a watch from a Google Form, stopping push notifications for that watch.',
+        tool: deleteWatch,
+        requiredAuth: 'googleFormsToken',
+        scope: 'delete',
+    },
+    {
+        name: 'googleFormsGetForm',
+        description: 'Retrieves the complete structure and metadata of a Google Form including title, description, items, settings, and publishing state.',
+        tool: getForm,
+        requiredAuth: 'googleFormsToken',
+        scope: 'read',
+    },
+    {
+        name: 'googleFormsGetResponse',
+        description: 'Retrieves a single form response by its unique response ID, including all answers, timestamps, and quiz scores.',
+        tool: getResponse,
+        requiredAuth: 'googleFormsToken',
+        scope: 'read',
+    },
+    {
+        name: 'googleFormsListResponses',
+        description: 'Lists all responses submitted to a Google Form with optional filtering and pagination.',
+        tool: listResponses,
+        requiredAuth: 'googleFormsToken',
+        scope: 'read',
+    },
+    {
+        name: 'googleFormsListWatches',
+        description: 'Lists all watches owned by the calling project for a specific Google Form, including status and expiration times.',
+        tool: listWatches,
+        requiredAuth: 'googleFormsToken',
+        scope: 'read',
+    },
+    {
+        name: 'googleFormsRenewWatch',
+        description: 'Renews a watch on a Google Form, extending its expiration by one week from the time of renewal.',
+        tool: renewWatch,
+        requiredAuth: 'googleFormsToken',
+        scope: 'write',
+    },
+    {
+        name: 'googleFormsSetPublishSettings',
+        description: 'Updates the publishing settings of a Google Form, controlling visibility and whether it accepts responses.',
+        tool: setPublishSettings,
+        requiredAuth: 'googleFormsToken',
+        scope: 'write',
+    },
+];
+//# sourceMappingURL=index.js.map

package/dist/toolkits/google-forms/tools/list-responses.d.ts

@@ -0,0 +1,8 @@
+export declare const listResponses: import("ai").Tool<{
+    googleFormsToken: string;
+    formId: string;
+    filter?: string | undefined;
+    pageToken?: string | undefined;
+    pageSize?: number | undefined;
+}, any>;
+//# sourceMappingURL=list-responses.d.ts.map

package/dist/toolkits/google-forms/tools/list-responses.js

@@ -0,0 +1,44 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { formsApiRequest } from './utils.js';
+export const listResponses = tool({
+    description: 'Lists all responses submitted to a Google Form with optional filtering and pagination.',
+    inputSchema: z.object({
+        googleFormsToken: z.string().describe('The Google Forms access token'),
+        formId: z.string().describe('The ID of the form whose responses to list'),
+        filter: z
+            .string()
+            .optional()
+            .describe("Optional filter expression, e.g. timestamp > 2024-01-15T00:00:00Z"),
+        pageSize: z
+            .number()
+            .min(1)
+            .max(5000)
+            .optional()
+            .describe('Maximum number of responses to return (default 5000)'),
+        pageToken: z.string().optional().describe('Page token from a previous list response'),
+    }),
+    execute: async ({ googleFormsToken, formId, filter, pageSize, pageToken }) => {
+        try {
+            const result = await formsApiRequest(googleFormsToken, `/forms/${formId}/responses`, {
+                searchParams: {
+                    filter,
+                    pageSize,
+                    pageToken,
+                },
+            });
+            if (!result.ok) {
+                return { error: 'Failed to list form responses', details: result.error };
+            }
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error listing form responses',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=list-responses.js.map

package/dist/toolkits/google-forms/tools/list-watches.d.ts

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

package/dist/toolkits/google-forms/tools/list-watches.js

@@ -0,0 +1,27 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { formsApiRequest } from './utils.js';
+export const listWatches = tool({
+    description: 'Lists all watches owned by the calling project for a specific Google Form, including status and expiration times.',
+    inputSchema: z.object({
+        googleFormsToken: z.string().describe('The Google Forms access token'),
+        formId: z.string().describe('The ID of the form whose watches to list'),
+    }),
+    execute: async ({ googleFormsToken, formId }) => {
+        try {
+            const result = await formsApiRequest(googleFormsToken, `/forms/${formId}/watches`);
+            if (!result.ok) {
+                return { error: 'Failed to list form watches', details: result.error };
+            }
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error listing form watches',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=list-watches.js.map

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

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

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

@@ -0,0 +1,28 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { formsApiRequest } from './utils.js';
+export const renewWatch = tool({
+    description: 'Renews a watch on a Google Form, extending its expiration by one week from the time of renewal.',
+    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 renew'),
+    }),
+    execute: async ({ googleFormsToken, formId, watchId }) => {
+        try {
+            const result = await formsApiRequest(googleFormsToken, `/forms/${formId}/watches/${watchId}:renew`, { method: 'POST', body: {} });
+            if (!result.ok) {
+                return { error: 'Failed to renew form watch', details: result.error };
+            }
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error renewing form watch',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=renew-watch.js.map

package/dist/toolkits/google-forms/tools/set-publish-settings.d.ts

@@ -0,0 +1,8 @@
+export declare const setPublishSettings: import("ai").Tool<{
+    googleFormsToken: string;
+    formId: string;
+    isPublished: boolean;
+    isAcceptingResponses: boolean;
+    updateMask?: string | undefined;
+}, any>;
+//# sourceMappingURL=set-publish-settings.d.ts.map

package/dist/toolkits/google-forms/tools/set-publish-settings.js

@@ -0,0 +1,43 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { formsApiRequest } from './utils.js';
+export const setPublishSettings = tool({
+    description: 'Updates the publishing settings of a Google Form, controlling visibility and whether it accepts responses.',
+    inputSchema: z.object({
+        googleFormsToken: z.string().describe('The Google Forms access token'),
+        formId: z.string().describe('The ID of the form to update'),
+        isPublished: z.boolean().describe('Whether the form is published and visible to others'),
+        isAcceptingResponses: z.boolean().describe('Whether the form accepts responses'),
+        updateMask: z
+            .string()
+            .optional()
+            .describe("Optional fields to update, e.g. 'publishState' or '*' for all fields"),
+    }),
+    execute: async ({ googleFormsToken, formId, isPublished, isAcceptingResponses, updateMask }) => {
+        try {
+            const body = {
+                publishSettings: {
+                    publishState: {
+                        isPublished,
+                        isAcceptingResponses,
+                    },
+                },
+            };
+            if (updateMask)
+                body.updateMask = updateMask;
+            const result = await formsApiRequest(googleFormsToken, `/forms/${formId}:setPublishSettings`, { method: 'POST', body });
+            if (!result.ok) {
+                return { error: 'Failed to set form publish settings', details: result.error };
+            }
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error setting form publish settings',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=set-publish-settings.js.map

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

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

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

@@ -0,0 +1,33 @@
+// @ts-nocheck
+export const FORMS_API_BASE = 'https://forms.googleapis.com/v1';
+export async function formsApiRequest(googleFormsToken, path, options) {
+    const url = new URL(`${FORMS_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 ${googleFormsToken}`,
+            ...(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/google-meet/icon.d.ts

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

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

@@ -0,0 +1,153 @@
+const SVG = `<svg
+   width="176"
+   height="138"
+   fill="none"
+   viewBox="0 0 176 138"
+   version="1.1"
+   id="svg39"
+   sodipodi:docname="Google_Meet_icon_(2026).svg"
+   inkscape:version="1.2.2 (b0a8486541, 2022-12-01)"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:svg="http://www.w3.org/2000/svg">
+  <sodipodi:namedview
+     id="namedview41"
+     pagecolor="#ffffff"
+     bordercolor="#000000"
+     borderopacity="0.25"
+     inkscape:showpageshadow="2"
+     inkscape:pageopacity="0.0"
+     inkscape:pagecheckerboard="0"
+     inkscape:deskcolor="#d1d1d1"
+     showgrid="false"
+     inkscape:zoom="2.4791667"
+     inkscape:cx="97.411765"
+     inkscape:cy="96.403361"
+     inkscape:window-width="1366"
+     inkscape:window-height="683"
+     inkscape:window-x="0"
+     inkscape:window-y="0"
+     inkscape:window-maximized="1"
+     inkscape:current-layer="svg39" />
+  <path
+     fill="url(#a)"
+     d="M 102.015,81.88 C 95.186,77.162 95.094,67.102 101.836,62.26 L 157,22.643 c 7.94,-5.701 19,-0.038 19,9.737 v 77.755 c 0,9.675 -10.861,15.359 -18.821,9.859 z"
+     id="path2"
+     style="fill:url(#a)" />
+  <path
+     fill="url(#b)"
+     d="M 0,44 C 0,19.7 19.7,0 44,0 h 64 c 11.046,0 20,8.954 20,20 v 98 c 0,11.046 -8.954,20 -20,20 H 20 C 8.9539999,138 0,129.046 0,118 Z"
+     id="path4"
+     style="fill:url(#b)" />
+  <mask
+     id="e"
+     width="129"
+     height="138"
+     x="8"
+     y="27"
+     maskUnits="userSpaceOnUse">
+    <path
+       fill="#ffffff"
+       d="M 8,71 C 8,46.7 27.7,27 52,27 h 64 c 11.046,0 20,8.954 20,20 v 98 c 0,11.046 -8.954,20 -20,20 H 28 C 16.954,165 8,156.046 8,145 Z"
+       id="path6" />
+  </mask>
+  <g
+     filter="url(#c)"
+     mask="url(#e)"
+     id="g11"
+     transform="translate(-8,-27)">
+    <path
+       fill="url(#f)"
+       d="M 73.906,99.198 183.906,36 v 124 z"
+       id="path9"
+       style="fill:url(#f)" />
+  </g>
+  <circle
+     cx="30"
+     cy="108"
+     r="14"
+     fill="#ffffff"
+     id="circle13" />
+  <defs
+     id="defs37">
+    <linearGradient
+       id="a"
+       x1="128.8"
+       x2="227.2"
+       y1="104.44"
+       y2="104.44"
+       gradientUnits="userSpaceOnUse"
+       gradientTransform="translate(-8,-27)">
+      <stop
+         stop-color="#f6a100"
+         id="stop15" />
+      <stop
+         offset="1"
+         stop-color="#ffbe00"
+         id="stop17" />
+    </linearGradient>
+    <linearGradient
+       id="f"
+       x1="136.22"
+       x2="78.5"
+       y1="91.32"
+       y2="91.190002"
+       gradientUnits="userSpaceOnUse">
+      <stop
+         offset=".15"
+         stop-color="#ffb5e8"
+         id="stop20" />
+      <stop
+         offset="1"
+         stop-color="#ffdbf5"
+         stop-opacity="0"
+         id="stop22" />
+    </linearGradient>
+    <radialGradient
+       id="b"
+       cx="0"
+       cy="0"
+       r="1"
+       gradientTransform="matrix(-159.725,0,0,-135.852,152.325,69)"
+       gradientUnits="userSpaceOnUse">
+      <stop
+         offset=".15"
+         stop-color="#ffe921"
+         id="stop25" />
+      <stop
+         offset="1"
+         stop-color="#fec700"
+         id="stop27" />
+    </radialGradient>
+    <filter
+       id="c"
+       width="166"
+       height="180"
+       x="45.91"
+       y="8"
+       color-interpolation-filters="sRGB"
+       filterUnits="userSpaceOnUse">
+      <feFlood
+         flood-opacity="0"
+         result="BackgroundImageFix"
+         id="feFlood30" />
+      <feBlend
+         in="SourceGraphic"
+         in2="BackgroundImageFix"
+         result="shape"
+         id="feBlend32"
+         mode="normal" />
+      <feGaussianBlur
+         result="effect1_foregroundBlur_37584_9338"
+         stdDeviation="14"
+         id="feGaussianBlur34" />
+    </filter>
+  </defs>
+</svg>
+`;
+export const GMEET_ICON = {
+    kind: 'svg',
+    dataUri: `data:image/svg+xml;base64,${Buffer.from(SVG).toString('base64')}`,
+};
+//# sourceMappingURL=icon.js.map

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

@@ -0,0 +1,44 @@
+import { defineToolkit, defineTool } from '../../core/define.js';
+import { GMEET_ICON } from './icon.js';
+import { googleMeetTools } from './tools/index.js';
+export default defineToolkit({
+    id: 'google-meet',
+    displayName: 'Google Meet',
+    shortDescription: 'Create and manage Google Meet spaces, conference records, participants, recordings, and transcripts.',
+    category: 'Scheduling & Booking',
+    icon: GMEET_ICON,
+    auth: {
+        type: 'oauth2',
+        tokenField: 'googleMeetToken',
+        provider: {
+            slug: 'googlemeet',
+            env: { clientId: 'GOOGLE_MEET_CLIENT_ID', clientSecret: 'GOOGLE_MEET_CLIENT_SECRET' },
+            authorizeUrl: 'https://accounts.google.com/o/oauth2/v2/auth',
+            tokenUrl: 'https://oauth2.googleapis.com/token',
+            scopes: [
+                'https://www.googleapis.com/auth/meetings.space.created',
+                'https://www.googleapis.com/auth/meetings.space.readonly',
+                'https://www.googleapis.com/auth/meetings.space.settings',
+            ],
+            exchangeStyle: 'form',
+            extraAuthParams: { access_type: 'offline', prompt: 'consent' },
+            connectDescription: 'Connect Google Meet to create meeting spaces, manage conferences, and access recordings and transcripts.',
+            callbackPath: '/api/auth/googlemeet/callback',
+            stateCookie: 'google_meet_oauth_state',
+        },
+    },
+    allowedHosts: ['meet.googleapis.com'],
+    tools: googleMeetTools.map((entry) => defineTool({
+        name: entry.name,
+        description: entry.description,
+        tool: entry.tool,
+        requiredAuth: entry.requiredAuth,
+        scope: entry.scope,
+    })),
+    meta: {
+        since: '0.0.8',
+        homepage: 'https://meet.google.com',
+        docsUrl: 'https://developers.google.com/meet/api/reference/rest/v2',
+    },
+});
+//# sourceMappingURL=manifest.js.map

package/dist/toolkits/google-meet/tools/create-meet.d.ts

@@ -0,0 +1,5 @@
+export declare const createMeet: import("ai").Tool<{
+    googleMeetToken: string;
+    config?: Record<string, unknown> | undefined;
+}, any>;
+//# sourceMappingURL=create-meet.d.ts.map