@rnsk/toolkits 0.0.10 → 0.0.12

package/dist/toolkits/datadog/tools/oncall-policies.js

@@ -0,0 +1,72 @@
+// @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 datadogCreateEscalationPolicy = tool({
+    description: 'Create an On-Call escalation policy with steps (targets, assignment, timeouts), retries, and team links.',
+    inputSchema: z.object({
+        datadogCredentials: credsField,
+        data: z.record(z.any()).describe("JSON:API data object with type 'policies' and attributes {name, steps, retries?, resolve_page_on_policy_end?}"),
+    }),
+    execute: async ({ datadogCredentials, data }) => {
+        try {
+            return await ddApi(datadogCredentials, 'POST', '/api/v2/on-call/escalation-policies', {
+                body: { data },
+            });
+        }
+        catch (error) {
+            return toDatadogError(error, 'Failed to create escalation policy');
+        }
+    },
+});
+export const datadogGetEscalationPolicy = tool({
+    description: 'Get an On-Call escalation policy by ID with steps and team links.',
+    inputSchema: z.object({
+        datadogCredentials: credsField,
+        policy_id: z.string().describe('Escalation policy ID'),
+    }),
+    execute: async ({ datadogCredentials, policy_id }) => {
+        try {
+            return await ddApi(datadogCredentials, 'GET', `/api/v2/on-call/escalation-policies/${policy_id}`);
+        }
+        catch (error) {
+            return toDatadogError(error, 'Failed to get escalation policy');
+        }
+    },
+});
+export const datadogUpdateEscalationPolicy = tool({
+    description: 'Update an On-Call escalation policy by ID. The data object must include the policy id and full attributes.',
+    inputSchema: z.object({
+        datadogCredentials: credsField,
+        policy_id: z.string().describe('Escalation policy ID to update'),
+        data: z.record(z.any()).describe("JSON:API data object with id, type 'policies', and attributes {name, steps, ...}"),
+    }),
+    execute: async ({ datadogCredentials, policy_id, data }) => {
+        try {
+            return await ddApi(datadogCredentials, 'PUT', `/api/v2/on-call/escalation-policies/${policy_id}`, {
+                body: { data },
+            });
+        }
+        catch (error) {
+            return toDatadogError(error, 'Failed to update escalation policy');
+        }
+    },
+});
+export const datadogDeleteEscalationPolicy = tool({
+    description: 'Delete an On-Call escalation policy by ID. Irreversible — confirm with the user first.',
+    inputSchema: z.object({
+        datadogCredentials: credsField,
+        policy_id: z.string().describe('Escalation policy ID to delete'),
+    }),
+    execute: async ({ datadogCredentials, policy_id }) => {
+        try {
+            await ddApi(datadogCredentials, 'DELETE', `/api/v2/on-call/escalation-policies/${policy_id}`);
+            return { deleted: true, policy_id, status: 204 };
+        }
+        catch (error) {
+            return toDatadogError(error, 'Failed to delete escalation policy');
+        }
+    },
+});
+//# sourceMappingURL=oncall-policies.js.map

package/dist/toolkits/datadog/tools/oncall-schedules.d.ts

@@ -0,0 +1,31 @@
+export declare const datadogCreateSchedule: import("ai").Tool<{
+    data: Record<string, any>;
+    datadogCredentials: string;
+}, any>;
+export declare const datadogGetSchedule: import("ai").Tool<{
+    datadogCredentials: string;
+    schedule_id: string;
+}, any>;
+export declare const datadogUpdateSchedule: import("ai").Tool<{
+    data: Record<string, any>;
+    datadogCredentials: string;
+    schedule_id: string;
+}, any>;
+export declare const datadogDeleteSchedule: import("ai").Tool<{
+    datadogCredentials: string;
+    schedule_id: string;
+}, {
+    error: string;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+} | {
+    deleted: boolean;
+    schedule_id: string;
+}>;
+export declare const datadogGetScheduledOnCallUser: import("ai").Tool<{
+    datadogCredentials: string;
+    schedule_id: string;
+}, any>;
+//# sourceMappingURL=oncall-schedules.d.ts.map

package/dist/toolkits/datadog/tools/oncall-schedules.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 datadogCreateSchedule = tool({
+    description: 'Create an On-Call schedule with rotation layers (members, intervals, time restrictions) and team links.',
+    inputSchema: z.object({
+        datadogCredentials: credsField,
+        data: z.record(z.any()).describe("JSON:API data object with type 'schedules' and attributes {name, time_zone, layers}"),
+    }),
+    execute: async ({ datadogCredentials, data }) => {
+        try {
+            return await ddApi(datadogCredentials, 'POST', '/api/v2/on-call/schedules', {
+                body: { data },
+            });
+        }
+        catch (error) {
+            return toDatadogError(error, 'Failed to create schedule');
+        }
+    },
+});
+export const datadogGetSchedule = tool({
+    description: 'Get an On-Call schedule by ID with layers and team links.',
+    inputSchema: z.object({
+        datadogCredentials: credsField,
+        schedule_id: z.string().describe('Schedule ID'),
+    }),
+    execute: async ({ datadogCredentials, schedule_id }) => {
+        try {
+            return await ddApi(datadogCredentials, 'GET', `/api/v2/on-call/schedules/${schedule_id}`);
+        }
+        catch (error) {
+            return toDatadogError(error, 'Failed to get schedule');
+        }
+    },
+});
+export const datadogUpdateSchedule = tool({
+    description: 'Update an On-Call schedule by ID. The data object must include the schedule id and full attributes.',
+    inputSchema: z.object({
+        datadogCredentials: credsField,
+        schedule_id: z.string().describe('Schedule ID to update'),
+        data: z.record(z.any()).describe("JSON:API data object with id, type 'schedules', and attributes {name, time_zone, layers}"),
+    }),
+    execute: async ({ datadogCredentials, schedule_id, data }) => {
+        try {
+            return await ddApi(datadogCredentials, 'PUT', `/api/v2/on-call/schedules/${schedule_id}`, {
+                body: { data },
+            });
+        }
+        catch (error) {
+            return toDatadogError(error, 'Failed to update schedule');
+        }
+    },
+});
+export const datadogDeleteSchedule = tool({
+    description: 'Delete an On-Call schedule by ID. Irreversible — confirm with the user first.',
+    inputSchema: z.object({
+        datadogCredentials: credsField,
+        schedule_id: z.string().describe('Schedule ID to delete'),
+    }),
+    execute: async ({ datadogCredentials, schedule_id }) => {
+        try {
+            await ddApi(datadogCredentials, 'DELETE', `/api/v2/on-call/schedules/${schedule_id}`);
+            return { deleted: true, schedule_id };
+        }
+        catch (error) {
+            return toDatadogError(error, 'Failed to delete schedule');
+        }
+    },
+});
+export const datadogGetScheduledOnCallUser = tool({
+    description: 'Get the currently scheduled on-call user for a schedule. Use during incidents to find who to page.',
+    inputSchema: z.object({
+        datadogCredentials: credsField,
+        schedule_id: z.string().describe('Schedule ID'),
+    }),
+    execute: async ({ datadogCredentials, schedule_id }) => {
+        try {
+            return await ddApi(datadogCredentials, 'GET', `/api/v2/on-call/schedules/${schedule_id}/on-call`);
+        }
+        catch (error) {
+            return toDatadogError(error, 'Failed to get scheduled on-call user');
+        }
+    },
+});
+//# sourceMappingURL=oncall-schedules.js.map

package/dist/toolkits/datadog/tools/oncall-teams.d.ts

@@ -0,0 +1,14 @@
+export declare const datadogGetTeamOnCallUsers: import("ai").Tool<{
+    team_id: string;
+    datadogCredentials: string;
+}, any>;
+export declare const datadogGetTeamRoutingRules: import("ai").Tool<{
+    team_id: string;
+    datadogCredentials: string;
+}, any>;
+export declare const datadogSetTeamRoutingRules: import("ai").Tool<{
+    data: Record<string, any>;
+    team_id: string;
+    datadogCredentials: string;
+}, any>;
+//# sourceMappingURL=oncall-teams.d.ts.map

package/dist/toolkits/datadog/tools/oncall-teams.js

@@ -0,0 +1,54 @@
+// @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 datadogGetTeamOnCallUsers = tool({
+    description: 'Get the current on-call users for an On-Call team. Use during incidents to find responders.',
+    inputSchema: z.object({
+        datadogCredentials: credsField,
+        team_id: z.string().describe('On-Call team ID'),
+    }),
+    execute: async ({ datadogCredentials, team_id }) => {
+        try {
+            return await ddApi(datadogCredentials, 'GET', `/api/v2/on-call/teams/${team_id}/on-call`);
+        }
+        catch (error) {
+            return toDatadogError(error, 'Failed to get team on-call users');
+        }
+    },
+});
+export const datadogGetTeamRoutingRules = tool({
+    description: 'Get the On-Call routing rules configured for a team.',
+    inputSchema: z.object({
+        datadogCredentials: credsField,
+        team_id: z.string().describe('On-Call team ID'),
+    }),
+    execute: async ({ datadogCredentials, team_id }) => {
+        try {
+            return await ddApi(datadogCredentials, 'GET', `/api/v2/on-call/teams/${team_id}/routing-rules`);
+        }
+        catch (error) {
+            return toDatadogError(error, 'Failed to get team routing rules');
+        }
+    },
+});
+export const datadogSetTeamRoutingRules = tool({
+    description: 'Replace the On-Call routing rules for a team. This overwrites all existing rules — confirm with the user first.',
+    inputSchema: z.object({
+        datadogCredentials: credsField,
+        team_id: z.string().describe('On-Call team ID'),
+        data: z.record(z.any()).describe("JSON:API data object with type 'team_routing_rules' and rule attributes"),
+    }),
+    execute: async ({ datadogCredentials, team_id, data }) => {
+        try {
+            return await ddApi(datadogCredentials, 'PUT', `/api/v2/on-call/teams/${team_id}/routing-rules`, {
+                body: { data },
+            });
+        }
+        catch (error) {
+            return toDatadogError(error, 'Failed to set team routing rules');
+        }
+    },
+});
+//# sourceMappingURL=oncall-teams.js.map

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

@@ -0,0 +1,43 @@
+export declare const datadogCreateSlo: import("ai").Tool<{
+    type: "metric" | "monitor";
+    name: string;
+    datadogCredentials: string;
+    thresholds: {
+        target: number;
+        timeframe: "7d" | "30d" | "90d";
+        warning?: number | undefined;
+    }[];
+    query?: {
+        numerator: string;
+        denominator: string;
+    } | undefined;
+    description?: string | undefined;
+    tags?: string[] | undefined;
+    monitor_ids?: number[] | undefined;
+    groups?: string[] | undefined;
+}, {
+    error: string;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+} | {
+    success: boolean;
+}>;
+export declare const datadogListSlos: import("ai").Tool<{
+    limit: number;
+    offset: number;
+    datadogCredentials: string;
+    query?: string | undefined;
+    tags?: string | undefined;
+}, {
+    error: string;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+} | {
+    slos: any;
+    total_count: any;
+}>;
+//# sourceMappingURL=slos.d.ts.map

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

@@ -0,0 +1,62 @@
+// @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 thresholdSchema = z.object({
+    target: z.number().min(0).max(100).describe('Target percentage, e.g. 99.9'),
+    timeframe: z.enum(['7d', '30d', '90d']).describe('Target timeframe'),
+    warning: z.number().min(0).max(100).optional().describe('Warning threshold percentage'),
+});
+export const datadogCreateSlo = tool({
+    description: 'Create a metric or monitor SLO with target thresholds. Metric SLOs need numerator/denominator queries; monitor SLOs need monitor IDs.',
+    inputSchema: z.object({
+        datadogCredentials: credsField,
+        name: z.string().min(1).max(100).describe('SLO display name'),
+        type: z.enum(['metric', 'monitor']).describe('SLO type'),
+        thresholds: z.array(thresholdSchema).min(1).describe('Target thresholds'),
+        query: z
+            .object({
+            numerator: z.string().describe('Good-events metric query'),
+            denominator: z.string().describe('Total-events metric query'),
+        })
+            .optional()
+            .describe('Required for metric SLOs'),
+        monitor_ids: z.array(z.number()).optional().describe('Required for monitor SLOs'),
+        description: z.string().max(500).optional().describe('SLO description'),
+        tags: z.array(z.string()).optional().describe("Tags, e.g. ['key:value']"),
+        groups: z.array(z.string()).optional().describe('SLO scope groups'),
+    }),
+    execute: async ({ datadogCredentials, ...body }) => {
+        try {
+            const data = await ddApi(datadogCredentials, 'POST', '/api/v1/slo', { body });
+            return { ...data, success: true };
+        }
+        catch (error) {
+            return toDatadogError(error, 'Failed to create SLO');
+        }
+    },
+});
+export const datadogListSlos = tool({
+    description: 'List SLOs with tag, name/description, and limit/offset filters.',
+    inputSchema: z.object({
+        datadogCredentials: credsField,
+        tags: z.string().optional().describe("Comma-separated tag filter, e.g. 'env:prod,team:backend'"),
+        query: z.string().optional().describe('Name/description search'),
+        limit: z.number().min(1).max(1000).optional().default(25).describe('Max SLOs (1-1000)'),
+        offset: z.number().min(0).optional().default(0).describe('SLOs to skip'),
+    }),
+    execute: async ({ datadogCredentials, tags, query, limit = 25, offset = 0 }) => {
+        try {
+            const data = await ddApi(datadogCredentials, 'GET', '/api/v1/slo', {
+                query: { tags_query: tags, query, limit, offset },
+            });
+            const slos = data?.data ?? [];
+            return { slos, total_count: data?.meta?.page?.total_count ?? slos.length };
+        }
+        catch (error) {
+            return toDatadogError(error, 'Failed to list SLOs');
+        }
+    },
+});
+//# sourceMappingURL=slos.js.map

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

@@ -0,0 +1,58 @@
+export declare const datadogCreateSyntheticApiTest: import("ai").Tool<{
+    options: {
+        locations: string[];
+        tick_every: number;
+        device_ids?: string[] | undefined;
+        min_location_failed?: number | undefined;
+        min_failure_duration?: number | undefined;
+        monitor_options?: Record<string, any> | undefined;
+    };
+    name: string;
+    config: {
+        request: Record<string, any>;
+        assertions: Record<string, any>[];
+        variables?: Record<string, any>[] | undefined;
+    };
+    datadogCredentials: string;
+    message?: string | undefined;
+    type?: string | undefined;
+    status?: "live" | "paused" | undefined;
+    tags?: string[] | undefined;
+    subtype?: "ssl" | "http" | "tcp" | "dns" | "icmp" | undefined;
+}, {
+    error: string;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+} | {
+    success: boolean;
+}>;
+export declare const datadogListSynthetics: import("ai").Tool<{
+    limit: number;
+    offset: number;
+    datadogCredentials: string;
+    tags?: string | undefined;
+    locations?: string | undefined;
+}, {
+    error: string;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+} | {
+    tests: any;
+    total_count: any;
+}>;
+export declare const datadogGetSyntheticsLocations: import("ai").Tool<{
+    datadogCredentials: string;
+}, {
+    error: string;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+} | {
+    locations: any;
+}>;
+//# sourceMappingURL=synthetics.d.ts.map

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

@@ -0,0 +1,90 @@
+// @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 datadogCreateSyntheticApiTest = tool({
+    description: 'Create a synthetic API test (http/ssl/tcp/dns/icmp) that monitors an endpoint from worldwide locations. Get location IDs from datadogGetSyntheticsLocations first.',
+    inputSchema: z.object({
+        datadogCredentials: credsField,
+        name: z.string().min(1).max(200).describe('Test name'),
+        config: z
+            .object({
+            request: z.record(z.any()).describe('HTTP request config'),
+            assertions: z
+                .array(z.record(z.any()))
+                .describe("Assertions with type/operator/target, e.g. {type:'statusCode',operator:'is',target:200}"),
+            variables: z.array(z.record(z.any())).optional().describe('Test variables'),
+        })
+            .describe('Request and assertions'),
+        options: z
+            .object({
+            tick_every: z.number().min(60).max(604800).describe('Run frequency in seconds'),
+            locations: z.array(z.string()).describe('Location IDs to run from'),
+            device_ids: z.array(z.string()).optional().describe('Mobile device IDs'),
+            min_location_failed: z.number().optional().describe('Failing locations required to alert'),
+            min_failure_duration: z.number().optional().describe('Seconds failing before alerting'),
+            monitor_options: z.record(z.any()).optional().describe('Monitor options'),
+        })
+            .describe('Execution options'),
+        type: z.string().optional().describe("Test type (default 'api')"),
+        subtype: z.enum(['http', 'ssl', 'tcp', 'dns', 'icmp']).optional().describe('Subtype (default http)'),
+        status: z.enum(['live', 'paused']).optional().describe('Status (default live)'),
+        message: z.string().optional().describe('Notification message'),
+        tags: z.array(z.string()).optional().describe('Test tags'),
+    }),
+    execute: async ({ datadogCredentials, ...body }) => {
+        try {
+            const data = await ddApi(datadogCredentials, 'POST', '/api/v1/synthetics/tests/api', { body });
+            return { ...data, success: true };
+        }
+        catch (error) {
+            return toDatadogError(error, 'Failed to create synthetic API test');
+        }
+    },
+});
+export const datadogListSynthetics = tool({
+    description: 'List synthetic tests with client-side tag/location filtering and limit/offset pagination.',
+    inputSchema: z.object({
+        datadogCredentials: credsField,
+        tags: z.string().optional().describe("Tag filter, e.g. 'env:prod,team:frontend'"),
+        locations: z.string().optional().describe('Comma-separated location filter'),
+        limit: z.number().min(1).max(200).optional().default(50).describe('Max tests (1-200)'),
+        offset: z.number().min(0).optional().default(0).describe('Tests to skip'),
+    }),
+    execute: async ({ datadogCredentials, tags, locations, limit = 50, offset = 0 }) => {
+        try {
+            const data = await ddApi(datadogCredentials, 'GET', '/api/v1/synthetics/tests');
+            let tests = data?.tests ?? (Array.isArray(data) ? data : []);
+            if (tags) {
+                const wanted = tags.split(',').map((t) => t.trim());
+                tests = tests.filter((t) => wanted.every((w) => (t.tags ?? []).includes(w)));
+            }
+            if (locations) {
+                const wanted = locations.split(',').map((l) => l.trim());
+                tests = tests.filter((t) => (t.locations ?? []).some((l) => wanted.includes(l)));
+            }
+            return { tests: tests.slice(offset, offset + limit), total_count: tests.length };
+        }
+        catch (error) {
+            return toDatadogError(error, 'Failed to list synthetics tests');
+        }
+    },
+});
+export const datadogGetSyntheticsLocations = tool({
+    description: 'List public and private synthetic locations. Use the IDs when creating synthetic tests.',
+    inputSchema: z.object({
+        datadogCredentials: credsField,
+    }),
+    execute: async ({ datadogCredentials }) => {
+        try {
+            const data = await ddApi(datadogCredentials, 'GET', '/api/v1/synthetics/locations');
+            const locations = data?.locations ?? (Array.isArray(data) ? data : []);
+            return { locations };
+        }
+        catch (error) {
+            return toDatadogError(error, 'Failed to get synthetics locations');
+        }
+    },
+});
+//# sourceMappingURL=synthetics.js.map

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

@@ -0,0 +1,7 @@
+export declare const datadogGetUsageSummary: import("ai").Tool<{
+    datadogCredentials: string;
+    start_month: string;
+    end_month?: string | undefined;
+    include_org_details?: boolean | undefined;
+}, any>;
+//# sourceMappingURL=usage.d.ts.map

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

@@ -0,0 +1,25 @@
+// @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 datadogGetUsageSummary = tool({
+    description: 'Get monthly billable usage (hosts, containers, API calls, logs) for cost monitoring. Empty payloads for inactive months are expected, not errors.',
+    inputSchema: z.object({
+        datadogCredentials: credsField,
+        start_month: z.string().describe("Start month 'YYYY-MM', e.g. '2024-01'"),
+        end_month: z.string().optional().describe("End month 'YYYY-MM' (defaults to start_month)"),
+        include_org_details: z.boolean().optional().describe('Include organization details'),
+    }),
+    execute: async ({ datadogCredentials, start_month, end_month, include_org_details }) => {
+        try {
+            return await ddApi(datadogCredentials, 'GET', '/api/v1/usage/summary', {
+                query: { start_month, end_month, include_org_details },
+            });
+        }
+        catch (error) {
+            return toDatadogError(error, 'Failed to get usage summary');
+        }
+    },
+});
+//# sourceMappingURL=usage.js.map

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

@@ -0,0 +1,35 @@
+export declare const datadogListUsers: import("ai").Tool<{
+    page_size: number;
+    datadogCredentials: string;
+    sort_dir: string;
+    page_number: number;
+    sort?: string | undefined;
+    filter_status?: string | undefined;
+}, {
+    error: string;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+} | {
+    users: any;
+    total_count: any;
+    total_filtered_count: any;
+}>;
+export declare const datadogListRoles: import("ai").Tool<{
+    page_size: number;
+    datadogCredentials: string;
+    page_number: number;
+    sort?: string | undefined;
+    filter_name?: string | undefined;
+}, {
+    error: string;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+} | {
+    roles: any;
+    total_count: any;
+}>;
+//# sourceMappingURL=users.d.ts.map

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

@@ -0,0 +1,66 @@
+// @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 datadogListUsers = tool({
+    description: 'List organization users with roles and access levels. Paginate with page_size/page_number.',
+    inputSchema: z.object({
+        datadogCredentials: credsField,
+        sort: z.string().optional().describe('Sort field: name, email, status, created_at'),
+        sort_dir: z.string().optional().default('asc').describe('Sort direction'),
+        page_size: z.number().min(1).max(1000).optional().default(50).describe('Users per page'),
+        page_number: z.number().min(0).optional().default(0).describe('Page number'),
+        filter_status: z.string().optional().describe('Status filter: Active, Pending, Disabled'),
+    }),
+    execute: async ({ datadogCredentials, sort, sort_dir = 'asc', page_size = 50, page_number = 0, filter_status }) => {
+        try {
+            const data = await ddApi(datadogCredentials, 'GET', '/api/v2/users', {
+                query: {
+                    sort,
+                    sort_dir,
+                    'page[size]': page_size,
+                    'page[number]': page_number,
+                    'filter[status]': filter_status,
+                },
+            });
+            const users = data?.data ?? [];
+            return {
+                users,
+                total_count: data?.meta?.page?.total_count ?? users.length,
+                total_filtered_count: data?.meta?.page?.total_filtered_count,
+            };
+        }
+        catch (error) {
+            return toDatadogError(error, 'Failed to list users');
+        }
+    },
+});
+export const datadogListRoles = tool({
+    description: 'List organization roles (permission sets) with member counts. Filter by partial name match.',
+    inputSchema: z.object({
+        datadogCredentials: credsField,
+        sort: z.string().optional().describe('Sort field: name, created_at, user_count'),
+        page_size: z.number().min(1).max(100).optional().default(10).describe('Roles per page'),
+        page_number: z.number().min(0).optional().default(0).describe('Page number'),
+        filter_name: z.string().optional().describe('Partial name filter'),
+    }),
+    execute: async ({ datadogCredentials, sort, page_size = 10, page_number = 0, filter_name }) => {
+        try {
+            const data = await ddApi(datadogCredentials, 'GET', '/api/v2/roles', {
+                query: {
+                    sort,
+                    'page[size]': page_size,
+                    'page[number]': page_number,
+                    filter: filter_name,
+                },
+            });
+            const roles = data?.data ?? [];
+            return { roles, total_count: data?.meta?.page?.total_count ?? roles.length };
+        }
+        catch (error) {
+            return toDatadogError(error, 'Failed to list roles');
+        }
+    },
+});
+//# sourceMappingURL=users.js.map

package/dist/toolkits/dev-to/icon.d.ts

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