@rnsk/toolkits 0.0.5 → 0.0.7

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

@@ -0,0 +1,41 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { grafanaRequest } from './utils.js';
+export const createOtlpV1Logs = tool({
+    description: 'Send OpenTelemetry Protocol (OTLP) v1 logs to Grafana Loki for ingestion and storage.',
+    inputSchema: z.object({
+        grafanaCredentials: z.string().describe('Grafana credentials JSON with baseUrl and optional apiToken'),
+        resourceLogs: z
+            .array(z.record(z.any()))
+            .describe('List of resource logs to send to Grafana Loki in OTLP format'),
+    }),
+    execute: async ({ grafanaCredentials, resourceLogs }) => {
+        try {
+            const result = await grafanaRequest(grafanaCredentials, '/otlp/v1/logs', {
+                method: 'POST',
+                body: { resourceLogs },
+                contentType: 'application/json',
+            });
+            if (!result.ok) {
+                return {
+                    error: 'Failed to create OTLP v1 logs',
+                    details: result.data,
+                    statusCode: result.status,
+                };
+            }
+            return {
+                success: true,
+                statusCode: result.status,
+                message: 'Logs ingested successfully',
+            };
+        }
+        catch (error) {
+            return {
+                error: 'Error creating OTLP v1 logs',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=create-otlp-v1-logs.js.map

package/dist/toolkits/grafana/tools/get-distributor-ha-tracker.d.ts

@@ -0,0 +1,22 @@
+export declare const getDistributorHaTracker: import("ai").Tool<{
+    grafanaCredentials: string;
+}, {
+    error: string;
+    details: any;
+    statusCode: number;
+    htmlContent?: undefined;
+    message?: undefined;
+} | {
+    statusCode: number;
+    htmlContent: any;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    statusCode?: undefined;
+    htmlContent?: undefined;
+}>;
+//# sourceMappingURL=get-distributor-ha-tracker.d.ts.map

package/dist/toolkits/grafana/tools/get-distributor-ha-tracker.js

@@ -0,0 +1,33 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { grafanaRequest } from './utils.js';
+export const getDistributorHaTracker = tool({
+    description: 'Retrieve distributor HA tracker status showing which replica is elected leader for each Prometheus HA cluster.',
+    inputSchema: z.object({
+        grafanaCredentials: z.string().describe('Grafana credentials JSON with baseUrl and optional apiToken'),
+    }),
+    execute: async ({ grafanaCredentials }) => {
+        try {
+            const result = await grafanaRequest(grafanaCredentials, '/distributor/ha_tracker');
+            if (!result.ok) {
+                return {
+                    error: 'Failed to get distributor HA tracker status',
+                    details: result.data,
+                    statusCode: result.status,
+                };
+            }
+            return {
+                statusCode: result.status,
+                htmlContent: result.data,
+            };
+        }
+        catch (error) {
+            return {
+                error: 'Error getting distributor HA tracker status',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=get-distributor-ha-tracker.js.map

package/dist/toolkits/grafana/tools/get-health.d.ts

@@ -0,0 +1,4 @@
+export declare const getHealth: import("ai").Tool<{
+    grafanaCredentials: string;
+}, any>;
+//# sourceMappingURL=get-health.d.ts.map

package/dist/toolkits/grafana/tools/get-health.js

@@ -0,0 +1,32 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { grafanaRequest } from './utils.js';
+export const getHealth = tool({
+    description: 'Check Grafana server health and database connectivity. Returns ok if the web server is running and can access the database.',
+    inputSchema: z.object({
+        grafanaCredentials: z.string().describe('Grafana credentials JSON with baseUrl and optional apiToken'),
+    }),
+    execute: async ({ grafanaCredentials }) => {
+        try {
+            const result = await grafanaRequest(grafanaCredentials, '/api/health', {
+                acceptJson: true,
+            });
+            if (!result.ok) {
+                return {
+                    error: 'Failed to get Grafana health status',
+                    details: result.data,
+                    statusCode: result.status,
+                };
+            }
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error getting Grafana health status',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=get-health.js.map

package/dist/toolkits/grafana/tools/get-index-gateway-ring.d.ts

@@ -0,0 +1,22 @@
+export declare const getIndexGatewayRing: import("ai").Tool<{
+    grafanaCredentials: string;
+}, {
+    error: string;
+    details: any;
+    statusCode: number;
+    htmlContent?: undefined;
+    message?: undefined;
+} | {
+    statusCode: number;
+    htmlContent: any;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    statusCode?: undefined;
+    htmlContent?: undefined;
+}>;
+//# sourceMappingURL=get-index-gateway-ring.d.ts.map

package/dist/toolkits/grafana/tools/get-index-gateway-ring.js

@@ -0,0 +1,33 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { grafanaRequest } from './utils.js';
+export const getIndexGatewayRing = tool({
+    description: 'Retrieve index gateway hash ring status including state, health, and last heartbeat of each node.',
+    inputSchema: z.object({
+        grafanaCredentials: z.string().describe('Grafana credentials JSON with baseUrl and optional apiToken'),
+    }),
+    execute: async ({ grafanaCredentials }) => {
+        try {
+            const result = await grafanaRequest(grafanaCredentials, '/indexgateway/ring');
+            if (!result.ok) {
+                return {
+                    error: 'Failed to get index gateway ring status',
+                    details: result.data,
+                    statusCode: result.status,
+                };
+            }
+            return {
+                statusCode: result.status,
+                htmlContent: result.data,
+            };
+        }
+        catch (error) {
+            return {
+                error: 'Error getting index gateway ring status',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=get-index-gateway-ring.js.map

package/dist/toolkits/grafana/tools/get-overrides-exporter-ring.d.ts

@@ -0,0 +1,22 @@
+export declare const getOverridesExporterRing: import("ai").Tool<{
+    grafanaCredentials: string;
+}, {
+    error: string;
+    details: any;
+    statusCode: number;
+    htmlContent?: undefined;
+    message?: undefined;
+} | {
+    statusCode: number;
+    htmlContent: any;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    statusCode?: undefined;
+    htmlContent?: undefined;
+}>;
+//# sourceMappingURL=get-overrides-exporter-ring.d.ts.map

package/dist/toolkits/grafana/tools/get-overrides-exporter-ring.js

@@ -0,0 +1,33 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { grafanaRequest } from './utils.js';
+export const getOverridesExporterRing = tool({
+    description: 'Retrieve overrides-exporter hash ring status including state, health, and last heartbeat of each node.',
+    inputSchema: z.object({
+        grafanaCredentials: z.string().describe('Grafana credentials JSON with baseUrl and optional apiToken'),
+    }),
+    execute: async ({ grafanaCredentials }) => {
+        try {
+            const result = await grafanaRequest(grafanaCredentials, '/overrides-exporter/ring');
+            if (!result.ok) {
+                return {
+                    error: 'Failed to get overrides-exporter ring status',
+                    details: result.data,
+                    statusCode: result.status,
+                };
+            }
+            return {
+                statusCode: result.status,
+                htmlContent: result.data,
+            };
+        }
+        catch (error) {
+            return {
+                error: 'Error getting overrides-exporter ring status',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=get-overrides-exporter-ring.js.map

package/dist/toolkits/grafana/tools/get-ruler-ring.d.ts

@@ -0,0 +1,22 @@
+export declare const getRulerRing: import("ai").Tool<{
+    grafanaCredentials: string;
+}, {
+    error: string;
+    details: any;
+    statusCode: number;
+    htmlContent?: undefined;
+    message?: undefined;
+} | {
+    statusCode: number;
+    htmlContent: any;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    statusCode?: undefined;
+    htmlContent?: undefined;
+}>;
+//# sourceMappingURL=get-ruler-ring.d.ts.map

package/dist/toolkits/grafana/tools/get-ruler-ring.js

@@ -0,0 +1,33 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { grafanaRequest } from './utils.js';
+export const getRulerRing = tool({
+    description: 'Retrieve ruler hash ring status including state, health, and last heartbeat of each ruler node.',
+    inputSchema: z.object({
+        grafanaCredentials: z.string().describe('Grafana credentials JSON with baseUrl and optional apiToken'),
+    }),
+    execute: async ({ grafanaCredentials }) => {
+        try {
+            const result = await grafanaRequest(grafanaCredentials, '/ruler/ring');
+            if (!result.ok) {
+                return {
+                    error: 'Failed to get ruler ring status',
+                    details: result.data,
+                    statusCode: result.status,
+                };
+            }
+            return {
+                statusCode: result.status,
+                htmlContent: result.data,
+            };
+        }
+        catch (error) {
+            return {
+                error: 'Error getting ruler ring status',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=get-ruler-ring.js.map

package/dist/toolkits/grafana/tools/get-status.d.ts

@@ -0,0 +1,22 @@
+export declare const getStatus: import("ai").Tool<{
+    grafanaCredentials: string;
+}, {
+    error: string;
+    details: any;
+    statusCode: number;
+    licenseAvailable?: undefined;
+    message?: undefined;
+} | {
+    licenseAvailable: any;
+    error?: undefined;
+    details?: undefined;
+    statusCode?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    statusCode?: undefined;
+    licenseAvailable?: undefined;
+}>;
+//# sourceMappingURL=get-status.d.ts.map

package/dist/toolkits/grafana/tools/get-status.js

@@ -0,0 +1,35 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { grafanaRequest } from './utils.js';
+export const getStatus = tool({
+    description: 'Check if a valid Grafana Enterprise license is available on the instance.',
+    inputSchema: z.object({
+        grafanaCredentials: z.string().describe('Grafana credentials JSON with baseUrl and apiToken'),
+    }),
+    execute: async ({ grafanaCredentials }) => {
+        try {
+            const result = await grafanaRequest(grafanaCredentials, '/api/licensing/check', {
+                acceptJson: true,
+            });
+            if (!result.ok) {
+                return {
+                    error: 'Failed to get license status',
+                    details: result.data,
+                    statusCode: result.status,
+                };
+            }
+            const licenseAvailable = typeof result.data === 'boolean'
+                ? result.data
+                : result.data?.license_available ?? result.data?.licenseAvailable ?? false;
+            return { licenseAvailable };
+        }
+        catch (error) {
+            return {
+                error: 'Error getting license status',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=get-status.js.map

package/dist/toolkits/grafana/tools/get-store-gateway-tenants.d.ts

@@ -0,0 +1,25 @@
+export declare const getStoreGatewayTenants: import("ai").Tool<{
+    grafanaCredentials: string;
+}, {
+    error: string;
+    details: any;
+    statusCode: number;
+    content?: undefined;
+    contentType?: undefined;
+    message?: undefined;
+} | {
+    content: any;
+    contentType: string;
+    error?: undefined;
+    details?: undefined;
+    statusCode?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    statusCode?: undefined;
+    content?: undefined;
+    contentType?: undefined;
+}>;
+//# sourceMappingURL=get-store-gateway-tenants.d.ts.map

package/dist/toolkits/grafana/tools/get-store-gateway-tenants.js

@@ -0,0 +1,33 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { grafanaRequest } from './utils.js';
+export const getStoreGatewayTenants = tool({
+    description: 'Retrieve store gateway tenants that have blocks stored in the configured storage.',
+    inputSchema: z.object({
+        grafanaCredentials: z.string().describe('Grafana credentials JSON with baseUrl and optional apiToken'),
+    }),
+    execute: async ({ grafanaCredentials }) => {
+        try {
+            const result = await grafanaRequest(grafanaCredentials, '/store-gateway/tenants');
+            if (!result.ok) {
+                return {
+                    error: 'Failed to get store gateway tenants',
+                    details: result.data,
+                    statusCode: result.status,
+                };
+            }
+            return {
+                content: result.data,
+                contentType: result.contentType,
+            };
+        }
+        catch (error) {
+            return {
+                error: 'Error getting store gateway tenants',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=get-store-gateway-tenants.js.map

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

@@ -0,0 +1,183 @@
+import { createOtlpV1Logs } from './create-otlp-v1-logs.js';
+import { getDistributorHaTracker } from './get-distributor-ha-tracker.js';
+import { getHealth } from './get-health.js';
+import { getIndexGatewayRing } from './get-index-gateway-ring.js';
+import { getOverridesExporterRing } from './get-overrides-exporter-ring.js';
+import { getRulerRing } from './get-ruler-ring.js';
+import { getStatus } from './get-status.js';
+import { getStoreGatewayTenants } from './get-store-gateway-tenants.js';
+import { postAcs } from './post-acs.js';
+import { queryPublicDashboard } from './query-public-dashboard.js';
+import { retrieveJwks } from './retrieve-jwks.js';
+export { createOtlpV1Logs, getDistributorHaTracker, getHealth, getIndexGatewayRing, getOverridesExporterRing, getRulerRing, getStatus, getStoreGatewayTenants, postAcs, queryPublicDashboard, retrieveJwks, };
+export declare const grafanaTools: ({
+    name: string;
+    description: string;
+    tool: 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;
+    }>;
+    requiredAuth: "grafanaCredentials";
+    scope: "write";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        grafanaCredentials: string;
+    }, {
+        error: string;
+        details: any;
+        statusCode: number;
+        htmlContent?: undefined;
+        message?: undefined;
+    } | {
+        statusCode: number;
+        htmlContent: any;
+        error?: undefined;
+        details?: undefined;
+        message?: undefined;
+    } | {
+        error: string;
+        message: string;
+        details?: undefined;
+        statusCode?: undefined;
+        htmlContent?: undefined;
+    }>;
+    requiredAuth: "grafanaCredentials";
+    scope: "read";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        grafanaCredentials: string;
+    }, any>;
+    requiredAuth: "grafanaCredentials";
+    scope: "read";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        grafanaCredentials: string;
+    }, {
+        error: string;
+        details: any;
+        statusCode: number;
+        licenseAvailable?: undefined;
+        message?: undefined;
+    } | {
+        licenseAvailable: any;
+        error?: undefined;
+        details?: undefined;
+        statusCode?: undefined;
+        message?: undefined;
+    } | {
+        error: string;
+        message: string;
+        details?: undefined;
+        statusCode?: undefined;
+        licenseAvailable?: undefined;
+    }>;
+    requiredAuth: "grafanaCredentials";
+    scope: "read";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        grafanaCredentials: string;
+    }, {
+        error: string;
+        details: any;
+        statusCode: number;
+        content?: undefined;
+        contentType?: undefined;
+        message?: undefined;
+    } | {
+        content: any;
+        contentType: string;
+        error?: undefined;
+        details?: undefined;
+        statusCode?: undefined;
+        message?: undefined;
+    } | {
+        error: string;
+        message: string;
+        details?: undefined;
+        statusCode?: undefined;
+        content?: undefined;
+        contentType?: undefined;
+    }>;
+    requiredAuth: "grafanaCredentials";
+    scope: "read";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        grafanaCredentials: string;
+        samlResponse: string;
+        relayState?: string | undefined;
+    }, {
+        statusCode: number;
+        message: string;
+        location: string;
+        error?: undefined;
+    } | {
+        error: string;
+        message: string;
+        statusCode?: undefined;
+        location?: undefined;
+    }>;
+    requiredAuth: "grafanaCredentials";
+    scope: "write";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        from: string;
+        to: string;
+        grafanaCredentials: string;
+        accessToken: string;
+        panelId: number;
+        intervalMs?: number | undefined;
+        maxDataPoints?: number | undefined;
+        baseUrlOverride?: string | undefined;
+    }, {
+        error: string;
+        details: any;
+        statusCode: number;
+        results?: undefined;
+        message?: undefined;
+    } | {
+        statusCode: number;
+        results: any;
+        error?: undefined;
+        details?: undefined;
+        message?: undefined;
+    } | {
+        error: string;
+        message: string;
+        details?: undefined;
+        statusCode?: undefined;
+        results?: undefined;
+    }>;
+    requiredAuth: "grafanaCredentials";
+    scope: "read";
+})[];
+//# sourceMappingURL=index.d.ts.map