@rnsk/toolkits 0.0.10 → 0.0.12

package/dist/toolkits/prometheus/tools/status.js

@@ -0,0 +1,248 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { promRequest, toPromError } from './client.js';
+const credsField = z.string().describe('Prometheus credentials JSON with baseUrl and optional username/password or bearerToken');
+export const statusConfig = tool({
+    description: 'Returns the loaded Prometheus configuration as dumped YAML (comments not included).',
+    inputSchema: z.object({
+        prometheusCredentials: credsField,
+    }),
+    execute: async ({ prometheusCredentials }) => {
+        try {
+            return await promRequest(prometheusCredentials, '/api/v1/status/config');
+        }
+        catch (error) {
+            return toPromError(error, 'Failed to get status config');
+        }
+    },
+});
+export const statusFlags = tool({
+    description: 'Returns flag values the server was started with (all values are strings).',
+    inputSchema: z.object({
+        prometheusCredentials: credsField,
+    }),
+    execute: async ({ prometheusCredentials }) => {
+        try {
+            return await promRequest(prometheusCredentials, '/api/v1/status/flags');
+        }
+        catch (error) {
+            return toPromError(error, 'Failed to get status flags');
+        }
+    },
+});
+export const statusRuntimeInfo = tool({
+    description: 'Returns runtime info (start time, uptime data, goroutines, series count, retention). Fields may change between versions.',
+    inputSchema: z.object({
+        prometheusCredentials: credsField,
+    }),
+    execute: async ({ prometheusCredentials }) => {
+        try {
+            return await promRequest(prometheusCredentials, '/api/v1/status/runtimeinfo');
+        }
+        catch (error) {
+            return toPromError(error, 'Failed to get runtime info');
+        }
+    },
+});
+export const statusBuildInfo = tool({
+    description: 'Returns build info (version, revision, branch, build date, Go version).',
+    inputSchema: z.object({
+        prometheusCredentials: credsField,
+    }),
+    execute: async ({ prometheusCredentials }) => {
+        try {
+            return await promRequest(prometheusCredentials, '/api/v1/status/buildinfo');
+        }
+        catch (error) {
+            return toPromError(error, 'Failed to get build info');
+        }
+    },
+});
+export const statusTsdb = tool({
+    description: 'Returns TSDB cardinality stats (series count, per-metric/label breakdowns, memory use).',
+    inputSchema: z.object({
+        prometheusCredentials: credsField,
+        limit: z.number().int().min(1).max(10000).optional().describe('Items per stat set (default 10, max 10000)'),
+    }),
+    execute: async ({ prometheusCredentials, limit }) => {
+        try {
+            return await promRequest(prometheusCredentials, '/api/v1/status/tsdb', { query: { limit } });
+        }
+        catch (error) {
+            return toPromError(error, 'Failed to get TSDB stats');
+        }
+    },
+});
+export const statusTsdbBlocks = tool({
+    description: 'Lists loaded TSDB blocks with ULIDs, time ranges, and compaction info. Experimental; format may change.',
+    inputSchema: z.object({
+        prometheusCredentials: credsField,
+    }),
+    execute: async ({ prometheusCredentials }) => {
+        try {
+            return await promRequest(prometheusCredentials, '/api/v1/status/tsdb/blocks');
+        }
+        catch (error) {
+            return toPromError(error, 'Failed to get TSDB blocks');
+        }
+    },
+});
+export const statusWalReplay = tool({
+    description: 'Returns WAL replay progress (segments read/total, percent, state). Available before the server is marked ready.',
+    inputSchema: z.object({
+        prometheusCredentials: credsField,
+    }),
+    execute: async ({ prometheusCredentials }) => {
+        try {
+            return await promRequest(prometheusCredentials, '/api/v1/status/walreplay');
+        }
+        catch (error) {
+            return toPromError(error, 'Failed to get WAL replay stats');
+        }
+    },
+});
+export const statusSelfMetrics = tool({
+    description: 'Returns Prometheus internal metrics as structured JSON (same data as /metrics exposition). Experimental.',
+    inputSchema: z.object({
+        prometheusCredentials: credsField,
+    }),
+    execute: async ({ prometheusCredentials }) => {
+        try {
+            return await promRequest(prometheusCredentials, '/api/v1/status/self_metrics');
+        }
+        catch (error) {
+            return toPromError(error, 'Failed to get self metrics');
+        }
+    },
+});
+export const healthy = tool({
+    description: 'Health check: returns 200 when the server is healthy (no /api/v1 prefix). Use for liveness probes.',
+    inputSchema: z.object({
+        prometheusCredentials: credsField,
+    }),
+    execute: async ({ prometheusCredentials }) => {
+        try {
+            return await promRequest(prometheusCredentials, '/-/healthy');
+        }
+        catch (error) {
+            return toPromError(error, 'Health check failed');
+        }
+    },
+});
+export const ready = tool({
+    description: 'Readiness check: returns 200 when the server is ready to serve traffic (no /api/v1 prefix).',
+    inputSchema: z.object({
+        prometheusCredentials: credsField,
+    }),
+    execute: async ({ prometheusCredentials }) => {
+        try {
+            return await promRequest(prometheusCredentials, '/-/ready');
+        }
+        catch (error) {
+            return toPromError(error, 'Readiness check failed');
+        }
+    },
+});
+export const federate = tool({
+    description: 'Federation endpoint: returns selected series in exposition format for hierarchical federation. Requires at least one match[] selector.',
+    inputSchema: z.object({
+        prometheusCredentials: credsField,
+        match: z.array(z.string()).min(1).describe('Series selectors to federate (at least one required)'),
+    }),
+    execute: async ({ prometheusCredentials, match }) => {
+        try {
+            return await promRequest(prometheusCredentials, '/federate', {
+                query: { 'match[]': match },
+            });
+        }
+        catch (error) {
+            return toPromError(error, 'Failed to federate');
+        }
+    },
+});
+export const listNotifications = tool({
+    description: 'Lists current UI notifications (active alerts about the server itself, e.g. config issues).',
+    inputSchema: z.object({
+        prometheusCredentials: credsField,
+    }),
+    execute: async ({ prometheusCredentials }) => {
+        try {
+            return await promRequest(prometheusCredentials, '/api/v1/notifications');
+        }
+        catch (error) {
+            return toPromError(error, 'Failed to list notifications');
+        }
+    },
+});
+export const liveNotifications = tool({
+    description: 'Collects live UI notifications over Server-Sent Events for a bounded time. Active notifications arrive on connect; deletions arrive with active:false. The stream is time-boxed since SSE never ends on its own.',
+    inputSchema: z.object({
+        prometheusCredentials: credsField,
+        durationSeconds: z.number().min(1).max(120).optional().describe('How long to listen (1-120s, default 10)'),
+    }),
+    execute: async ({ prometheusCredentials, durationSeconds }) => {
+        const { parsePrometheusCredentials } = await import('./client.js');
+        let baseUrl;
+        let headers;
+        try {
+            const creds = parsePrometheusCredentials(prometheusCredentials);
+            baseUrl = creds.baseUrl;
+            headers = { Accept: 'text/event-stream' };
+            if (creds.bearerToken)
+                headers.Authorization = `Bearer ${creds.bearerToken}`;
+            else if (creds.username) {
+                headers.Authorization = `Basic ${Buffer.from(`${creds.username}:${creds.password ?? ''}`).toString('base64')}`;
+            }
+        }
+        catch (error) {
+            return toPromError(error, 'Failed to stream notifications');
+        }
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), (durationSeconds ?? 10) * 1000);
+        const events = [];
+        try {
+            const response = await fetch(`${baseUrl}/api/v1/notifications/live`, {
+                headers,
+                signal: controller.signal,
+            });
+            if (!response.ok || !response.body) {
+                return { error: 'Failed to stream notifications', status: response.status };
+            }
+            const reader = response.body.getReader();
+            const decoder = new TextDecoder();
+            let buffer = '';
+            for (;;) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                const parts = buffer.split('\n\n');
+                buffer = parts.pop() ?? '';
+                for (const part of parts) {
+                    const dataLines = part.split('\n').filter((l) => l.startsWith('data:'));
+                    for (const line of dataLines) {
+                        const payload = line.slice(5).trim();
+                        try {
+                            events.push(JSON.parse(payload));
+                        }
+                        catch {
+                            events.push({ raw: payload });
+                        }
+                    }
+                }
+            }
+            return { events };
+        }
+        catch (error) {
+            if (error?.name === 'AbortError') {
+                return { events, truncated: true };
+            }
+            return toPromError(error, 'Failed to stream notifications');
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    },
+});
+//# sourceMappingURL=status.js.map

package/dist/toolkits/prometheus/tools/targets.d.ts

@@ -0,0 +1,31 @@
+export declare const scrapePools: import("ai").Tool<{
+    prometheusCredentials: string;
+}, any>;
+export declare const targets: import("ai").Tool<{
+    prometheusCredentials: string;
+    state?: "active" | "any" | "dropped" | undefined;
+    scrapePool?: string | undefined;
+}, any>;
+export declare const targetRelabelSteps: import("ai").Tool<{
+    labels: string;
+    prometheusCredentials: string;
+    scrapePool: string;
+}, any>;
+export declare const rules: import("ai").Tool<{
+    prometheusCredentials: string;
+    type?: "alert" | "record" | undefined;
+    file?: string[] | undefined;
+    match?: string[] | undefined;
+    ruleName?: string[] | undefined;
+    ruleGroup?: string[] | undefined;
+    excludeAlerts?: boolean | undefined;
+    groupLimit?: number | undefined;
+    groupNextToken?: string | undefined;
+}, any>;
+export declare const alerts: import("ai").Tool<{
+    prometheusCredentials: string;
+}, any>;
+export declare const alertmanagers: import("ai").Tool<{
+    prometheusCredentials: string;
+}, any>;
+//# sourceMappingURL=targets.d.ts.map

package/dist/toolkits/prometheus/tools/targets.js

@@ -0,0 +1,117 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { promRequest, toPromError } from './client.js';
+const credsField = z.string().describe('Prometheus credentials JSON with baseUrl and optional username/password or bearerToken');
+export const scrapePools = tool({
+    description: 'Lists configured scrape pool names.',
+    inputSchema: z.object({
+        prometheusCredentials: credsField,
+    }),
+    execute: async ({ prometheusCredentials }) => {
+        try {
+            return await promRequest(prometheusCredentials, '/api/v1/scrape_pools');
+        }
+        catch (error) {
+            return toPromError(error, 'Failed to list scrape pools');
+        }
+    },
+});
+export const targets = tool({
+    description: 'Returns scrape target discovery state (active + dropped targets with health, labels, last scrape).',
+    inputSchema: z.object({
+        prometheusCredentials: credsField,
+        state: z.enum(['active', 'dropped', 'any']).optional().describe('Filter targets (default both)'),
+        scrapePool: z.string().optional().describe('Filter by scrape pool name'),
+    }),
+    execute: async ({ prometheusCredentials, state, scrapePool }) => {
+        try {
+            return await promRequest(prometheusCredentials, '/api/v1/targets', {
+                query: { state, scrapePool },
+            });
+        }
+        catch (error) {
+            return toPromError(error, 'Failed to get targets');
+        }
+    },
+});
+export const targetRelabelSteps = tool({
+    description: 'Shows step-by-step relabeling rules and their effect on a target label set. Experimental (web-UI oriented).',
+    inputSchema: z.object({
+        prometheusCredentials: credsField,
+        scrapePool: z.string().describe('Scrape pool name of the target'),
+        labels: z.string().describe('Pre-relabel label set as JSON, e.g. {"__address__":"localhost:9090","job":"prometheus"}'),
+    }),
+    execute: async ({ prometheusCredentials, scrapePool, labels }) => {
+        try {
+            return await promRequest(prometheusCredentials, '/api/v1/targets/relabel_steps', {
+                query: { scrapePool, labels },
+            });
+        }
+        catch (error) {
+            return toPromError(error, 'Failed to get relabel steps');
+        }
+    },
+});
+export const rules = tool({
+    description: 'Lists loaded alerting/recording rules with active alerts. Supports filtering by type, name, group, file, and labels.',
+    inputSchema: z.object({
+        prometheusCredentials: credsField,
+        type: z.enum(['alert', 'record']).optional().describe('Only alerting or recording rules'),
+        ruleName: z.array(z.string()).optional().describe('Filter by rule names'),
+        ruleGroup: z.array(z.string()).optional().describe('Filter by rule group names'),
+        file: z.array(z.string()).optional().describe('Filter by rule file paths'),
+        excludeAlerts: z.boolean().optional().describe('Omit active alerts, rules only'),
+        match: z.array(z.string()).optional().describe('Label selectors matched against rule definition labels'),
+        groupLimit: z.number().int().optional().describe('Rule groups per page (enables groupNextToken pagination)'),
+        groupNextToken: z.string().optional().describe('Pagination token from a previous response'),
+    }),
+    execute: async ({ prometheusCredentials, ruleName, ruleGroup, file, excludeAlerts, match, groupLimit, groupNextToken, type }) => {
+        try {
+            return await promRequest(prometheusCredentials, '/api/v1/rules', {
+                query: {
+                    type,
+                    'rule_name[]': ruleName,
+                    'rule_group[]': ruleGroup,
+                    'file[]': file,
+                    exclude_alerts: excludeAlerts,
+                    'match[]': match,
+                    group_limit: groupLimit,
+                    group_next_token: groupNextToken,
+                },
+            });
+        }
+        catch (error) {
+            return toPromError(error, 'Failed to list rules');
+        }
+    },
+});
+export const alerts = tool({
+    description: 'Lists all active alerts firing on this Prometheus instance.',
+    inputSchema: z.object({
+        prometheusCredentials: credsField,
+    }),
+    execute: async ({ prometheusCredentials }) => {
+        try {
+            return await promRequest(prometheusCredentials, '/api/v1/alerts');
+        }
+        catch (error) {
+            return toPromError(error, 'Failed to list alerts');
+        }
+    },
+});
+export const alertmanagers = tool({
+    description: 'Returns Alertmanager discovery state (active + dropped Alertmanagers).',
+    inputSchema: z.object({
+        prometheusCredentials: credsField,
+    }),
+    execute: async ({ prometheusCredentials }) => {
+        try {
+            return await promRequest(prometheusCredentials, '/api/v1/alertmanagers');
+        }
+        catch (error) {
+            return toPromError(error, 'Failed to get alertmanagers');
+        }
+    },
+});
+//# sourceMappingURL=targets.js.map

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

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

package/dist/toolkits/razorpay/icon.js

@@ -0,0 +1,33 @@
+const SVG = `<svg xmlns="http://www.w3.org/2000/svg" version="1.1" viewBox="0.00 0.00 163.00 163.00" width="128" height="128">
+<path fill="#3395ff" d="
+  M 109.19 163.00
+  L 79.18 163.00
+  L 108.75 53.30
+  A 0.26 0.26 0.0 0 0 108.36 53.02
+  L 65.13 80.79
+  A 0.64 0.64 0.0 0 1 64.16 80.09
+  Q 67.52 67.02 71.17 54.15
+  C 71.68 52.34 75.03 50.50 76.65 49.46
+  Q 110.50 27.67 151.94 0.83
+  A 0.49 0.49 0.0 0 1 152.68 1.37
+  L 109.19 163.00
+  Z"
+/>
+<path fill="#072654" d="
+  M 71.90 163.00
+  L 12.04 163.00
+  L 11.25 162.72
+  A 0.82 0.82 0.0 0 1 10.73 161.74
+  L 22.31 118.20
+  A 4.55 4.51 81.2 0 1 24.24 115.54
+  L 96.81 68.91
+  A 0.18 0.18 0.0 0 1 97.09 69.11
+  L 71.90 163.00
+  Z"
+/>
+</svg>`;
+export const RAZORPAY_ICON = {
+    kind: 'svg',
+    dataUri: `data:image/svg+xml;base64,${Buffer.from(SVG).toString('base64')}`,
+};
+//# sourceMappingURL=icon.js.map

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

@@ -0,0 +1,32 @@
+import { defineToolkit, defineTool } from '../../core/define.js';
+import { inferToolScope } from '../../core/scope.js';
+import { RAZORPAY_ICON } from './icon.js';
+import { razorpayTools } from './tools/index.js';
+export default defineToolkit({
+    id: 'razorpay',
+    displayName: 'Razorpay',
+    shortDescription: 'Manage orders, payments, invoices, payouts, and settlements.',
+    category: 'Finance & Accounting',
+    icon: RAZORPAY_ICON,
+    auth: {
+        type: 'basic_auth',
+        tokenField: 'razorpayCredentials',
+        provider: {
+            connectDescription: "Connect Razorpay with your key_id and key_secret (Dashboard > Settings > API Keys) stored as 'key_id:key_secret'. All APIs use Basic Auth (base64 of the pair) against https://api.razorpay.com/v1. OAuth (partner flow, auth.razorpay.com) is not used: it needs a partner application and its tokens expire hourly.",
+        },
+    },
+    allowedHosts: ['api.razorpay.com'],
+    tools: razorpayTools.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.11',
+        homepage: 'https://razorpay.com',
+        docsUrl: 'https://razorpay.com/docs/api',
+    },
+});
+//# sourceMappingURL=manifest.js.map

package/dist/toolkits/razorpay/tools/client.d.ts

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+export declare const RAZORPAY_API_BASE = "https://api.razorpay.com/v1";
+/** Raw 'key_id:key_secret' pair (Basic auth). Keys: Razorpay Dashboard > Settings > API Keys. */
+export declare const razorpayCredentialsField: z.ZodOptional<z.ZodString>;
+export declare function missingCredentials(): {
+    error: string;
+};
+export interface RazorpayRequestOptions {
+    method?: string;
+    query?: Record<string, string | number | boolean | undefined>;
+    body?: unknown;
+}
+export declare function razorpayRequest(credentials: string | undefined, path: string, options?: RazorpayRequestOptions, action?: string): Promise<any>;
+export declare const paginationFields: {
+    count: z.ZodOptional<z.ZodNumber>;
+    skip: z.ZodOptional<z.ZodNumber>;
+};
+export declare const timeRangeFields: {
+    from: z.ZodOptional<z.ZodNumber>;
+    to: z.ZodOptional<z.ZodNumber>;
+};
+/** Recursively convert camelCase keys to snake_case for Razorpay payloads. */
+export declare function toSnakeCase(value: unknown): unknown;
+//# sourceMappingURL=client.d.ts.map

package/dist/toolkits/razorpay/tools/client.js

@@ -0,0 +1,73 @@
+// @ts-nocheck
+import { z } from 'zod';
+export const RAZORPAY_API_BASE = 'https://api.razorpay.com/v1';
+/** Raw 'key_id:key_secret' pair (Basic auth). Keys: Razorpay Dashboard > Settings > API Keys. */
+export const razorpayCredentialsField = z
+    .string()
+    .optional()
+    .describe("Razorpay credentials as 'key_id:key_secret'. Injected at runtime.");
+export function missingCredentials() {
+    return { error: 'Razorpay credentials are required. Connect Razorpay first with your key_id and key_secret.' };
+}
+function basicHeader(credentials) {
+    return `Basic ${Buffer.from(credentials).toString('base64')}`;
+}
+export async function razorpayRequest(credentials, path, options, action = 'call Razorpay API') {
+    if (!credentials || !credentials.includes(':'))
+        return missingCredentials();
+    let url = `${RAZORPAY_API_BASE}${path}`;
+    if (options?.query) {
+        const search = new URLSearchParams();
+        for (const [k, v] of Object.entries(options.query)) {
+            if (v !== undefined)
+                search.set(k, String(v));
+        }
+        const qs = search.toString();
+        if (qs)
+            url += `?${qs}`;
+    }
+    const headers = {
+        Authorization: basicHeader(credentials),
+        Accept: 'application/json',
+    };
+    if (options?.body !== undefined)
+        headers['Content-Type'] = 'application/json';
+    try {
+        const response = await fetch(url, {
+            method: options?.method ?? 'GET',
+            headers,
+            body: options?.body !== undefined ? JSON.stringify(options.body) : undefined,
+        });
+        const data = await response.json().catch(() => ({}));
+        if (!response.ok || data?.error) {
+            return { error: `Failed to ${action}`, details: data };
+        }
+        return data;
+    }
+    catch (error) {
+        return { error: `Error while trying to ${action}`, message: error instanceof Error ? error.message : 'Unknown error' };
+    }
+}
+export const paginationFields = {
+    count: z.number().int().min(1).max(100).optional().describe('Records per page (default 10, max 100)'),
+    skip: z.number().int().min(0).optional().describe('Records to skip (default 0)'),
+};
+export const timeRangeFields = {
+    from: z.number().int().min(0).optional().describe('Unix seconds: records created on/after this time'),
+    to: z.number().int().min(0).optional().describe('Unix seconds: records created on/before this time'),
+};
+/** Recursively convert camelCase keys to snake_case for Razorpay payloads. */
+export function toSnakeCase(value) {
+    if (Array.isArray(value))
+        return value.map(toSnakeCase);
+    if (value && typeof value === 'object') {
+        const out = {};
+        for (const [k, v] of Object.entries(value)) {
+            const snake = k.replace(/([A-Z])/g, (m) => `_${m.toLowerCase()}`);
+            out[snake] = toSnakeCase(v);
+        }
+        return out;
+    }
+    return value;
+}
+//# sourceMappingURL=client.js.map

package/dist/toolkits/razorpay/tools/customers.d.ts

@@ -0,0 +1,29 @@
+export declare const createCustomer: import("ai").Tool<{
+    name?: string | undefined;
+    email?: string | undefined;
+    notes?: Record<string, any> | undefined;
+    razorpayCredentials?: string | undefined;
+    gstin?: string | undefined;
+    contact?: string | undefined;
+}, any>;
+export declare const getCustomer: import("ai").Tool<{
+    customerId: string;
+    razorpayCredentials?: string | undefined;
+}, any>;
+export declare const updateCustomer: import("ai").Tool<{
+    customerId: string;
+    name?: string | undefined;
+    email?: string | undefined;
+    razorpayCredentials?: string | undefined;
+    contact?: string | undefined;
+}, any>;
+export declare const fetchAllCustomers: import("ai").Tool<{
+    count?: number | undefined;
+    razorpayCredentials?: string | undefined;
+    skip?: number | undefined;
+}, any>;
+export declare const listCustomerTokens: import("ai").Tool<{
+    customerId: string;
+    razorpayCredentials?: string | undefined;
+}, any>;
+//# sourceMappingURL=customers.d.ts.map

package/dist/toolkits/razorpay/tools/customers.js

@@ -0,0 +1,53 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { paginationFields, razorpayCredentialsField, razorpayRequest } from './client.js';
+const customerFields = {
+    name: z.string().optional().describe('Customer name'),
+    email: z.string().optional().describe('Customer email'),
+    contact: z.string().optional().describe('Customer phone number'),
+};
+export const createCustomer = tool({
+    description: 'Registers a customer for recurring payments or saved cards. Returns a customer_id for future transactions.',
+    inputSchema: z.object({
+        razorpayCredentials: razorpayCredentialsField,
+        ...customerFields,
+        gstin: z.string().optional().describe('GSTIN (India-specific)'),
+        notes: z.record(z.any()).optional().describe('Custom metadata (string/integer/number values)'),
+    }),
+    execute: async ({ razorpayCredentials, ...body }) => razorpayRequest(razorpayCredentials, '/customers', { method: 'POST', body }, 'create customer'),
+});
+export const getCustomer = tool({
+    description: 'Reads one customer (name, email, contact, notes).',
+    inputSchema: z.object({
+        razorpayCredentials: razorpayCredentialsField,
+        customerId: z.string().regex(/^cust_[a-zA-Z0-9]+$/).describe("Customer ID, e.g. 'cust_SMoQL8RbRrw4w5'"),
+    }),
+    execute: async ({ razorpayCredentials, customerId }) => razorpayRequest(razorpayCredentials, `/customers/${customerId}`, undefined, 'get customer'),
+});
+export const updateCustomer = tool({
+    description: 'Updates customer name/email/contact. Only provided fields change.',
+    inputSchema: z.object({
+        razorpayCredentials: razorpayCredentialsField,
+        customerId: z.string().describe('Customer ID to update'),
+        ...customerFields,
+    }),
+    execute: async ({ razorpayCredentials, customerId, ...body }) => razorpayRequest(razorpayCredentials, `/customers/${customerId}`, { method: 'PATCH', body }, 'update customer'),
+});
+export const fetchAllCustomers = tool({
+    description: 'Lists customers with skip/count pagination (max 100 per page). Use to iterate the customer base.',
+    inputSchema: z.object({
+        razorpayCredentials: razorpayCredentialsField,
+        ...paginationFields,
+    }),
+    execute: async ({ razorpayCredentials, ...query }) => razorpayRequest(razorpayCredentials, '/customers', { query }, 'fetch customers'),
+});
+export const listCustomerTokens = tool({
+    description: 'Lists saved payment methods (card/emandate/nach/upi tokens with status and limits) for a customer.',
+    inputSchema: z.object({
+        razorpayCredentials: razorpayCredentialsField,
+        customerId: z.string().regex(/^cust_[a-zA-Z0-9]{14}$/).describe("Customer ID 'cust_' + 14 alphanumerics"),
+    }),
+    execute: async ({ razorpayCredentials, customerId }) => razorpayRequest(razorpayCredentials, `/customers/${customerId}/tokens`, undefined, 'list customer tokens'),
+});
+//# sourceMappingURL=customers.js.map

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

@@ -0,0 +1,16 @@
+import { createContact, getContact, getFundAccount, getSettlementRecon, getTransferReversals, listFundAccounts, listFundValidations, updateContact } from './payouts.js';
+import { createCustomer, fetchAllCustomers, getCustomer, listCustomerTokens, updateCustomer } from './customers.js';
+import { cancelInvoice, createInvoice, deleteInvoice, fetchAllInvoices, fetchInvoiceById, issueInvoice, sendInvoiceNotification, updateInvoice } from './invoices.js';
+import { cancelPaymentLink, createItem, createPaymentLink, deleteItem, fetchAllPaymentLinks, fetchPaymentLink, getItem, listItems, notifyPaymentLink, updateItem, updatePaymentLink } from './items-links.js';
+import { createOrder, fetchAllPayments, fetchAllRefundsForPayment, fetchOrderById, fetchOrders, fetchPaymentsByOrder, fetchRefunds, listDisputes, listPaymentDowntimes, updateOrder } from './orders.js';
+export { createOrder, fetchOrders, fetchOrderById, updateOrder, fetchPaymentsByOrder, fetchAllPayments, fetchAllRefundsForPayment, fetchRefunds, listDisputes, listPaymentDowntimes, createCustomer, getCustomer, updateCustomer, fetchAllCustomers, listCustomerTokens, createInvoice, fetchAllInvoices, fetchInvoiceById, updateInvoice, deleteInvoice, issueInvoice, cancelInvoice, sendInvoiceNotification, createItem, getItem, listItems, updateItem, deleteItem, createPaymentLink, fetchPaymentLink, fetchAllPaymentLinks, updatePaymentLink, cancelPaymentLink, notifyPaymentLink, createContact, getContact, updateContact, getFundAccount, listFundAccounts, listFundValidations, getTransferReversals, getSettlementRecon, };
+declare const auth: "razorpayCredentials";
+type Scope = 'read' | 'write' | 'delete';
+export declare const razorpayTools: {
+    name: string;
+    description: string;
+    tool: any;
+    requiredAuth: typeof auth;
+    scope: Scope;
+}[];
+//# sourceMappingURL=index.d.ts.map