@rnsk/toolkits 0.0.6 → 0.0.8

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

package/dist/toolkits/grafana/tools/index.js

@@ -0,0 +1,93 @@
+// @ts-nocheck
+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 const grafanaTools = [
+    {
+        name: 'grafanaCreateOtlpV1Logs',
+        description: 'Send OpenTelemetry Protocol (OTLP) v1 logs to Grafana Loki for ingestion and storage.',
+        tool: createOtlpV1Logs,
+        requiredAuth: 'grafanaCredentials',
+        scope: 'write',
+    },
+    {
+        name: 'grafanaGetDistributorHaTracker',
+        description: 'Retrieve distributor HA tracker status showing which replica is elected leader for each Prometheus HA cluster.',
+        tool: getDistributorHaTracker,
+        requiredAuth: 'grafanaCredentials',
+        scope: 'read',
+    },
+    {
+        name: 'grafanaGetHealth',
+        description: 'Check Grafana server health and database connectivity. Returns ok if the web server is running and can access the database.',
+        tool: getHealth,
+        requiredAuth: 'grafanaCredentials',
+        scope: 'read',
+    },
+    {
+        name: 'grafanaGetIndexGatewayRing',
+        description: 'Retrieve index gateway hash ring status including state, health, and last heartbeat of each node.',
+        tool: getIndexGatewayRing,
+        requiredAuth: 'grafanaCredentials',
+        scope: 'read',
+    },
+    {
+        name: 'grafanaGetOverridesExporterRing',
+        description: 'Retrieve overrides-exporter hash ring status including state, health, and last heartbeat of each node.',
+        tool: getOverridesExporterRing,
+        requiredAuth: 'grafanaCredentials',
+        scope: 'read',
+    },
+    {
+        name: 'grafanaGetRulerRing',
+        description: 'Retrieve ruler hash ring status including state, health, and last heartbeat of each ruler node.',
+        tool: getRulerRing,
+        requiredAuth: 'grafanaCredentials',
+        scope: 'read',
+    },
+    {
+        name: 'grafanaGetStatus',
+        description: 'Check if a valid Grafana Enterprise license is available on the instance.',
+        tool: getStatus,
+        requiredAuth: 'grafanaCredentials',
+        scope: 'read',
+    },
+    {
+        name: 'grafanaGetStoreGatewayTenants',
+        description: 'Retrieve store gateway tenants that have blocks stored in the configured storage.',
+        tool: getStoreGatewayTenants,
+        requiredAuth: 'grafanaCredentials',
+        scope: 'read',
+    },
+    {
+        name: 'grafanaPostAcs',
+        description: 'Perform SAML Assertion Consumer Service (ACS) operation when processing authentication responses from an identity provider.',
+        tool: postAcs,
+        requiredAuth: 'grafanaCredentials',
+        scope: 'write',
+    },
+    {
+        name: 'grafanaQueryPublicDashboard',
+        description: 'Query a panel on a public Grafana dashboard to retrieve time-series data and metrics for a specified time range.',
+        tool: queryPublicDashboard,
+        requiredAuth: 'grafanaCredentials',
+        scope: 'read',
+    },
+    {
+        name: 'grafanaRetrieveJwks',
+        description: 'Retrieve JSON Web Key Set (JWKS) with all public keys that can be used to verify JWT tokens.',
+        tool: retrieveJwks,
+        requiredAuth: 'grafanaCredentials',
+        scope: 'read',
+    },
+];
+//# sourceMappingURL=index.js.map

package/dist/toolkits/grafana/tools/post-acs.d.ts

@@ -0,0 +1,16 @@
+export declare const postAcs: 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;
+}>;
+//# sourceMappingURL=post-acs.d.ts.map

package/dist/toolkits/grafana/tools/post-acs.js

@@ -0,0 +1,44 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { grafanaRequest } from './utils.js';
+export const postAcs = tool({
+    description: 'Perform SAML Assertion Consumer Service (ACS) operation when processing authentication responses from an identity provider.',
+    inputSchema: z.object({
+        grafanaCredentials: z.string().describe('Grafana credentials JSON with baseUrl'),
+        samlResponse: z
+            .string()
+            .describe('Base64-encoded SAML Response from the Identity Provider'),
+        relayState: z
+            .string()
+            .optional()
+            .describe('Optional relay state parameter for the SAML authentication flow'),
+    }),
+    execute: async ({ grafanaCredentials, samlResponse, relayState }) => {
+        try {
+            const params = new URLSearchParams({ SAMLResponse: samlResponse });
+            if (relayState) {
+                params.set('RelayState', relayState);
+            }
+            const result = await grafanaRequest(grafanaCredentials, '/login/saml/acs', {
+                method: 'POST',
+                body: params.toString(),
+                contentType: 'application/x-www-form-urlencoded',
+            });
+            return {
+                statusCode: result.status,
+                message: result.status === 302
+                    ? 'SAML ACS processed successfully with redirect'
+                    : 'SAML ACS request completed',
+                location: result.headers?.location ?? result.headers?.Location,
+            };
+        }
+        catch (error) {
+            return {
+                error: 'Error performing SAML ACS operation',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=post-acs.js.map

package/dist/toolkits/grafana/tools/query-public-dashboard.d.ts

@@ -0,0 +1,29 @@
+export declare const queryPublicDashboard: 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;
+}>;
+//# sourceMappingURL=query-public-dashboard.d.ts.map

package/dist/toolkits/grafana/tools/query-public-dashboard.js

@@ -0,0 +1,70 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { grafanaRequest } from './utils.js';
+export const queryPublicDashboard = tool({
+    description: 'Query a panel on a public Grafana dashboard to retrieve time-series data and metrics for a specified time range.',
+    inputSchema: z.object({
+        grafanaCredentials: z.string().describe('Grafana credentials JSON with baseUrl'),
+        accessToken: z.string().describe('Public dashboard access token'),
+        panelId: z.number().int().min(1).describe('Panel ID to query within the dashboard'),
+        from: z
+            .string()
+            .describe("Start time for the query, e.g. 'now-6h' or an epoch millisecond timestamp"),
+        to: z
+            .string()
+            .describe("End time for the query, e.g. 'now' or an epoch millisecond timestamp"),
+        intervalMs: z
+            .number()
+            .int()
+            .min(1)
+            .optional()
+            .describe('Time interval between data points in milliseconds'),
+        maxDataPoints: z
+            .number()
+            .int()
+            .min(1)
+            .optional()
+            .describe('Maximum number of data points to return'),
+        baseUrlOverride: z
+            .string()
+            .optional()
+            .describe('Optional base URL override for the Grafana instance hosting the public dashboard'),
+    }),
+    execute: async ({ grafanaCredentials, accessToken, panelId, from, to, intervalMs, maxDataPoints, baseUrlOverride, }) => {
+        try {
+            const body = {
+                timeRange: { from, to },
+            };
+            if (intervalMs !== undefined)
+                body.intervalMs = intervalMs;
+            if (maxDataPoints !== undefined)
+                body.maxDataPoints = maxDataPoints;
+            const result = await grafanaRequest(grafanaCredentials, `/api/public/dashboards/${accessToken}/panels/${panelId}/query`, {
+                method: 'POST',
+                body,
+                contentType: 'application/json',
+                acceptJson: true,
+                baseUrlOverride,
+            });
+            if (!result.ok) {
+                return {
+                    error: 'Failed to query public dashboard panel',
+                    details: result.data,
+                    statusCode: result.status,
+                };
+            }
+            return {
+                statusCode: result.status,
+                results: result.data?.results ?? result.data,
+            };
+        }
+        catch (error) {
+            return {
+                error: 'Error querying public dashboard panel',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=query-public-dashboard.js.map

package/dist/toolkits/grafana/tools/retrieve-jwks.d.ts

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

package/dist/toolkits/grafana/tools/retrieve-jwks.js

@@ -0,0 +1,32 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { grafanaRequest } from './utils.js';
+export const retrieveJwks = tool({
+    description: 'Retrieve JSON Web Key Set (JWKS) with all public keys that can be used to verify JWT tokens.',
+    inputSchema: z.object({
+        grafanaCredentials: z.string().describe('Grafana credentials JSON with baseUrl'),
+    }),
+    execute: async ({ grafanaCredentials }) => {
+        try {
+            const result = await grafanaRequest(grafanaCredentials, '/api/signing-keys/keys', {
+                acceptJson: true,
+            });
+            if (!result.ok) {
+                return {
+                    error: 'Failed to retrieve JWKS',
+                    details: result.data,
+                    statusCode: result.status,
+                };
+            }
+            return result.data;
+        }
+        catch (error) {
+            return {
+                error: 'Error retrieving JWKS',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=retrieve-jwks.js.map

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

@@ -0,0 +1,21 @@
+export interface GrafanaCredentials {
+    baseUrl: string;
+    apiToken?: string;
+}
+export declare function parseGrafanaCredentials(grafanaCredentials: string): GrafanaCredentials;
+export declare function grafanaRequest(grafanaCredentials: string, path: string, options?: {
+    method?: string;
+    body?: unknown;
+    contentType?: string;
+    acceptJson?: boolean;
+    baseUrlOverride?: string;
+}): Promise<{
+    ok: boolean;
+    status: number;
+    data: any;
+    contentType: string;
+    headers: {
+        [k: string]: string;
+    };
+}>;
+//# sourceMappingURL=utils.d.ts.map

package/dist/toolkits/grafana/tools/utils.js

@@ -0,0 +1,48 @@
+// @ts-nocheck
+export function parseGrafanaCredentials(grafanaCredentials) {
+    const parsed = JSON.parse(grafanaCredentials);
+    if (!parsed.baseUrl) {
+        throw new Error('Grafana credentials must include baseUrl');
+    }
+    return {
+        baseUrl: parsed.baseUrl.replace(/\/+$/, ''),
+        apiToken: parsed.apiToken,
+    };
+}
+function buildHeaders(credentials, options) {
+    const headers = {};
+    if (options?.contentType) {
+        headers['Content-Type'] = options.contentType;
+    }
+    if (options?.acceptJson) {
+        headers.Accept = 'application/json';
+    }
+    if (credentials.apiToken) {
+        headers.Authorization = `Bearer ${credentials.apiToken}`;
+    }
+    return headers;
+}
+export async function grafanaRequest(grafanaCredentials, path, options) {
+    const credentials = parseGrafanaCredentials(grafanaCredentials);
+    const baseUrl = (options?.baseUrlOverride ?? credentials.baseUrl).replace(/\/+$/, '');
+    const url = `${baseUrl}${path.startsWith('/') ? path : `/${path}`}`;
+    const fetchOptions = {
+        method: options?.method ?? 'GET',
+        headers: buildHeaders(credentials, options),
+        redirect: 'manual',
+    };
+    if (options?.body !== undefined) {
+        fetchOptions.body =
+            typeof options.body === 'string' ? options.body : JSON.stringify(options.body);
+    }
+    const response = await fetch(url, fetchOptions);
+    const contentType = response.headers.get('content-type') ?? '';
+    const headers = Object.fromEntries(response.headers.entries());
+    if (contentType.includes('application/json')) {
+        const data = await response.json().catch(() => null);
+        return { ok: response.ok, status: response.status, data, contentType, headers };
+    }
+    const text = await response.text();
+    return { ok: response.ok, status: response.status, data: text, contentType, headers };
+}
+//# sourceMappingURL=utils.js.map

package/dist/toolkits/groww/icon.d.ts

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

package/dist/toolkits/groww/icon.js

@@ -0,0 +1,21 @@
+const SVG = `<svg id="Layer_1" xmlns="http://www.w3.org/2000/svg" version="1.1" viewBox="0 0 150 150">
+  
+  <defs>
+    <style>
+      .st0 {
+        fill: #4e68ff;
+      }
+
+      .st1 {
+        fill: #00f6b6;
+      }
+    </style>
+  </defs>
+  <path class="st0" d="M92.23,147.97c40.31-9.52,65.27-49.9,55.75-90.2C138.46,17.47,98.07-7.49,57.77,2.02,17.47,11.54-7.49,51.93,2.02,92.23c9.52,40.3,49.91,65.26,90.2,55.74Z"/>
+  <path class="st1" d="M147.98,57.77c-1.36-5.77-3.35-11.21-5.88-16.3l-.02.02-47.22,43.65c-2.95,2.73-7.34,3.2-10.81,1.17l-20.07-11.75c-3.25-1.89-7.32-1.61-10.26.72-12.43,9.84-44.26,35.01-44.71,35.38,15.7,29.11,49.48,45.29,83.22,37.31,40.31-9.52,65.27-49.9,55.75-90.2Z"/>
+</svg>`;
+export const GROWW_ICON = {
+    kind: 'svg',
+    dataUri: `data:image/svg+xml;base64,${Buffer.from(SVG).toString('base64')}`,
+};
+//# sourceMappingURL=icon.js.map

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

@@ -0,0 +1,32 @@
+import { defineToolkit, defineTool } from '../../core/define.js';
+import { GROWW_ICON } from './icon.js';
+import { growwTools } from './tools/index.js';
+export default defineToolkit({
+    id: 'groww',
+    displayName: 'Groww',
+    shortDescription: 'Trade equities and F&O, manage orders and smart orders, and fetch live market data.',
+    category: 'Finance & Accounting',
+    icon: GROWW_ICON,
+    auth: {
+        type: 'bearer_token',
+        tokenField: 'growwAccessToken',
+        provider: {
+            connectDescription: 'Connect Groww with a Trading API access token. Generate one from Groww Profile > Settings > Trading APIs > Generate API keys > Access Token (expires daily at 6:00 AM). Alternatively generate it via your API key + secret checksum or TOTP flow, then paste the access token here. All trading calls send it as Authorization: Bearer <token> with X-API-VERSION: 1.0.',
+        },
+    },
+    allowedHosts: ['api.groww.in', 'growwapi-assets.groww.in'],
+    tools: growwTools.map((entry) => defineTool({
+        name: entry.name,
+        description: entry.description,
+        tool: entry.tool,
+        requiredAuth: entry.requiredAuth,
+        scope: entry.scope,
+    })),
+    meta: {
+        since: '0.0.7',
+        homepage: 'https://groww.in',
+        docsUrl: 'https://groww.in/trade-api/docs/curl',
+        apiDocsUrl: 'https://groww.in/trade-api/docs/curl',
+    },
+});
+//# sourceMappingURL=manifest.js.map

package/dist/toolkits/groww/tools/historical.d.ts

@@ -0,0 +1,32 @@
+export declare const growwGetHistoricalCandles: import("ai").Tool<{
+    exchange: string;
+    segment: string;
+    groww_symbol: string;
+    start_time: string;
+    end_time: string;
+    candle_interval: string;
+    growwAccessToken?: string | undefined;
+}, unknown>;
+export declare const growwGetHistoricalCandleRange: import("ai").Tool<{
+    trading_symbol: string;
+    exchange: string;
+    segment: string;
+    start_time: string;
+    end_time: string;
+    growwAccessToken?: string | undefined;
+    interval_in_minutes?: string | undefined;
+}, unknown>;
+export declare const growwGetExpiries: import("ai").Tool<{
+    exchange: string;
+    underlying_symbol: string;
+    year?: number | undefined;
+    month?: number | undefined;
+    growwAccessToken?: string | undefined;
+}, unknown>;
+export declare const growwGetContracts: import("ai").Tool<{
+    exchange: string;
+    expiry_date: string;
+    underlying_symbol: string;
+    growwAccessToken?: string | undefined;
+}, unknown>;
+//# sourceMappingURL=historical.d.ts.map