@rnsk/toolkits 0.0.5 → 0.0.7

package/dist/toolkits/google-slides/manifest.js

@@ -0,0 +1,46 @@
+import { defineToolkit, defineTool } from '../../core/define.js';
+import { GSLIDES_ICON } from './icon.js';
+import { googleSlidesTools } from './tools/index.js';
+export default defineToolkit({
+    id: 'google-slides',
+    displayName: 'Google Slides',
+    shortDescription: 'Create, read, and update Google Slides presentations, including Markdown-based slide generation.',
+    category: 'Document & File Management',
+    icon: GSLIDES_ICON,
+    auth: {
+        type: 'oauth2',
+        tokenField: 'googleSlidesToken',
+        provider: {
+            slug: 'googleslides',
+            env: { clientId: 'GOOGLE_SLIDES_CLIENT_ID', clientSecret: 'GOOGLE_SLIDES_CLIENT_SECRET' },
+            authorizeUrl: 'https://accounts.google.com/o/oauth2/v2/auth',
+            tokenUrl: 'https://oauth2.googleapis.com/token',
+            scopes: [
+                'https://www.googleapis.com/auth/presentations',
+                'https://www.googleapis.com/auth/presentations.readonly',
+                'https://www.googleapis.com/auth/drive',
+                'https://www.googleapis.com/auth/drive.file',
+                'https://www.googleapis.com/auth/drive.readonly',
+            ],
+            exchangeStyle: 'form',
+            extraAuthParams: { access_type: 'offline', prompt: 'consent' },
+            connectDescription: 'Connect Google Slides to create presentations, copy templates, and manage slide content.',
+            callbackPath: '/api/auth/googleslides/callback',
+            stateCookie: 'google_slides_oauth_state',
+        },
+    },
+    allowedHosts: ['slides.googleapis.com', 'www.googleapis.com'],
+    tools: googleSlidesTools.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://slides.google.com',
+        docsUrl: 'https://developers.google.com/slides/api/reference/rest',
+    },
+});
+//# sourceMappingURL=manifest.js.map

package/dist/toolkits/google-slides/tools/create-presentation.d.ts

@@ -0,0 +1,8 @@
+export declare const createPresentation: import("ai").Tool<{
+    googleSlidesToken: string;
+    title?: string | undefined;
+    pageSize?: Record<string, unknown> | undefined;
+    locale?: string | undefined;
+    presentationId?: string | undefined;
+}, any>;
+//# sourceMappingURL=create-presentation.d.ts.map

package/dist/toolkits/google-slides/tools/create-presentation.js

@@ -0,0 +1,42 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { slidesRequest } from './utils.js';
+export const createPresentation = tool({
+    description: 'Create a new Google Slides presentation with optional title, locale, page size, and custom presentation ID.',
+    inputSchema: z.object({
+        googleSlidesToken: z.string().describe('The Google Slides access token'),
+        title: z.string().optional().describe('The title of the presentation'),
+        locale: z.string().optional().describe("Locale as IETF BCP 47 tag (e.g. 'en-US')"),
+        pageSize: z.record(z.unknown()).optional().describe('Page size configuration object'),
+        presentationId: z.string().optional().describe('Optional custom ID for the new presentation'),
+    }),
+    execute: async ({ googleSlidesToken, title, locale, pageSize, presentationId }) => {
+        try {
+            const body = {};
+            if (title)
+                body.title = title;
+            if (locale)
+                body.locale = locale;
+            if (pageSize)
+                body.pageSize = pageSize;
+            if (presentationId)
+                body.presentationId = presentationId;
+            const result = await slidesRequest(googleSlidesToken, '/presentations', {
+                method: 'POST',
+                body,
+            });
+            if (!result.ok) {
+                return { error: 'Failed to create presentation', details: result.data, statusCode: result.status };
+            }
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error creating presentation',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=create-presentation.js.map

package/dist/toolkits/google-slides/tools/create-slides-markdown.d.ts

@@ -0,0 +1,56 @@
+export declare const createSlidesMarkdown: import("ai").Tool<{
+    title: string;
+    googleSlidesToken: string;
+    markdown_text: string;
+}, {
+    error: string;
+    details: any;
+    statusCode: number;
+    presentation_id?: undefined;
+    slide_count?: undefined;
+    presentation?: undefined;
+    presentationUrl?: undefined;
+    batchUpdate?: undefined;
+    message?: undefined;
+} | {
+    presentation_id: any;
+    slide_count: any;
+    presentation: any;
+    error?: undefined;
+    details?: undefined;
+    statusCode?: undefined;
+    presentationUrl?: undefined;
+    batchUpdate?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    presentation_id: any;
+    details: any;
+    statusCode: number;
+    slide_count?: undefined;
+    presentation?: undefined;
+    presentationUrl?: undefined;
+    batchUpdate?: undefined;
+    message?: undefined;
+} | {
+    presentation_id: any;
+    slide_count: number;
+    presentationUrl: string;
+    batchUpdate: any;
+    error?: undefined;
+    details?: undefined;
+    statusCode?: undefined;
+    presentation?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    statusCode?: undefined;
+    presentation_id?: undefined;
+    slide_count?: undefined;
+    presentation?: undefined;
+    presentationUrl?: undefined;
+    batchUpdate?: undefined;
+}>;
+//# sourceMappingURL=create-slides-markdown.d.ts.map

package/dist/toolkits/google-slides/tools/create-slides-markdown.js

@@ -0,0 +1,70 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { buildMarkdownSlideRequests, parseMarkdownSlides } from './markdown.js';
+import { slidesRequest } from './utils.js';
+export const createSlidesMarkdown = tool({
+    description: 'Creates a new Google Slides presentation from Markdown text. Splits content into slides using --- separators.',
+    inputSchema: z.object({
+        googleSlidesToken: z.string().describe('The Google Slides access token'),
+        title: z.string().describe('The title for the new Google Slides presentation'),
+        markdown_text: z
+            .string()
+            .describe('Slide content in Markdown. Separate slides with \\n---\\n on its own line.'),
+    }),
+    execute: async ({ googleSlidesToken, title, markdown_text }) => {
+        try {
+            const createResult = await slidesRequest(googleSlidesToken, '/presentations', {
+                method: 'POST',
+                body: { title },
+            });
+            if (!createResult.ok) {
+                return {
+                    error: 'Failed to create presentation',
+                    details: createResult.data,
+                    statusCode: createResult.status,
+                };
+            }
+            const presentationId = createResult.data?.presentationId;
+            const defaultSlideId = createResult.data?.slides?.[0]?.objectId;
+            const slideSections = parseMarkdownSlides(markdown_text);
+            if (!presentationId || slideSections.length === 0) {
+                return {
+                    presentation_id: presentationId,
+                    slide_count: createResult.data?.slides?.length ?? 0,
+                    presentation: createResult.data,
+                };
+            }
+            const requests = [];
+            if (defaultSlideId) {
+                requests.push({ deleteObject: { objectId: defaultSlideId } });
+            }
+            requests.push(...buildMarkdownSlideRequests(markdown_text, { insertionIndex: 0, idPrefix: 'new' }));
+            const batchResult = await slidesRequest(googleSlidesToken, `/presentations/${presentationId}:batchUpdate`, {
+                method: 'POST',
+                body: { requests },
+            });
+            if (!batchResult.ok) {
+                return {
+                    error: 'Presentation created but failed to add markdown slides',
+                    presentation_id: presentationId,
+                    details: batchResult.data,
+                    statusCode: batchResult.status,
+                };
+            }
+            return {
+                presentation_id: presentationId,
+                slide_count: slideSections.length,
+                presentationUrl: `https://docs.google.com/presentation/d/${presentationId}/edit`,
+                batchUpdate: batchResult.data,
+            };
+        }
+        catch (error) {
+            return {
+                error: 'Error creating slides from markdown',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=create-slides-markdown.js.map

package/dist/toolkits/google-slides/tools/get-page-thumbnail2.d.ts

@@ -0,0 +1,8 @@
+export declare const getPageThumbnail2: import("ai").Tool<{
+    googleSlidesToken: string;
+    presentationId: string;
+    pageObjectId: string;
+    'thumbnailProperties.mimeType'?: string | undefined;
+    'thumbnailProperties.thumbnailSize'?: "LARGE" | "MEDIUM" | "SMALL" | "THUMBNAIL_SIZE_UNSPECIFIED" | undefined;
+}, any>;
+//# sourceMappingURL=get-page-thumbnail2.d.ts.map

package/dist/toolkits/google-slides/tools/get-page-thumbnail2.js

@@ -0,0 +1,41 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { slidesRequest } from './utils.js';
+export const getPageThumbnail2 = tool({
+    description: 'Generate a thumbnail of the latest version of a specified slide page. Returns a preview image URL.',
+    inputSchema: z.object({
+        googleSlidesToken: z.string().describe('The Google Slides access token'),
+        presentationId: z.string().describe('The ID of the presentation'),
+        pageObjectId: z.string().describe('The object ID of the page whose thumbnail to retrieve'),
+        'thumbnailProperties.mimeType': z
+            .string()
+            .optional()
+            .describe('Optional thumbnail MIME type (defaults to PNG)'),
+        'thumbnailProperties.thumbnailSize': z
+            .enum(['LARGE', 'MEDIUM', 'SMALL', 'THUMBNAIL_SIZE_UNSPECIFIED'])
+            .optional()
+            .describe('Optional thumbnail size (LARGE=1600px, MEDIUM=800px, SMALL=200px)'),
+    }),
+    execute: async ({ googleSlidesToken, presentationId, pageObjectId, 'thumbnailProperties.mimeType': mimeType, 'thumbnailProperties.thumbnailSize': thumbnailSize, }) => {
+        try {
+            const query = {};
+            if (mimeType)
+                query['thumbnailProperties.mimeType'] = mimeType;
+            if (thumbnailSize)
+                query['thumbnailProperties.thumbnailSize'] = thumbnailSize;
+            const result = await slidesRequest(googleSlidesToken, `/presentations/${presentationId}/pages/${pageObjectId}/thumbnail`, { query });
+            if (!result.ok) {
+                return { error: 'Failed to get page thumbnail', details: result.data, statusCode: result.status };
+            }
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error getting page thumbnail',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=get-page-thumbnail2.js.map

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

@@ -0,0 +1,139 @@
+import { createPresentation } from './create-presentation.js';
+import { createSlidesMarkdown } from './create-slides-markdown.js';
+import { getPageThumbnail2 } from './get-page-thumbnail2.js';
+import { presentationsBatchUpdate } from './presentations-batch-update.js';
+import { presentationsCopyFromTemplate } from './presentations-copy-from-template.js';
+import { presentationsGet } from './presentations-get.js';
+import { presentationsPagesGet } from './presentations-pages-get.js';
+import { presentationsPagesGetThumbnail } from './presentations-pages-get-thumbnail.js';
+export { createPresentation, createSlidesMarkdown, getPageThumbnail2, presentationsBatchUpdate, presentationsCopyFromTemplate, presentationsGet, presentationsPagesGet, presentationsPagesGetThumbnail, };
+export declare const googleSlidesTools: ({
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        googleSlidesToken: string;
+        title?: string | undefined;
+        pageSize?: Record<string, unknown> | undefined;
+        locale?: string | undefined;
+        presentationId?: string | undefined;
+    }, any>;
+    requiredAuth: "googleSlidesToken";
+    scope: "write";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        title: string;
+        googleSlidesToken: string;
+        markdown_text: string;
+    }, {
+        error: string;
+        details: any;
+        statusCode: number;
+        presentation_id?: undefined;
+        slide_count?: undefined;
+        presentation?: undefined;
+        presentationUrl?: undefined;
+        batchUpdate?: undefined;
+        message?: undefined;
+    } | {
+        presentation_id: any;
+        slide_count: any;
+        presentation: any;
+        error?: undefined;
+        details?: undefined;
+        statusCode?: undefined;
+        presentationUrl?: undefined;
+        batchUpdate?: undefined;
+        message?: undefined;
+    } | {
+        error: string;
+        presentation_id: any;
+        details: any;
+        statusCode: number;
+        slide_count?: undefined;
+        presentation?: undefined;
+        presentationUrl?: undefined;
+        batchUpdate?: undefined;
+        message?: undefined;
+    } | {
+        presentation_id: any;
+        slide_count: number;
+        presentationUrl: string;
+        batchUpdate: any;
+        error?: undefined;
+        details?: undefined;
+        statusCode?: undefined;
+        presentation?: undefined;
+        message?: undefined;
+    } | {
+        error: string;
+        message: string;
+        details?: undefined;
+        statusCode?: undefined;
+        presentation_id?: undefined;
+        slide_count?: undefined;
+        presentation?: undefined;
+        presentationUrl?: undefined;
+        batchUpdate?: undefined;
+    }>;
+    requiredAuth: "googleSlidesToken";
+    scope: "write";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        googleSlidesToken: string;
+        presentationId: string;
+        pageObjectId: string;
+        'thumbnailProperties.mimeType'?: string | undefined;
+        'thumbnailProperties.thumbnailSize'?: "LARGE" | "MEDIUM" | "SMALL" | "THUMBNAIL_SIZE_UNSPECIFIED" | undefined;
+    }, any>;
+    requiredAuth: "googleSlidesToken";
+    scope: "read";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        googleSlidesToken: string;
+        presentationId: string;
+        requests?: Record<string, unknown>[] | undefined;
+        writeControl?: Record<string, unknown> | undefined;
+        markdown_text?: string | undefined;
+    }, any>;
+    requiredAuth: "googleSlidesToken";
+    scope: "write";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        googleSlidesToken: string;
+        template_presentation_id: string;
+        new_title?: string | undefined;
+        parent_folder_id?: string | undefined;
+    }, any>;
+    requiredAuth: "googleSlidesToken";
+    scope: "write";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        googleSlidesToken: string;
+        presentationId?: string | undefined;
+        presentationName?: string | undefined;
+        fields?: string | undefined;
+    }, any>;
+    requiredAuth: "googleSlidesToken";
+    scope: "read";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        googleSlidesToken: string;
+        presentationId: string;
+        pageObjectId: string;
+    }, any>;
+    requiredAuth: "googleSlidesToken";
+    scope: "read";
+})[];
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,69 @@
+// @ts-nocheck
+import { createPresentation } from './create-presentation.js';
+import { createSlidesMarkdown } from './create-slides-markdown.js';
+import { getPageThumbnail2 } from './get-page-thumbnail2.js';
+import { presentationsBatchUpdate } from './presentations-batch-update.js';
+import { presentationsCopyFromTemplate } from './presentations-copy-from-template.js';
+import { presentationsGet } from './presentations-get.js';
+import { presentationsPagesGet } from './presentations-pages-get.js';
+import { presentationsPagesGetThumbnail } from './presentations-pages-get-thumbnail.js';
+export { createPresentation, createSlidesMarkdown, getPageThumbnail2, presentationsBatchUpdate, presentationsCopyFromTemplate, presentationsGet, presentationsPagesGet, presentationsPagesGetThumbnail, };
+export const googleSlidesTools = [
+    {
+        name: 'googleSlidesCreatePresentation',
+        description: 'Tool to create a blank Google Slides presentation. Use when you need to initialize a new presentation with a specific title, locale, or page size.',
+        tool: createPresentation,
+        requiredAuth: 'googleSlidesToken',
+        scope: 'write',
+    },
+    {
+        name: 'googleSlidesCreateSlidesMarkdown',
+        description: 'Creates a new Google Slides presentation from Markdown text. Automatically splits content into slides using \'---\' separators and applies appropriate templates based on content structure.',
+        tool: createSlidesMarkdown,
+        requiredAuth: 'googleSlidesToken',
+        scope: 'write',
+    },
+    {
+        name: 'googleSlidesGetPageThumbnail2',
+        description: 'Tool to generate a thumbnail of the latest version of a specified page. Use when you need a preview image URL for a slide page. This request counts as an expensive read request for quota purposes.',
+        tool: getPageThumbnail2,
+        requiredAuth: 'googleSlidesToken',
+        scope: 'read',
+    },
+    {
+        name: 'googleSlidesPresentationsBatchUpdate',
+        description: 'Update Google Slides presentations using markdown content or raw API text. Supports professional themes, auto-formatting, and multiple slide types (title, bullet, table, quote, image, two-column).',
+        tool: presentationsBatchUpdate,
+        requiredAuth: 'googleSlidesToken',
+        scope: 'write',
+    },
+    {
+        name: 'googleSlidesPresentationsCopyFromTemplate',
+        description: 'Tool to create a new Google Slides presentation by duplicating an existing template deck via Drive file copy. Use when you need to preserve themes, masters, and layouts exactly as they appear in the template. After co...',
+        tool: presentationsCopyFromTemplate,
+        requiredAuth: 'googleSlidesToken',
+        scope: 'write',
+    },
+    {
+        name: 'googleSlidesPresentationsGet',
+        description: 'Tool to retrieve the latest version of a presentation. Use after obtaining the presentation ID.',
+        tool: presentationsGet,
+        requiredAuth: 'googleSlidesToken',
+        scope: 'read',
+    },
+    {
+        name: 'googleSlidesPresentationsPagesGet',
+        description: 'Tool to get the latest version of a specific page in a presentation. Use when you need to inspect slide, layout, master, or notes page details.',
+        tool: presentationsPagesGet,
+        requiredAuth: 'googleSlidesToken',
+        scope: 'read',
+    },
+    {
+        name: 'googleSlidesPresentationsPagesGetThumbnail',
+        description: 'DEPRECATED: Use GOOGLESLIDES_GET_PAGE_THUMBNAIL2 instead. Tool to generate and return a thumbnail image URL for a specific page. Use when you need a quick preview of a slide page after loading it.',
+        tool: presentationsPagesGetThumbnail,
+        requiredAuth: 'googleSlidesToken',
+        scope: 'read',
+    },
+];
+//# sourceMappingURL=index.js.map

package/dist/toolkits/google-slides/tools/markdown.d.ts

@@ -0,0 +1,6 @@
+export declare function parseMarkdownSlides(markdownText: string): string[];
+export declare function buildMarkdownSlideRequests(markdownText: string, options?: {
+    insertionIndex?: number;
+    idPrefix?: string;
+}): Array<Record<string, unknown>>;
+//# sourceMappingURL=markdown.d.ts.map