@rnsk/toolkits 0.0.10 → 0.0.11

package/dist/toolkits/datadog/tools/dashboards.js

@@ -0,0 +1,127 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { ddApi, toDatadogError } from './client.js';
+const credsField = z.string().describe('Datadog credentials JSON with apiKey and appKey (injected by system)');
+const widgetSchema = z.object({
+    definition: z.record(z.any()).describe('Widget definition with type, requests, styling'),
+    id: z.number().optional().describe('Widget ID (auto-generated when omitted)'),
+    layout: z.record(z.any()).optional().describe('Layout (x, y, width, height for free layouts)'),
+});
+const templateVariableSchema = z.object({
+    name: z.string().describe('Variable name'),
+    prefix: z.string().optional().describe('Variable prefix'),
+    default: z.string().optional().describe('Default value'),
+    available_values: z.array(z.string()).optional().describe('Allowed values'),
+});
+export const datadogCreateDashboard = tool({
+    description: 'Create a dashboard with widgets for unified monitoring views. For log/APM/RUM widget queries keep group_by inside the query object, not at request level.',
+    inputSchema: z.object({
+        datadogCredentials: credsField,
+        title: z.string().min(1).max(80).describe('Dashboard title'),
+        widgets: z.array(widgetSchema).min(1).describe('Widgets to include'),
+        description: z.string().max(500).optional().describe('Dashboard description'),
+        layout_type: z.enum(['ordered', 'free']).optional().describe('Layout (default ordered)'),
+        tags: z.array(z.string()).optional().describe('Dashboard tags'),
+        notify_list: z.array(z.string()).optional().describe('Users to notify of changes'),
+        template_variables: z.array(templateVariableSchema).optional().describe('Template variables'),
+    }),
+    execute: async ({ datadogCredentials, ...body }) => {
+        try {
+            const data = await ddApi(datadogCredentials, 'POST', '/api/v1/dashboard', { body });
+            return { ...data, success: true };
+        }
+        catch (error) {
+            return toDatadogError(error, 'Failed to create dashboard');
+        }
+    },
+});
+export const datadogGetDashboard = tool({
+    description: 'Get a dashboard by ID with widgets, layout, and template variables. Keep reflow_type and pause_auto_refresh from the response for round-trip updates.',
+    inputSchema: z.object({
+        datadogCredentials: credsField,
+        dashboard_id: z.string().describe('Dashboard ID'),
+    }),
+    execute: async ({ datadogCredentials, dashboard_id }) => {
+        try {
+            return await ddApi(datadogCredentials, 'GET', `/api/v1/dashboard/${dashboard_id}`);
+        }
+        catch (error) {
+            return toDatadogError(error, 'Failed to get dashboard');
+        }
+    },
+});
+export const datadogUpdateDashboard = tool({
+    description: 'Update a dashboard; only provided fields change. Omit reflow_type and pause_auto_refresh to preserve existing values.',
+    inputSchema: z.object({
+        datadogCredentials: credsField,
+        dashboard_id: z.string().describe('Dashboard ID to update'),
+        title: z.string().min(1).max(80).optional().describe('Dashboard title'),
+        widgets: z.array(widgetSchema).optional().describe('Replacement widgets'),
+        description: z.string().max(500).optional().describe('Dashboard description'),
+        layout_type: z.string().optional().describe("Layout: 'ordered' or 'free'"),
+        tags: z.array(z.string()).optional().describe('Replacement tags'),
+        notify_list: z.array(z.string()).optional().describe('Replacement notify list'),
+        template_variables: z.array(templateVariableSchema).optional().describe('Replacement variables'),
+        reflow_type: z.string().optional().describe("Reflow for ordered layouts: 'auto' or 'fixed'"),
+        is_read_only: z.boolean().optional().describe('Read-only flag'),
+        pause_auto_refresh: z.boolean().optional().describe('Pause automatic refresh'),
+    }),
+    execute: async ({ datadogCredentials, dashboard_id, ...body }) => {
+        try {
+            const data = await ddApi(datadogCredentials, 'PUT', `/api/v1/dashboard/${dashboard_id}`, { body });
+            return { ...data, success: true };
+        }
+        catch (error) {
+            return toDatadogError(error, 'Failed to update dashboard');
+        }
+    },
+});
+export const datadogDeleteDashboard = tool({
+    description: 'Permanently delete a dashboard. Irreversible — confirm with the user first.',
+    inputSchema: z.object({
+        datadogCredentials: credsField,
+        dashboard_id: z.string().describe('Dashboard ID to delete'),
+    }),
+    execute: async ({ datadogCredentials, dashboard_id }) => {
+        try {
+            const data = await ddApi(datadogCredentials, 'DELETE', `/api/v1/dashboard/${dashboard_id}`);
+            return {
+                deleted_dashboard_id: data?.deleted_dashboard_id ?? dashboard_id,
+                message: 'Dashboard deleted',
+                success: true,
+            };
+        }
+        catch (error) {
+            return toDatadogError(error, 'Failed to delete dashboard');
+        }
+    },
+});
+export const datadogListDashboards = tool({
+    description: 'List dashboards with shared/deleted filters and start/count pagination.',
+    inputSchema: z.object({
+        datadogCredentials: credsField,
+        filter_shared: z.boolean().optional().describe('Filter by shared status'),
+        filter_deleted: z.boolean().optional().describe('Include deleted dashboards'),
+        count: z.number().optional().describe('Max dashboards to return'),
+        start: z.number().optional().describe('Offset: skip this many dashboards'),
+    }),
+    execute: async ({ datadogCredentials, filter_shared, filter_deleted, count, start }) => {
+        try {
+            const data = await ddApi(datadogCredentials, 'GET', '/api/v1/dashboard', {
+                query: {
+                    'filter[shared]': filter_shared,
+                    'filter[deleted]': filter_deleted,
+                    count,
+                    start,
+                },
+            });
+            const dashboards = data?.dashboards ?? (Array.isArray(data) ? data : []);
+            return { dashboards, total_count: dashboards.length };
+        }
+        catch (error) {
+            return toDatadogError(error, 'Failed to list dashboards');
+        }
+    },
+});
+//# sourceMappingURL=dashboards.js.map

package/dist/toolkits/datadog/tools/events.d.ts

@@ -0,0 +1,35 @@
+export declare const datadogCreateEvent: import("ai").Tool<{
+    title: string;
+    text: string;
+    datadogCredentials: string;
+    priority?: "low" | "normal" | undefined;
+    tags?: string[] | undefined;
+    host?: string | undefined;
+    device_name?: string | undefined;
+    alert_type?: "error" | "success" | "warning" | "info" | undefined;
+    source_type_name?: string | undefined;
+    aggregation_key?: string | undefined;
+    date_happened?: number | undefined;
+}, any>;
+export declare const datadogListEvents: import("ai").Tool<{
+    start: number;
+    end: number;
+    datadogCredentials: string;
+    priority?: "low" | "normal" | undefined;
+    sources?: string | undefined;
+    page?: number | undefined;
+    tags?: string[] | undefined;
+    unaggregated?: boolean | undefined;
+    exclude_aggregate?: boolean | undefined;
+}, {
+    error: string;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+} | {
+    events: any;
+    total_count: any;
+    status: any;
+}>;
+//# sourceMappingURL=events.d.ts.map

package/dist/toolkits/datadog/tools/events.js

@@ -0,0 +1,56 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { ddApi, toDatadogError } from './client.js';
+const credsField = z.string().describe('Datadog credentials JSON with apiKey and appKey (injected by system)');
+export const datadogCreateEvent = tool({
+    description: 'Post an event for deployments, outages, or config changes. Markdown is supported in text.',
+    inputSchema: z.object({
+        datadogCredentials: credsField,
+        title: z.string().max(100).describe('Event title'),
+        text: z.string().describe('Event body (markdown supported)'),
+        host: z.string().optional().describe('Associated host'),
+        device_name: z.string().optional().describe('Associated device'),
+        tags: z.array(z.string()).optional().describe('Event tags'),
+        priority: z.enum(['normal', 'low']).optional().describe('Priority'),
+        alert_type: z.enum(['error', 'warning', 'info', 'success']).optional().describe('Alert type'),
+        source_type_name: z.string().optional().describe("Source, e.g. 'jenkins', 'docker'"),
+        aggregation_key: z.string().optional().describe('Key for grouping events'),
+        date_happened: z.number().optional().describe('Seconds epoch (defaults to now)'),
+    }),
+    execute: async ({ datadogCredentials, ...body }) => {
+        try {
+            return await ddApi(datadogCredentials, 'POST', '/api/v1/events', { body });
+        }
+        catch (error) {
+            return toDatadogError(error, 'Failed to create event');
+        }
+    },
+});
+export const datadogListEvents = tool({
+    description: 'List events in a seconds-epoch window. Start broad (few filters, narrow range) and narrow incrementally — combined filters on wide ranges can return empty or huge results.',
+    inputSchema: z.object({
+        datadogCredentials: credsField,
+        start: z.number().describe('Range start as seconds epoch'),
+        end: z.number().describe('Range end as seconds epoch'),
+        tags: z.array(z.string()).optional().describe('Tag filters'),
+        sources: z.string().optional().describe('Comma-separated sources, e.g. jenkins,docker'),
+        priority: z.enum(['normal', 'low']).optional().describe('Priority filter'),
+        page: z.number().optional().describe('Page number'),
+        unaggregated: z.boolean().optional().describe('Return unaggregated events'),
+        exclude_aggregate: z.boolean().optional().describe('Exclude aggregated events'),
+    }),
+    execute: async ({ datadogCredentials, tags, ...rest }) => {
+        try {
+            const data = await ddApi(datadogCredentials, 'GET', '/api/v1/events', {
+                query: { ...rest, tags: tags?.join(',') },
+            });
+            const events = data?.events ?? (Array.isArray(data) ? data : []);
+            return { events, total_count: events.length, status: data?.status };
+        }
+        catch (error) {
+            return toDatadogError(error, 'Failed to list events');
+        }
+    },
+});
+//# sourceMappingURL=events.js.map

package/dist/toolkits/datadog/tools/hosts.d.ts

@@ -0,0 +1,49 @@
+export declare const datadogListHosts: import("ai").Tool<{
+    datadogCredentials: string;
+    filter?: string | undefined;
+    count?: number | undefined;
+    start?: number | undefined;
+    from_timestamp?: number | undefined;
+    sort_field?: "status" | "name" | "cpu" | "iowait" | "load" | undefined;
+    sort_dir?: "asc" | "desc" | undefined;
+    include_hosts_metadata?: boolean | undefined;
+    include_muted_hosts_data?: boolean | undefined;
+}, any>;
+export declare const datadogGetHostTags: import("ai").Tool<{
+    datadogCredentials: string;
+    host_name: string;
+    source?: string | undefined;
+}, any>;
+export declare const datadogListAllTags: import("ai").Tool<{
+    datadogCredentials: string;
+    source?: string | undefined;
+}, {
+    error: string;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+} | {
+    tags: {
+        name: string;
+        count: number;
+    }[];
+    total_count: number;
+}>;
+export declare const datadogUpdateHostTags: import("ai").Tool<{
+    tags: string[];
+    datadogCredentials: string;
+    host_name: string;
+    source?: string | undefined;
+}, {
+    error: string;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+} | {
+    host: string;
+    tags: any;
+    source: string | undefined;
+}>;
+//# sourceMappingURL=hosts.d.ts.map

package/dist/toolkits/datadog/tools/hosts.js

@@ -0,0 +1,87 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { ddApi, toDatadogError } from './client.js';
+const credsField = z.string().describe('Datadog credentials JSON with apiKey and appKey (injected by system)');
+export const datadogListHosts = tool({
+    description: 'List infrastructure hosts with metrics, tags, and status. Filter by tag query and sort by status, name, cpu, iowait, or load.',
+    inputSchema: z.object({
+        datadogCredentials: credsField,
+        filter: z.string().optional().describe("Tag filter, e.g. 'env:production'"),
+        sort_field: z.enum(['status', 'name', 'cpu', 'iowait', 'load']).optional().describe('Sort field'),
+        sort_dir: z.enum(['asc', 'desc']).optional().describe('Sort direction'),
+        start: z.number().optional().describe('Pagination offset'),
+        count: z.number().max(1000).optional().describe('Hosts to return (max 1000)'),
+        from_timestamp: z.number().optional().describe('Activity window start as seconds epoch'),
+        include_hosts_metadata: z.boolean().optional().describe('Include host metadata'),
+        include_muted_hosts_data: z.boolean().optional().describe('Include muted hosts'),
+    }),
+    execute: async ({ datadogCredentials, ...query }) => {
+        try {
+            return await ddApi(datadogCredentials, 'GET', '/api/v1/hosts', { query });
+        }
+        catch (error) {
+            return toDatadogError(error, 'Failed to list hosts');
+        }
+    },
+});
+export const datadogGetHostTags = tool({
+    description: 'Get all tags for a host, optionally filtered by source (users, chef, puppet, aws, datadog).',
+    inputSchema: z.object({
+        datadogCredentials: credsField,
+        host_name: z.string().describe('Host name'),
+        source: z.string().optional().describe('Tag source to filter by'),
+    }),
+    execute: async ({ datadogCredentials, host_name, source }) => {
+        try {
+            return await ddApi(datadogCredentials, 'GET', `/api/v1/tags/hosts/${encodeURIComponent(host_name)}`, {
+                query: { source },
+            });
+        }
+        catch (error) {
+            return toDatadogError(error, 'Failed to get host tags');
+        }
+    },
+});
+export const datadogListAllTags = tool({
+    description: 'List all tags in use across the organization, optionally filtered by source. Use to discover tag keys for filters.',
+    inputSchema: z.object({
+        datadogCredentials: credsField,
+        source: z.string().optional().describe("Source filter, e.g. 'chef', 'users', 'datadog'"),
+    }),
+    execute: async ({ datadogCredentials, source }) => {
+        try {
+            const data = await ddApi(datadogCredentials, 'GET', '/api/v1/tags/hosts', {
+                query: { source },
+            });
+            const tagMap = data?.tags ?? {};
+            const tags = Object.entries(tagMap).map(([name, hosts]) => ({
+                name,
+                count: Array.isArray(hosts) ? hosts.length : 0,
+            }));
+            return { tags, total_count: tags.length };
+        }
+        catch (error) {
+            return toDatadogError(error, 'Failed to list tags');
+        }
+    },
+});
+export const datadogUpdateHostTags = tool({
+    description: 'Replace all tags from one source on a host (defaults to users source). This overwrites — include the full desired tag set.',
+    inputSchema: z.object({
+        datadogCredentials: credsField,
+        host_name: z.string().describe('Host name'),
+        tags: z.array(z.string()).describe('Complete replacement tag list'),
+        source: z.string().optional().describe("Tag source (defaults to 'users')"),
+    }),
+    execute: async ({ datadogCredentials, host_name, tags, source }) => {
+        try {
+            const data = await ddApi(datadogCredentials, 'PUT', `/api/v1/tags/hosts/${encodeURIComponent(host_name)}`, { query: { source }, body: { tags } });
+            return { host: host_name, tags: data?.tags ?? tags, source };
+        }
+        catch (error) {
+            return toDatadogError(error, 'Failed to update host tags');
+        }
+    },
+});
+//# sourceMappingURL=hosts.js.map

package/dist/toolkits/datadog/tools/incidents.d.ts

@@ -0,0 +1,18 @@
+export declare const datadogListIncidents: import("ai").Tool<{
+    page_size: number;
+    datadogCredentials: string;
+    page_offset: number;
+    sort?: "public_id" | "-public_id" | undefined;
+    include?: string | undefined;
+    filter_query?: string | undefined;
+}, {
+    error: string;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+} | {
+    incidents: any;
+    total_count: any;
+}>;
+//# sourceMappingURL=incidents.d.ts.map

package/dist/toolkits/datadog/tools/incidents.js

@@ -0,0 +1,34 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { ddApi, toDatadogError } from './client.js';
+const credsField = z.string().describe('Datadog credentials JSON with apiKey and appKey (injected by system)');
+export const datadogListIncidents = tool({
+    description: 'List incidents with state/severity/timeline data. Filter active incidents with filter_query state:active.',
+    inputSchema: z.object({
+        datadogCredentials: credsField,
+        filter_query: z.string().optional().describe("Filter, e.g. 'state:active'"),
+        sort: z.enum(['public_id', '-public_id']).optional().describe('Sort by public ID'),
+        include: z.string().optional().describe("Related resources, e.g. 'users,attachments'"),
+        page_size: z.number().min(1).max(100).optional().default(25).describe('Incidents per page'),
+        page_offset: z.number().min(0).optional().default(0).describe('Pagination offset'),
+    }),
+    execute: async ({ datadogCredentials, filter_query, page_size = 25, page_offset = 0, ...rest }) => {
+        try {
+            const data = await ddApi(datadogCredentials, 'GET', '/api/v2/incidents', {
+                query: {
+                    ...rest,
+                    'filter[query]': filter_query,
+                    'page[size]': page_size,
+                    'page[offset]': page_offset,
+                },
+            });
+            const incidents = data?.data ?? [];
+            return { incidents, total_count: data?.meta?.page?.total_count ?? incidents.length };
+        }
+        catch (error) {
+            return toDatadogError(error, 'Failed to list incidents');
+        }
+    },
+});
+//# sourceMappingURL=incidents.js.map