@rnsk/toolkits 0.0.10 → 0.0.12

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

@@ -0,0 +1,27 @@
+export declare const datadogListMetrics: import("ai").Tool<{
+    datadogCredentials: string;
+    from_timestamp: number;
+    host?: string | undefined;
+    tag_filter?: string | undefined;
+}, any>;
+export declare const datadogQueryMetrics: import("ai").Tool<{
+    query: string;
+    datadogCredentials: string;
+    from_timestamp: number;
+    to_timestamp: number;
+}, any>;
+export declare const datadogSubmitMetrics: import("ai").Tool<{
+    series: {
+        metric: string;
+        points: {
+            value: number;
+            timestamp?: number | undefined;
+        }[];
+        type?: string | undefined;
+        host?: string | undefined;
+        tags?: string[] | undefined;
+        interval?: number | undefined;
+    }[];
+    datadogCredentials: string;
+}, any>;
+//# sourceMappingURL=metrics.d.ts.map

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

@@ -0,0 +1,83 @@
+// @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 datadogListMetrics = tool({
+    description: 'Discover actively reporting metric names since a timestamp, optionally filtered by host or tags. Use before datadogQueryMetrics to find exact names.',
+    inputSchema: z.object({
+        datadogCredentials: credsField,
+        from_timestamp: z.number().describe('Seconds since epoch: list metrics active since this time'),
+        host: z.string().optional().describe('Only metrics reported with this hostname tag'),
+        tag_filter: z.string().optional().describe("Tag filter, e.g. 'env:prod AND service:api' (no other filters)"),
+    }),
+    execute: async ({ datadogCredentials, from_timestamp, host, tag_filter }) => {
+        try {
+            return await ddApi(datadogCredentials, 'GET', '/api/v1/metrics', {
+                query: { from: from_timestamp, host, tag_filter },
+            });
+        }
+        catch (error) {
+            return toDatadogError(error, 'Failed to list metrics');
+        }
+    },
+});
+export const datadogQueryMetrics = tool({
+    description: 'Query timeseries data with a metrics query string over a UTC seconds range (max 1 year). Use datadogListMetrics first to confirm names; millisecond timestamps silently return empty series.',
+    inputSchema: z.object({
+        datadogCredentials: credsField,
+        query: z.string().describe("Query, e.g. 'avg:system.cpu.user{*}'"),
+        from_timestamp: z.number().describe('Range start as UTC seconds'),
+        to_timestamp: z.number().describe('Range end as UTC seconds'),
+    }),
+    execute: async ({ datadogCredentials, query, from_timestamp, to_timestamp }) => {
+        try {
+            return await ddApi(datadogCredentials, 'GET', '/api/v1/query', {
+                query: { from: from_timestamp, to: to_timestamp, query },
+            });
+        }
+        catch (error) {
+            return toDatadogError(error, 'Failed to query metrics');
+        }
+    },
+});
+export const datadogSubmitMetrics = tool({
+    description: 'Submit custom gauge/rate/count series (KPIs, app metrics). Points default to the current time when timestamp is omitted.',
+    inputSchema: z.object({
+        datadogCredentials: credsField,
+        series: z
+            .array(z.object({
+            metric: z.string().describe('Metric name, e.g. myapp.response_time'),
+            points: z
+                .array(z.object({
+                timestamp: z.number().optional().describe('Seconds epoch (defaults to now)'),
+                value: z.number().describe('Point value'),
+            }))
+                .min(1)
+                .describe('Data points'),
+            host: z.string().optional().describe('Host name'),
+            tags: z.array(z.string()).optional().describe("Tags, e.g. ['env:production']"),
+            type: z.string().optional().describe("One of 'gauge', 'rate', 'count'"),
+            interval: z.number().optional().describe('Seconds between points (rate metrics)'),
+        }))
+            .min(1)
+            .describe('Series to submit'),
+    }),
+    execute: async ({ datadogCredentials, series }) => {
+        try {
+            const now = Math.floor(Date.now() / 1000);
+            return await ddApi(datadogCredentials, 'POST', '/api/v1/series', {
+                body: {
+                    series: series.map((s) => ({
+                        ...s,
+                        points: s.points.map((p) => [p.timestamp ?? now, p.value]),
+                    })),
+                },
+            });
+        }
+        catch (error) {
+            return toDatadogError(error, 'Failed to submit metrics');
+        }
+    },
+});
+//# sourceMappingURL=metrics.js.map

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

@@ -0,0 +1,95 @@
+export declare const datadogCreateMonitor: import("ai").Tool<{
+    query: string;
+    type: "metric alert" | "service check" | "event alert" | "query alert" | "composite" | "log alert";
+    name: string;
+    datadogCredentials: string;
+    message?: string | undefined;
+    options?: Record<string, any> | undefined;
+    priority?: number | undefined;
+    tags?: string[] | undefined;
+}, any>;
+export declare const datadogGetMonitor: import("ai").Tool<{
+    datadogCredentials: string;
+    monitor_id: number;
+    group_states?: string[] | undefined;
+    with_downtimes?: boolean | undefined;
+}, any>;
+export declare const datadogListMonitors: import("ai").Tool<{
+    datadogCredentials: string;
+    name?: string | undefined;
+    page?: number | undefined;
+    page_size?: number | undefined;
+    tags?: string[] | undefined;
+    group_states?: string[] | undefined;
+    with_downtimes?: boolean | undefined;
+    monitor_tags?: string[] | undefined;
+    id_offset?: number | undefined;
+}, {
+    error: string;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+} | {
+    monitors: any;
+    total_count: any;
+}>;
+export declare const datadogUpdateMonitor: import("ai").Tool<{
+    datadogCredentials: string;
+    monitor_id: number;
+    query?: string | undefined;
+    message?: string | undefined;
+    options?: Record<string, any> | undefined;
+    type?: "metric alert" | "service check" | "event alert" | "query alert" | "composite" | "log alert" | undefined;
+    priority?: number | undefined;
+    name?: string | undefined;
+    tags?: string[] | undefined;
+}, any>;
+export declare const datadogDeleteMonitor: import("ai").Tool<{
+    datadogCredentials: string;
+    monitor_id: number;
+    force?: boolean | undefined;
+}, {
+    error: string;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+} | {
+    deleted_monitor_id: any;
+    message: any;
+}>;
+export declare const datadogMuteMonitor: import("ai").Tool<{
+    datadogCredentials: string;
+    monitor_id: number;
+    end?: number | undefined;
+    override?: boolean | undefined;
+}, any>;
+export declare const datadogUnmuteMonitor: import("ai").Tool<{
+    datadogCredentials: string;
+    monitor_id: number;
+    all_scopes?: boolean | undefined;
+}, {
+    error: string;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+} | {
+    monitor_id: number;
+    muted: any;
+    success: boolean;
+    message: string;
+}>;
+export declare const datadogCreateDowntime: import("ai").Tool<{
+    scope: string[];
+    datadogCredentials: string;
+    message?: string | undefined;
+    start?: number | undefined;
+    end?: number | undefined;
+    monitor_id?: number | undefined;
+    monitor_tags?: string[] | undefined;
+    timezone?: string | undefined;
+    recurrence?: Record<string, any> | undefined;
+}, any>;
+//# sourceMappingURL=monitors.d.ts.map

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

@@ -0,0 +1,190 @@
+// @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 monitorType = z
+    .enum(['metric alert', 'service check', 'event alert', 'query alert', 'composite', 'log alert'])
+    .describe('Monitor type (query syntax must match the type)');
+const monitorOptions = z.record(z.any()).optional().describe('Options: thresholds, notify_no_data, renotify_interval, etc.');
+export const datadogCreateMonitor = tool({
+    description: 'Create a monitor with alerting thresholds and notifications. The query syntax must match the monitor type exactly or creation fails.',
+    inputSchema: z.object({
+        datadogCredentials: credsField,
+        type: monitorType,
+        name: z.string().describe("Monitor name, e.g. 'High CPU Usage'"),
+        query: z.string().describe("Monitor query, e.g. 'avg(last_5m):avg:system.cpu.user{*} > 80'"),
+        message: z.string().optional().describe('Notification text (supports @mentions and markdown)'),
+        tags: z.array(z.string()).optional().describe('Tags for the monitor'),
+        priority: z.number().optional().describe('Priority 1-5 (1 is highest)'),
+        options: monitorOptions,
+    }),
+    execute: async ({ datadogCredentials, ...body }) => {
+        try {
+            return await ddApi(datadogCredentials, 'POST', '/api/v1/monitor', { body });
+        }
+        catch (error) {
+            return toDatadogError(error, 'Failed to create monitor');
+        }
+    },
+});
+export const datadogGetMonitor = tool({
+    description: 'Get a monitor by ID with state, config, and optionally downtimes. Use datadogListMonitors to discover IDs.',
+    inputSchema: z.object({
+        datadogCredentials: credsField,
+        monitor_id: z.number().describe('Monitor ID'),
+        group_states: z.array(z.string()).optional().describe("Group states: 'all', 'alert', 'warn', 'no data'"),
+        with_downtimes: z.boolean().optional().describe('Include active downtimes'),
+    }),
+    execute: async ({ datadogCredentials, monitor_id, group_states, with_downtimes }) => {
+        try {
+            return await ddApi(datadogCredentials, 'GET', `/api/v1/monitor/${monitor_id}`, {
+                query: { group_states: group_states?.join(','), with_downtimes },
+            });
+        }
+        catch (error) {
+            return toDatadogError(error, 'Failed to get monitor');
+        }
+    },
+});
+export const datadogListMonitors = tool({
+    description: 'List monitors with name/tag/state filters. Set page and page_size together to paginate (pages start at 0); omit both for all monitors.',
+    inputSchema: z.object({
+        datadogCredentials: credsField,
+        name: z.string().optional().describe('Name substring filter'),
+        tags: z.array(z.string()).optional().describe('Scope tags, e.g. host:host0'),
+        monitor_tags: z.array(z.string()).optional().describe('Service/custom tags, e.g. service:my-app'),
+        group_states: z.array(z.string()).optional().describe('Alert, Warn, or No Data'),
+        with_downtimes: z.boolean().optional().describe('Include current downtimes'),
+        page: z.number().optional().describe('Page number from 0 (requires page_size)'),
+        page_size: z.number().max(100).optional().describe('Monitors per page (max 100, requires page)'),
+        id_offset: z.number().optional().describe('Monitor ID offset pagination'),
+    }),
+    execute: async ({ datadogCredentials, tags, monitor_tags, group_states, ...rest }) => {
+        try {
+            const data = await ddApi(datadogCredentials, 'GET', '/api/v1/monitor', {
+                query: {
+                    ...rest,
+                    tags: tags?.join(','),
+                    monitor_tags: monitor_tags?.join(','),
+                    group_states: group_states?.join(','),
+                },
+            });
+            const monitors = Array.isArray(data) ? data : (data?.monitors ?? []);
+            return { monitors, total_count: data?.total_count ?? monitors.length };
+        }
+        catch (error) {
+            return toDatadogError(error, 'Failed to list monitors');
+        }
+    },
+});
+export const datadogUpdateMonitor = tool({
+    description: 'Update a monitor; only provided fields change. Confirm query/type changes with the user first.',
+    inputSchema: z.object({
+        datadogCredentials: credsField,
+        monitor_id: z.number().describe('Monitor ID to update'),
+        type: monitorType.optional(),
+        name: z.string().optional().describe('Monitor name'),
+        query: z.string().optional().describe('Monitor query'),
+        message: z.string().optional().describe('Notification text'),
+        tags: z.array(z.string()).optional().describe('Replacement tags'),
+        priority: z.number().optional().describe('Priority 1-5'),
+        options: monitorOptions,
+    }),
+    execute: async ({ datadogCredentials, monitor_id, ...body }) => {
+        try {
+            return await ddApi(datadogCredentials, 'PUT', `/api/v1/monitor/${monitor_id}`, { body });
+        }
+        catch (error) {
+            return toDatadogError(error, 'Failed to update monitor');
+        }
+    },
+});
+export const datadogDeleteMonitor = tool({
+    description: 'Permanently delete a monitor. Irreversible — confirm with the user first.',
+    inputSchema: z.object({
+        datadogCredentials: credsField,
+        monitor_id: z.number().describe('Monitor ID to delete'),
+        force: z.boolean().optional().describe('Force deletion without confirmation'),
+    }),
+    execute: async ({ datadogCredentials, monitor_id, force }) => {
+        try {
+            const data = await ddApi(datadogCredentials, 'DELETE', `/api/v1/monitor/${monitor_id}`, {
+                query: { force },
+            });
+            return {
+                deleted_monitor_id: data?.deleted_monitor_id ?? monitor_id,
+                message: data?.message ?? 'Monitor deleted',
+            };
+        }
+        catch (error) {
+            return toDatadogError(error, 'Failed to delete monitor');
+        }
+    },
+});
+export const datadogMuteMonitor = tool({
+    description: 'Mute a monitor to silence alerts during maintenance or deployments. Without end it stays muted until manually unmuted.',
+    inputSchema: z.object({
+        datadogCredentials: credsField,
+        monitor_id: z.number().describe('Monitor ID to mute'),
+        end: z.number().optional().describe('POSIX timestamp when the mute expires'),
+        override: z.boolean().optional().describe('Override existing mute settings'),
+    }),
+    execute: async ({ datadogCredentials, monitor_id, end, override }) => {
+        try {
+            return await ddApi(datadogCredentials, 'POST', `/api/v1/monitor/${monitor_id}/mute`, {
+                body: { end, override },
+            });
+        }
+        catch (error) {
+            return toDatadogError(error, 'Failed to mute monitor');
+        }
+    },
+});
+export const datadogUnmuteMonitor = tool({
+    description: 'Unmute a monitor so alerting resumes immediately. Only unmute after maintenance or the issue is fully resolved to avoid alert storms.',
+    inputSchema: z.object({
+        datadogCredentials: credsField,
+        monitor_id: z.number().describe('Monitor ID to unmute'),
+        all_scopes: z.boolean().optional().describe('Unmute for all scopes'),
+    }),
+    execute: async ({ datadogCredentials, monitor_id, all_scopes }) => {
+        try {
+            const data = await ddApi(datadogCredentials, 'POST', `/api/v1/monitor/${monitor_id}/unmute`, {
+                body: { all_scopes },
+            });
+            return {
+                monitor_id,
+                muted: data?.muted ?? false,
+                success: true,
+                message: 'Monitor unmuted',
+            };
+        }
+        catch (error) {
+            return toDatadogError(error, 'Failed to unmute monitor');
+        }
+    },
+});
+export const datadogCreateDowntime = tool({
+    description: 'Create a downtime to suppress alerts during maintenance or deployments. Scope to hosts, services, tags, or a monitor ID.',
+    inputSchema: z.object({
+        datadogCredentials: credsField,
+        scope: z.array(z.string()).describe("Scope, e.g. ['host:web-01'] or ['*']"),
+        message: z.string().optional().describe("Note, e.g. 'Scheduled maintenance'"),
+        start: z.number().optional().describe('Start as seconds epoch (omit to start now)'),
+        end: z.number().optional().describe('End as seconds epoch'),
+        timezone: z.string().optional().describe("Timezone, e.g. 'UTC' or 'America/New_York'"),
+        monitor_id: z.number().optional().describe('Downtime for one monitor instead of scope'),
+        monitor_tags: z.array(z.string()).optional().describe('Monitor tags to match'),
+        recurrence: z.record(z.any()).optional().describe('Recurrence: type (days/weeks/months/years), period, week_days, until_date/occurrences'),
+    }),
+    execute: async ({ datadogCredentials, ...body }) => {
+        try {
+            return await ddApi(datadogCredentials, 'POST', '/api/v1/downtime', { body });
+        }
+        catch (error) {
+            return toDatadogError(error, 'Failed to create downtime');
+        }
+    },
+});
+//# sourceMappingURL=monitors.js.map

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

@@ -0,0 +1,61 @@
+export declare const datadogCreateNotificationChannel: import("ai").Tool<{
+    data: Record<string, any>;
+    user_id: string;
+    datadogCredentials: string;
+}, any>;
+export declare const datadogGetNotificationChannel: import("ai").Tool<{
+    channel_id: string;
+    user_id: string;
+    datadogCredentials: string;
+}, any>;
+export declare const datadogListNotificationChannels: import("ai").Tool<{
+    user_id: string;
+    datadogCredentials: string;
+}, any>;
+export declare const datadogDeleteNotificationChannel: import("ai").Tool<{
+    channel_id: string;
+    user_id: string;
+    datadogCredentials: string;
+}, {
+    error: string;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+} | {
+    success: boolean;
+}>;
+export declare const datadogCreateNotificationRule: import("ai").Tool<{
+    data: Record<string, any>;
+    user_id: string;
+    datadogCredentials: string;
+}, any>;
+export declare const datadogGetNotificationRule: import("ai").Tool<{
+    user_id: string;
+    datadogCredentials: string;
+    rule_id: string;
+}, any>;
+export declare const datadogListNotificationRules: import("ai").Tool<{
+    user_id: string;
+    datadogCredentials: string;
+}, any>;
+export declare const datadogUpdateNotificationRule: import("ai").Tool<{
+    data: Record<string, any>;
+    user_id: string;
+    datadogCredentials: string;
+    rule_id: string;
+}, any>;
+export declare const datadogDeleteNotificationRule: import("ai").Tool<{
+    user_id: string;
+    datadogCredentials: string;
+    rule_id: string;
+}, {
+    error: string;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+} | {
+    success: boolean;
+}>;
+//# sourceMappingURL=oncall-notifications.d.ts.map

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

@@ -0,0 +1,155 @@
+// @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 datadogCreateNotificationChannel = tool({
+    description: 'Create an email or phone notification channel for a user (E.164 for phone, address+formats for email).',
+    inputSchema: z.object({
+        datadogCredentials: credsField,
+        user_id: z.string().describe('Owner user ID'),
+        data: z.record(z.any()).describe("JSON:API data object with type 'notification_channels' and config attributes"),
+    }),
+    execute: async ({ datadogCredentials, user_id, data }) => {
+        try {
+            return await ddApi(datadogCredentials, 'POST', `/api/v2/on-call/users/${user_id}/notification-channels`, {
+                body: { data },
+            });
+        }
+        catch (error) {
+            return toDatadogError(error, 'Failed to create notification channel');
+        }
+    },
+});
+export const datadogGetNotificationChannel = tool({
+    description: 'Get one notification channel for a user by channel ID.',
+    inputSchema: z.object({
+        datadogCredentials: credsField,
+        user_id: z.string().describe('Owner user ID'),
+        channel_id: z.string().describe('Notification channel ID'),
+    }),
+    execute: async ({ datadogCredentials, user_id, channel_id }) => {
+        try {
+            return await ddApi(datadogCredentials, 'GET', `/api/v2/on-call/users/${user_id}/notification-channels/${channel_id}`);
+        }
+        catch (error) {
+            return toDatadogError(error, 'Failed to get notification channel');
+        }
+    },
+});
+export const datadogListNotificationChannels = tool({
+    description: 'List all notification channels configured for a user.',
+    inputSchema: z.object({
+        datadogCredentials: credsField,
+        user_id: z.string().describe('Owner user ID'),
+    }),
+    execute: async ({ datadogCredentials, user_id }) => {
+        try {
+            return await ddApi(datadogCredentials, 'GET', `/api/v2/on-call/users/${user_id}/notification-channels`);
+        }
+        catch (error) {
+            return toDatadogError(error, 'Failed to list notification channels');
+        }
+    },
+});
+export const datadogDeleteNotificationChannel = tool({
+    description: 'Delete a user notification channel. Irreversible — confirm with the user first.',
+    inputSchema: z.object({
+        datadogCredentials: credsField,
+        user_id: z.string().describe('Owner user ID'),
+        channel_id: z.string().describe('Notification channel ID to delete'),
+    }),
+    execute: async ({ datadogCredentials, user_id, channel_id }) => {
+        try {
+            await ddApi(datadogCredentials, 'DELETE', `/api/v2/on-call/users/${user_id}/notification-channels/${channel_id}`);
+            return { success: true };
+        }
+        catch (error) {
+            return toDatadogError(error, 'Failed to delete notification channel');
+        }
+    },
+});
+export const datadogCreateNotificationRule = tool({
+    description: 'Create a notification rule for a user: urgency category, delay, and the channel it routes to.',
+    inputSchema: z.object({
+        datadogCredentials: credsField,
+        user_id: z.string().describe('Owner user ID'),
+        data: z.record(z.any()).describe("JSON:API data object with type 'notification_rules', attributes, and channel relationships"),
+    }),
+    execute: async ({ datadogCredentials, user_id, data }) => {
+        try {
+            return await ddApi(datadogCredentials, 'POST', `/api/v2/on-call/users/${user_id}/notification-rules`, {
+                body: { data },
+            });
+        }
+        catch (error) {
+            return toDatadogError(error, 'Failed to create notification rule');
+        }
+    },
+});
+export const datadogGetNotificationRule = tool({
+    description: 'Get one notification rule for a user by rule ID.',
+    inputSchema: z.object({
+        datadogCredentials: credsField,
+        user_id: z.string().describe('Owner user ID'),
+        rule_id: z.string().describe('Notification rule ID'),
+    }),
+    execute: async ({ datadogCredentials, user_id, rule_id }) => {
+        try {
+            return await ddApi(datadogCredentials, 'GET', `/api/v2/on-call/users/${user_id}/notification-rules/${rule_id}`);
+        }
+        catch (error) {
+            return toDatadogError(error, 'Failed to get notification rule');
+        }
+    },
+});
+export const datadogListNotificationRules = tool({
+    description: 'List all notification rules configured for a user.',
+    inputSchema: z.object({
+        datadogCredentials: credsField,
+        user_id: z.string().describe('Owner user ID'),
+    }),
+    execute: async ({ datadogCredentials, user_id }) => {
+        try {
+            return await ddApi(datadogCredentials, 'GET', `/api/v2/on-call/users/${user_id}/notification-rules`);
+        }
+        catch (error) {
+            return toDatadogError(error, 'Failed to list notification rules');
+        }
+    },
+});
+export const datadogUpdateNotificationRule = tool({
+    description: 'Update a user notification rule by ID (category, delay, channel).',
+    inputSchema: z.object({
+        datadogCredentials: credsField,
+        user_id: z.string().describe('Owner user ID'),
+        rule_id: z.string().describe('Notification rule ID to update'),
+        data: z.record(z.any()).describe("JSON:API data object with the rule update"),
+    }),
+    execute: async ({ datadogCredentials, user_id, rule_id, data }) => {
+        try {
+            return await ddApi(datadogCredentials, 'PUT', `/api/v2/on-call/users/${user_id}/notification-rules/${rule_id}`, { body: { data } });
+        }
+        catch (error) {
+            return toDatadogError(error, 'Failed to update notification rule');
+        }
+    },
+});
+export const datadogDeleteNotificationRule = tool({
+    description: 'Delete a user notification rule. Irreversible — confirm with the user first.',
+    inputSchema: z.object({
+        datadogCredentials: credsField,
+        user_id: z.string().describe('Owner user ID'),
+        rule_id: z.string().describe('Notification rule ID to delete'),
+    }),
+    execute: async ({ datadogCredentials, user_id, rule_id }) => {
+        try {
+            await ddApi(datadogCredentials, 'DELETE', `/api/v2/on-call/users/${user_id}/notification-rules/${rule_id}`);
+            return { success: true };
+        }
+        catch (error) {
+            return toDatadogError(error, 'Failed to delete notification rule');
+        }
+    },
+});
+//# sourceMappingURL=oncall-notifications.js.map

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

@@ -0,0 +1,28 @@
+export declare const datadogCreateEscalationPolicy: import("ai").Tool<{
+    data: Record<string, any>;
+    datadogCredentials: string;
+}, any>;
+export declare const datadogGetEscalationPolicy: import("ai").Tool<{
+    policy_id: string;
+    datadogCredentials: string;
+}, any>;
+export declare const datadogUpdateEscalationPolicy: import("ai").Tool<{
+    data: Record<string, any>;
+    policy_id: string;
+    datadogCredentials: string;
+}, any>;
+export declare const datadogDeleteEscalationPolicy: import("ai").Tool<{
+    policy_id: string;
+    datadogCredentials: string;
+}, {
+    error: string;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+} | {
+    deleted: boolean;
+    policy_id: string;
+    status: number;
+}>;
+//# sourceMappingURL=oncall-policies.d.ts.map