@rnsk/toolkits 0.0.6 → 0.0.8

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

@@ -0,0 +1,222 @@
+// @ts-nocheck
+function uniqueId(prefix, index) {
+    return `${prefix}_${index}_${Math.random().toString(36).slice(2, 8)}`;
+}
+export function parseMarkdownSlides(markdownText) {
+    let text = markdownText.trim();
+    if (/^Theme:\s*/im.test(text)) {
+        text = text.replace(/^Theme:\s*\S+\s*\n?/im, '').trim();
+    }
+    return text
+        .split(/\n---\n/)
+        .map((slide) => slide.trim())
+        .filter(Boolean);
+}
+function isTableSlide(content) {
+    const lines = content.split('\n').filter((line) => line.trim());
+    return lines.some((line) => line.includes('|')) && lines.length >= 2;
+}
+function parseMarkdownTable(content) {
+    const lines = content
+        .split('\n')
+        .map((line) => line.trim())
+        .filter((line) => line.includes('|'));
+    if (lines.length < 2)
+        return null;
+    const parseRow = (line) => line
+        .replace(/^\|/, '')
+        .replace(/\|$/, '')
+        .split('|')
+        .map((cell) => cell.trim());
+    const headers = parseRow(lines[0]);
+    const dataLines = lines.slice(2);
+    const rows = dataLines.map(parseRow).filter((row) => row.some(Boolean));
+    return { headers, rows };
+}
+function stripMarkdownFormatting(text) {
+    return text
+        .replace(/\*\*(.*?)\*\*/g, '$1')
+        .replace(/^>\s?/gm, '')
+        .replace(/^#+\s*/gm, '')
+        .replace(/^[-*+]\s+/gm, '• ')
+        .trim();
+}
+function buildTextBoxRequests(slideObjectId, shapeObjectId, text, options) {
+    const x = options?.x ?? 400000;
+    const y = options?.y ?? 400000;
+    const width = options?.width ?? 8200000;
+    const height = options?.height ?? 4300000;
+    return [
+        {
+            createShape: {
+                objectId: shapeObjectId,
+                shapeType: 'TEXT_BOX',
+                elementProperties: {
+                    pageObjectId: slideObjectId,
+                    size: {
+                        width: { magnitude: width, unit: 'EMU' },
+                        height: { magnitude: height, unit: 'EMU' },
+                    },
+                    transform: {
+                        scaleX: 1,
+                        scaleY: 1,
+                        translateX: x,
+                        translateY: y,
+                        unit: 'EMU',
+                    },
+                },
+            },
+        },
+        {
+            insertText: {
+                objectId: shapeObjectId,
+                insertionIndex: 0,
+                text: stripMarkdownFormatting(text),
+            },
+        },
+    ];
+}
+function buildTableRequests(slideObjectId, tableObjectId, content) {
+    const parsed = parseMarkdownTable(content);
+    if (!parsed)
+        return buildTextBoxRequests(slideObjectId, `${tableObjectId}_text`, content);
+    const rowCount = parsed.rows.length + 1;
+    const columnCount = parsed.headers.length;
+    const requests = [
+        {
+            createTable: {
+                objectId: tableObjectId,
+                elementProperties: {
+                    pageObjectId: slideObjectId,
+                    size: {
+                        width: { magnitude: 8200000, unit: 'EMU' },
+                        height: { magnitude: 4300000, unit: 'EMU' },
+                    },
+                    transform: {
+                        scaleX: 1,
+                        scaleY: 1,
+                        translateX: 400000,
+                        translateY: 400000,
+                        unit: 'EMU',
+                    },
+                },
+                rows: rowCount,
+                columns: columnCount,
+            },
+        },
+    ];
+    parsed.headers.forEach((header, columnIndex) => {
+        requests.push({
+            insertText: {
+                objectId: tableObjectId,
+                cellLocation: { rowIndex: 0, columnIndex },
+                text: stripMarkdownFormatting(header),
+                insertionIndex: 0,
+            },
+        });
+    });
+    parsed.rows.forEach((row, rowIndex) => {
+        row.forEach((cell, columnIndex) => {
+            if (columnIndex >= columnCount)
+                return;
+            requests.push({
+                insertText: {
+                    objectId: tableObjectId,
+                    cellLocation: { rowIndex: rowIndex + 1, columnIndex },
+                    text: stripMarkdownFormatting(cell),
+                    insertionIndex: 0,
+                },
+            });
+        });
+    });
+    return requests;
+}
+function buildImageRequests(slideObjectId, imageObjectId, url) {
+    return [
+        {
+            createImage: {
+                objectId: imageObjectId,
+                url,
+                elementProperties: {
+                    pageObjectId: slideObjectId,
+                    size: {
+                        width: { magnitude: 6400000, unit: 'EMU' },
+                        height: { magnitude: 3600000, unit: 'EMU' },
+                    },
+                    transform: {
+                        scaleX: 1,
+                        scaleY: 1,
+                        translateX: 1200000,
+                        translateY: 800000,
+                        unit: 'EMU',
+                    },
+                },
+            },
+        },
+    ];
+}
+function extractImageUrl(content) {
+    const match = content.match(/!\[[^\]]*]\(([^)]+)\)/);
+    return match?.[1]?.trim() ?? null;
+}
+export function buildMarkdownSlideRequests(markdownText, options) {
+    const slides = parseMarkdownSlides(markdownText);
+    const requests = [];
+    const prefix = options?.idPrefix ?? 'md';
+    slides.forEach((slideContent, index) => {
+        const slideObjectId = uniqueId(`${prefix}_slide`, index);
+        const insertionIndex = options?.insertionIndex !== undefined ? options.insertionIndex + index : index + 1;
+        requests.push({
+            createSlide: {
+                objectId: slideObjectId,
+                insertionIndex,
+                slideLayoutReference: { predefinedLayout: 'BLANK' },
+            },
+        });
+        if (slideContent.includes('|||')) {
+            const [left, right] = slideContent.split('|||').map((part) => part.trim());
+            requests.push(...buildTextBoxRequests(slideObjectId, uniqueId(`${prefix}_left`, index), left, {
+                x: 300000,
+                y: 400000,
+                width: 4000000,
+                height: 4300000,
+            }), ...buildTextBoxRequests(slideObjectId, uniqueId(`${prefix}_right`, index), right, {
+                x: 4500000,
+                y: 400000,
+                width: 4000000,
+                height: 4300000,
+            }));
+            return;
+        }
+        const imageUrl = extractImageUrl(slideContent);
+        if (imageUrl) {
+            requests.push(...buildImageRequests(slideObjectId, uniqueId(`${prefix}_image`, index), imageUrl));
+            const caption = slideContent.replace(/!\[[^\]]*]\([^)]+\)/, '').trim();
+            if (caption) {
+                requests.push(...buildTextBoxRequests(slideObjectId, uniqueId(`${prefix}_caption`, index), caption, {
+                    y: 4500000,
+                    height: 800000,
+                }));
+            }
+            return;
+        }
+        if (isTableSlide(slideContent)) {
+            requests.push(...buildTableRequests(slideObjectId, uniqueId(`${prefix}_table`, index), slideContent));
+            return;
+        }
+        const layout = slideContent.startsWith('# ') ? 'TITLE' : 'TITLE_AND_BODY';
+        if (layout === 'TITLE') {
+            requests.pop();
+            requests.push({
+                createSlide: {
+                    objectId: slideObjectId,
+                    insertionIndex,
+                    slideLayoutReference: { predefinedLayout: 'TITLE' },
+                },
+            });
+        }
+        requests.push(...buildTextBoxRequests(slideObjectId, uniqueId(`${prefix}_body`, index), slideContent));
+    });
+    return requests;
+}
+//# sourceMappingURL=markdown.js.map

package/dist/toolkits/google-slides/tools/presentations-batch-update.d.ts

@@ -0,0 +1,8 @@
+export declare const presentationsBatchUpdate: import("ai").Tool<{
+    googleSlidesToken: string;
+    presentationId: string;
+    requests?: Record<string, unknown>[] | undefined;
+    writeControl?: Record<string, unknown> | undefined;
+    markdown_text?: string | undefined;
+}, any>;
+//# sourceMappingURL=presentations-batch-update.d.ts.map

package/dist/toolkits/google-slides/tools/presentations-batch-update.js

@@ -0,0 +1,58 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { buildMarkdownSlideRequests } from './markdown.js';
+import { slidesRequest } from './utils.js';
+export const presentationsBatchUpdate = tool({
+    description: 'Update a Google Slides presentation using raw Slides API batch requests or Markdown content.',
+    inputSchema: z.object({
+        googleSlidesToken: z.string().describe('The Google Slides access token'),
+        presentationId: z.string().describe('The ID of the presentation to update'),
+        requests: z
+            .array(z.record(z.unknown()))
+            .optional()
+            .describe('List of Google Slides batchUpdate request objects'),
+        writeControl: z
+            .record(z.unknown())
+            .optional()
+            .describe('Write control options such as requiredRevisionId'),
+        markdown_text: z
+            .string()
+            .optional()
+            .describe('Markdown content to add as new slides. Separate slides with \\n---\\n'),
+    }),
+    execute: async ({ googleSlidesToken, presentationId, requests, writeControl, markdown_text }) => {
+        try {
+            const batchRequests = [...(requests ?? [])];
+            if (markdown_text) {
+                const presentation = await slidesRequest(googleSlidesToken, `/presentations/${presentationId}`);
+                const insertionIndex = presentation.data?.slides?.length ?? 0;
+                batchRequests.push(...buildMarkdownSlideRequests(markdown_text, {
+                    insertionIndex,
+                    idPrefix: 'batch',
+                }));
+            }
+            if (batchRequests.length === 0) {
+                return { error: 'Provide requests and/or markdown_text to update the presentation' };
+            }
+            const body = { requests: batchRequests };
+            if (writeControl)
+                body.writeControl = writeControl;
+            const result = await slidesRequest(googleSlidesToken, `/presentations/${presentationId}:batchUpdate`, {
+                method: 'POST',
+                body,
+            });
+            if (!result.ok) {
+                return { error: 'Failed to batch update presentation', details: result.data, statusCode: result.status };
+            }
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error batch updating presentation',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=presentations-batch-update.js.map

package/dist/toolkits/google-slides/tools/presentations-copy-from-template.d.ts

@@ -0,0 +1,7 @@
+export declare const presentationsCopyFromTemplate: import("ai").Tool<{
+    googleSlidesToken: string;
+    template_presentation_id: string;
+    new_title?: string | undefined;
+    parent_folder_id?: string | undefined;
+}, any>;
+//# sourceMappingURL=presentations-copy-from-template.d.ts.map

package/dist/toolkits/google-slides/tools/presentations-copy-from-template.js

@@ -0,0 +1,42 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { driveRequest } from './utils.js';
+export const presentationsCopyFromTemplate = tool({
+    description: 'Copy a Google Slides template presentation to create a new deck, optionally with a new title and destination folder.',
+    inputSchema: z.object({
+        googleSlidesToken: z.string().describe('The Google Slides access token'),
+        template_presentation_id: z.string().describe('Drive file ID of the Slides template to copy'),
+        new_title: z.string().optional().describe('Title for the copied presentation'),
+        parent_folder_id: z.string().optional().describe('Destination Google Drive folder ID'),
+    }),
+    execute: async ({ googleSlidesToken, template_presentation_id, new_title, parent_folder_id }) => {
+        try {
+            const body = {};
+            if (new_title)
+                body.name = new_title;
+            if (parent_folder_id)
+                body.parents = [parent_folder_id];
+            const result = await driveRequest(googleSlidesToken, `/files/${template_presentation_id}/copy`, {
+                method: 'POST',
+                body,
+            });
+            if (!result.ok) {
+                return { error: 'Failed to copy presentation template', details: result.data, statusCode: result.status };
+            }
+            return {
+                presentationId: result.data?.id,
+                name: result.data?.name,
+                webViewLink: result.data?.webViewLink,
+                ...result.data,
+            };
+        }
+        catch (error) {
+            return {
+                error: 'Error copying presentation template',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=presentations-copy-from-template.js.map

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

@@ -0,0 +1,7 @@
+export declare const presentationsGet: import("ai").Tool<{
+    googleSlidesToken: string;
+    presentationId?: string | undefined;
+    presentationName?: string | undefined;
+    fields?: string | undefined;
+}, any>;
+//# sourceMappingURL=presentations-get.d.ts.map

package/dist/toolkits/google-slides/tools/presentations-get.js

@@ -0,0 +1,58 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { driveRequest, slidesRequest } from './utils.js';
+export const presentationsGet = tool({
+    description: 'Retrieve a Google Slides presentation by ID or search for a presentation by name in Drive.',
+    inputSchema: z.object({
+        googleSlidesToken: z.string().describe('The Google Slides access token'),
+        presentationId: z.string().optional().describe('The ID of the presentation to retrieve'),
+        presentationName: z
+            .string()
+            .optional()
+            .describe('Presentation name to search for in Google Drive'),
+        fields: z
+            .string()
+            .optional()
+            .describe('Comma-separated field mask for a partial Slides API response'),
+    }),
+    execute: async ({ googleSlidesToken, presentationId, presentationName, fields }) => {
+        try {
+            let resolvedId = presentationId;
+            if (!resolvedId && presentationName) {
+                const escaped = presentationName.replace(/'/g, "\\'");
+                const search = await driveRequest(googleSlidesToken, '/files', {
+                    query: {
+                        q: `name='${escaped}' and mimeType='application/vnd.google-apps.presentation' and trashed=false`,
+                        pageSize: 1,
+                        fields: 'files(id,name,webViewLink)',
+                    },
+                });
+                if (!search.ok) {
+                    return { error: 'Failed to search for presentation by name', details: search.data, statusCode: search.status };
+                }
+                resolvedId = search.data?.files?.[0]?.id;
+                if (!resolvedId) {
+                    return { error: `No presentation found with name '${presentationName}'` };
+                }
+            }
+            if (!resolvedId) {
+                return { error: 'Provide presentationId or presentationName' };
+            }
+            const result = await slidesRequest(googleSlidesToken, `/presentations/${resolvedId}`, {
+                query: fields ? { fields } : {},
+            });
+            if (!result.ok) {
+                return { error: 'Failed to get presentation', details: result.data, statusCode: result.status };
+            }
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error getting presentation',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=presentations-get.js.map

package/dist/toolkits/google-slides/tools/presentations-pages-get-thumbnail.d.ts

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

package/dist/toolkits/google-slides/tools/presentations-pages-get-thumbnail.js

@@ -0,0 +1,41 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { slidesRequest } from './utils.js';
+export const presentationsPagesGetThumbnail = tool({
+    description: 'Get a thumbnail image URL for a slide page. Deprecated in favor of getPageThumbnail2; kept for compatibility.',
+    inputSchema: z.object({
+        googleSlidesToken: z.string().describe('The Google Slides access token'),
+        presentationId: z.string().describe('The ID of the presentation containing the page'),
+        pageObjectId: z.string().describe('The object ID of the page whose thumbnail to retrieve'),
+        'thumbnailProperties.mimeType': z
+            .string()
+            .optional()
+            .describe("Optional thumbnail MIME type (currently only 'PNG' is supported)"),
+        'thumbnailProperties.thumbnailSize': z
+            .enum(['LARGE', 'MEDIUM', 'SMALL', 'THUMBNAIL_SIZE_UNSPECIFIED'])
+            .optional()
+            .describe('Optional thumbnail size'),
+    }),
+    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=presentations-pages-get-thumbnail.js.map

package/dist/toolkits/google-slides/tools/presentations-pages-get.d.ts

@@ -0,0 +1,6 @@
+export declare const presentationsPagesGet: import("ai").Tool<{
+    googleSlidesToken: string;
+    presentationId: string;
+    pageObjectId: string;
+}, any>;
+//# sourceMappingURL=presentations-pages-get.d.ts.map

package/dist/toolkits/google-slides/tools/presentations-pages-get.js

@@ -0,0 +1,28 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { slidesRequest } from './utils.js';
+export const presentationsPagesGet = tool({
+    description: 'Retrieve a specific page (slide) from a Google Slides presentation.',
+    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 to retrieve'),
+    }),
+    execute: async ({ googleSlidesToken, presentationId, pageObjectId }) => {
+        try {
+            const result = await slidesRequest(googleSlidesToken, `/presentations/${presentationId}/pages/${pageObjectId}`);
+            if (!result.ok) {
+                return { error: 'Failed to get presentation page', details: result.data, statusCode: result.status };
+            }
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error getting presentation page',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=presentations-pages-get.js.map

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

@@ -0,0 +1,22 @@
+export declare const SLIDES_BASE = "https://slides.googleapis.com/v1";
+export declare const DRIVE_BASE = "https://www.googleapis.com/drive/v3";
+export declare function buildQueryString(params: Record<string, unknown>): string;
+export declare function slidesRequest(googleSlidesToken: string, path: string, options?: {
+    method?: string;
+    body?: unknown;
+    query?: Record<string, unknown>;
+}): Promise<{
+    ok: boolean;
+    status: number;
+    data: any;
+}>;
+export declare function driveRequest(googleSlidesToken: string, path: string, options?: {
+    method?: string;
+    body?: unknown;
+    query?: Record<string, unknown>;
+}): Promise<{
+    ok: boolean;
+    status: number;
+    data: any;
+}>;
+//# sourceMappingURL=utils.d.ts.map

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

@@ -0,0 +1,51 @@
+// @ts-nocheck
+export const SLIDES_BASE = 'https://slides.googleapis.com/v1';
+export const DRIVE_BASE = 'https://www.googleapis.com/drive/v3';
+export function buildQueryString(params) {
+    const search = new URLSearchParams();
+    for (const [key, value] of Object.entries(params)) {
+        if (value !== undefined && value !== null && value !== '') {
+            search.set(key, String(value));
+        }
+    }
+    const qs = search.toString();
+    return qs ? `?${qs}` : '';
+}
+export async function slidesRequest(googleSlidesToken, path, options) {
+    const normalizedPath = path.startsWith('/') ? path : `/${path}`;
+    const url = `${SLIDES_BASE}${normalizedPath}${buildQueryString(options?.query ?? {})}`;
+    const headers = {
+        Authorization: `Bearer ${googleSlidesToken}`,
+        Accept: 'application/json',
+    };
+    const method = options?.method ?? 'GET';
+    const fetchOptions = { method, headers };
+    if (options?.body !== undefined) {
+        headers['Content-Type'] = 'application/json';
+        fetchOptions.body = JSON.stringify(options.body);
+    }
+    const response = await fetch(url, fetchOptions);
+    if (response.status === 204) {
+        return { ok: response.ok, status: response.status, data: null };
+    }
+    const data = await response.json().catch(() => null);
+    return { ok: response.ok, status: response.status, data };
+}
+export async function driveRequest(googleSlidesToken, path, options) {
+    const normalizedPath = path.startsWith('/') ? path : `/${path}`;
+    const url = `${DRIVE_BASE}${normalizedPath}${buildQueryString(options?.query ?? {})}`;
+    const headers = {
+        Authorization: `Bearer ${googleSlidesToken}`,
+        Accept: 'application/json',
+    };
+    const method = options?.method ?? 'GET';
+    const fetchOptions = { method, headers };
+    if (options?.body !== undefined) {
+        headers['Content-Type'] = 'application/json';
+        fetchOptions.body = JSON.stringify(options.body);
+    }
+    const response = await fetch(url, fetchOptions);
+    const data = await response.json().catch(() => null);
+    return { ok: response.ok, status: response.status, data };
+}
+//# sourceMappingURL=utils.js.map

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

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

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

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

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

@@ -0,0 +1,3 @@
+declare const _default: import("../../index.js").ToolkitManifest;
+export default _default;
+//# sourceMappingURL=manifest.d.ts.map

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

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