@rnsk/toolkits 0.0.6 → 0.0.7

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/grafana/icon.d.ts

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

package/dist/toolkits/grafana/icon.js

@@ -0,0 +1,6 @@
+const SVG = `<svg width="800px" height="800px" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="none"><path fill="url(#grafana-color-16__paint0_linear_2372_364)" d="M13.985 7.175a4.408 4.408 0 00-.138-.802 5.035 5.035 0 00-1.054-1.998 2.96 2.96 0 00-.366-.393c.198-.787-.245-1.468-.245-1.468-.764-.046-1.237.227-1.42.363-.031-.015-.062-.03-.092-.03-.122-.046-.26-.106-.397-.137-.138-.045-.275-.075-.413-.12-.137-.031-.29-.061-.443-.092-.03 0-.046 0-.076-.015C9.005 1.44 8.058 1 8.058 1 7.004 1.666 6.79 2.604 6.79 2.604s0 .015-.016.06l-.183.046c-.076.03-.168.06-.244.076-.077.03-.168.06-.245.09-.153.076-.32.152-.473.228-.153.09-.306.181-.443.272-.016-.015-.03-.015-.03-.015-1.467-.545-2.766.136-2.766.136-.122 1.544.58 2.528.733 2.71-.03.09-.06.196-.091.287a8.104 8.104 0 00-.245 1.09c0 .06-.015.106-.015.166C1.397 8.386 1 9.748 1 9.748c1.13 1.287 2.46 1.377 2.46 1.377.167.303.366.575.58.848.092.106.183.212.29.318a3.014 3.014 0 00.061 2.149c1.268.045 2.093-.545 2.261-.681.122.045.26.076.382.106.382.106.78.151 1.176.181h.49c.595.848 1.634.954 1.634.954.748-.772.779-1.544.779-1.71v-.015-.03-.03c.153-.107.305-.228.443-.35a5.37 5.37 0 00.779-.892c.015-.03.046-.06.061-.09.84.045 1.436-.515 1.436-.515-.138-.863-.642-1.287-.749-1.378l-.015-.015h-.015s-.015 0-.015-.015c0-.045.015-.106.015-.151 0-.091.015-.182.015-.288V9.4v-.166-.076-.152l-.015-.075c-.015-.091-.03-.197-.061-.288a3.506 3.506 0 00-.428-1.044 3.856 3.856 0 00-.718-.848 3.784 3.784 0 00-.901-.575 3.347 3.347 0 00-.993-.272c-.168-.015-.336-.03-.504-.03H9.37 9.204c-.092.015-.169.015-.26.03-.336.06-.642.181-.932.348-.275.166-.52.363-.718.605a2.579 2.579 0 00-.459.757 2.63 2.63 0 00-.183.817v.393c.015.137.046.273.077.394.076.258.183.485.336.666.137.197.32.348.504.485.183.12.382.212.58.272.199.06.382.076.565.076h.244c.031 0 .047 0 .062-.015.015 0 .046-.015.061-.015.046-.016.076-.016.122-.03l.23-.092a.869.869 0 00.198-.12c.015-.016.03-.03.046-.03a.129.129 0 00.015-.198c-.046-.06-.122-.075-.183-.03-.015.015-.03.015-.046.03-.046.03-.107.046-.168.06l-.183.046c-.03 0-.061.015-.092.015H8.73a1.519 1.519 0 01-.825-.378 1.452 1.452 0 01-.306-.378 1.655 1.655 0 01-.168-.485c-.015-.09-.015-.166-.015-.257v-.106-.03c0-.046.015-.091.015-.136.061-.364.26-.727.55-1 .077-.075.153-.136.23-.181.076-.06.167-.106.259-.151.092-.046.183-.076.29-.106a.993.993 0 01.306-.046h.321c.107.015.229.03.336.046.214.045.427.12.626.242.397.212.733.56.947.969.107.211.183.423.214.65.015.06.015.121.015.167v.363c0 .06-.015.121-.015.182 0 .06-.015.12-.03.181l-.046.182c-.03.121-.077.242-.123.363a3.183 3.183 0 01-.366.666 3.002 3.002 0 01-1.91 1.18c-.122.016-.26.03-.382.046h-.198c-.061 0-.138 0-.199-.015a3.637 3.637 0 01-.81-.151 4.068 4.068 0 01-.748-.303 4.098 4.098 0 01-1.696-1.695 4.398 4.398 0 01-.29-.742c-.076-.257-.107-.514-.137-.772v-.302-.091c0-.136.015-.258.03-.394s.046-.272.061-.393c.03-.137.061-.258.092-.394a5.33 5.33 0 01.275-.741c.214-.47.504-.893.855-1.226.092-.091.184-.167.275-.243.092-.075.184-.136.29-.211a5.39 5.39 0 01.306-.182c.046-.03.107-.045.153-.076a.26.26 0 01.076-.03.26.26 0 01.077-.03c.107-.046.229-.091.336-.121.03-.015.06-.015.091-.03.03-.016.061-.016.092-.03.061-.016.122-.031.168-.046.03-.015.061-.015.092-.015.03 0 .06-.016.091-.016.03 0 .061-.015.092-.015l.046-.015h.046c.03 0 .06-.015.091-.015.03 0 .061-.015.107-.015.03 0 .077-.015.107-.015h.764c.23.015.443.03.657.075.428.076.84.212 1.207.394.366.182.702.393.977.636l.046.045.046.045c.03.03.061.061.107.091l.092.091.091.09c.123.122.23.258.336.394.199.258.367.515.49.772.014.015.014.03.03.046.015.015.015.03.015.045l.046.09.046.092.045.09c.046.122.092.228.123.333.06.167.107.318.137.455.015.045.061.09.122.075a.104.104 0 00.107-.106c.092-.227.092-.393.077-.575z"/><defs><linearGradient id="grafana-color-16__paint0_linear_2372_364" x1="7.502" x2="7.502" y1="18.142" y2="5.356" gradientUnits="userSpaceOnUse"><stop stop-color="#FFF200"/><stop offset="1" stop-color="#F15A29"/></linearGradient></defs></svg>`;
+export const GRAFANA_ICON = {
+    kind: 'svg',
+    dataUri: `data:image/svg+xml;base64,${Buffer.from(SVG).toString('base64')}`,
+};
+//# sourceMappingURL=icon.js.map

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

@@ -0,0 +1,31 @@
+import { defineToolkit, defineTool } from '../../core/define.js';
+import { GRAFANA_ICON } from './icon.js';
+import { grafanaTools } from './tools/index.js';
+export default defineToolkit({
+    id: 'grafana',
+    displayName: 'Grafana',
+    shortDescription: 'Monitor Grafana health, query public dashboards, ingest OTLP logs, and inspect Mimir/Loki ring status.',
+    category: 'Developer Tools & DevOps',
+    icon: GRAFANA_ICON,
+    auth: {
+        type: 'service_account',
+        tokenField: 'grafanaCredentials',
+        provider: {
+            fields: ['baseUrl', 'apiToken'],
+            connectDescription: 'Connect your Grafana instance with its base URL (e.g. https://grafana.example.com) and an optional service account API token.',
+        },
+    },
+    tools: grafanaTools.map((entry) => defineTool({
+        name: entry.name,
+        description: entry.description,
+        tool: entry.tool,
+        requiredAuth: entry.requiredAuth,
+        scope: entry.scope,
+    })),
+    meta: {
+        since: '0.0.6',
+        homepage: 'https://grafana.com',
+        docsUrl: 'https://grafana.com/docs/grafana/latest/developer-resources/api-reference/http-api/',
+    },
+});
+//# sourceMappingURL=manifest.js.map

package/dist/toolkits/grafana/tools/create-otlp-v1-logs.d.ts

@@ -0,0 +1,23 @@
+export declare const createOtlpV1Logs: import("ai").Tool<{
+    grafanaCredentials: string;
+    resourceLogs: Record<string, any>[];
+}, {
+    error: string;
+    details: any;
+    statusCode: number;
+    success?: undefined;
+    message?: undefined;
+} | {
+    success: boolean;
+    statusCode: number;
+    message: string;
+    error?: undefined;
+    details?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    statusCode?: undefined;
+    success?: undefined;
+}>;
+//# sourceMappingURL=create-otlp-v1-logs.d.ts.map