@rnsk/toolkits 0.0.10 → 0.0.12

package/dist/toolkits/new-relic/tools/ingest.d.ts

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+export declare const sendEvents: import("ai").Tool<{
+    events: Record<string, any>[];
+    accountId: string;
+    insertKey: string;
+}, any>;
+export declare const sendTraces: import("ai").Tool<{
+    ingestKey: string;
+    traces: {
+        spans: {
+            id: string;
+            attributes: {
+                'duration.ms': number;
+                name?: string | undefined;
+                'parent.id'?: string | null | undefined;
+                'service.name'?: string | undefined;
+            } & {
+                [k: string]: any;
+            };
+            'trace.id': string;
+            timestamp?: number | undefined;
+        }[];
+        common?: z.objectOutputType<{
+            'service.name': z.ZodOptional<z.ZodString>;
+            host: z.ZodOptional<z.ZodString>;
+        }, z.ZodAny, "strip"> | undefined;
+    }[];
+    dataFormat?: "newrelic" | undefined;
+    dataFormatVersion?: string | undefined;
+}, any>;
+//# sourceMappingURL=ingest.d.ts.map

package/dist/toolkits/new-relic/tools/ingest.js

@@ -0,0 +1,80 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { EVENTS_API_BASE, TRACE_API_BASE } from './client.js';
+export const sendEvents = tool({
+    description: 'Sends custom events (business metrics, app events) for NRQL querying/charting. Each event needs eventType. Uses an Insights insert key (not the user key).',
+    inputSchema: z.object({
+        accountId: z.string().describe('Account ID receiving the events'),
+        insertKey: z.string().describe('Insights insert API key (X-Insert-Key) — differs from the user API key'),
+        events: z.array(z.record(z.any())).min(1).describe("Events with eventType + attributes, e.g. [{eventType:'Purchase',amount:99.99,userId:'user123'}]"),
+    }),
+    execute: async ({ accountId, insertKey, events }) => {
+        try {
+            if (!insertKey)
+                return { error: 'New Relic insert key is required. Provide insertKey.' };
+            const response = await fetch(`${EVENTS_API_BASE}/accounts/${accountId}/events`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', 'X-Insert-Key': insertKey },
+                body: JSON.stringify(events),
+            });
+            const data = await response.json().catch(() => ({}));
+            if (!response.ok)
+                return { error: 'Failed to send events', details: data };
+            return data;
+        }
+        catch (error) {
+            return { error: 'Error sending events', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+const spanSchema = z.object({
+    id: z.string().describe('Unique span ID'),
+    'trace.id': z.string().describe('Trace ID shared by all spans in the trace'),
+    timestamp: z.number().int().optional().describe('Start epoch millis (default receipt time)'),
+    attributes: z.object({
+        'duration.ms': z.number().describe('Span duration millis (required)'),
+        name: z.string().optional().describe("Span name, e.g. '/api/users'"),
+        'parent.id': z.string().nullable().optional().describe('Caller span ID (null for root — traces need a root)'),
+        'service.name': z.string().optional().describe('Owning entity, e.g. order-service'),
+    }).catchall(z.any()).describe('Span details (duration.ms required)'),
+});
+export const sendTraces = tool({
+    description: 'Sends distributed-trace spans (New Relic format, max 1MB post-compression) for latency debugging. Uses a license/ingest key (not the user key).',
+    inputSchema: z.object({
+        ingestKey: z.string().describe('License (ingest) key for the Trace API — differs from the user API key'),
+        traces: z.array(z.object({
+            spans: z.array(spanSchema).min(1).describe('Units of work (at least one span)'),
+            common: z.object({
+                'service.name': z.string().optional().describe('Default service for all spans'),
+                host: z.string().optional().describe('Default host for all spans'),
+            }).catchall(z.any()).optional().describe('Shared attributes (span values override)'),
+        })).min(1).describe('Traces to report'),
+        dataFormat: z.enum(['newrelic']).optional().describe("Format (default 'newrelic')"),
+        dataFormatVersion: z.string().optional().describe("Version (default '1')"),
+    }),
+    execute: async ({ ingestKey, traces, dataFormat, dataFormatVersion }) => {
+        try {
+            if (!ingestKey)
+                return { error: 'New Relic ingest key is required. Provide ingestKey.' };
+            const response = await fetch(TRACE_API_BASE, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Api-Key': ingestKey,
+                    'Data-Format': dataFormat ?? 'newrelic',
+                    'Data-Format-Version': dataFormatVersion ?? '1',
+                },
+                body: JSON.stringify(traces),
+            });
+            const data = await response.json().catch(() => ({}));
+            if (!response.ok)
+                return { error: 'Failed to send traces', details: data };
+            return data;
+        }
+        catch (error) {
+            return { error: 'Error sending traces', message: error instanceof Error ? error.message : 'Unknown error' };
+        }
+    },
+});
+//# sourceMappingURL=ingest.js.map

package/dist/toolkits/new-relic/tools/notifications.d.ts

@@ -0,0 +1,186 @@
+export declare const createAiNotificationsChannel: import("ai").Tool<{
+    type: "WEBHOOK" | "EMAIL" | "SLACK" | "PAGERDUTY_ACCOUNT_INTEGRATION" | "PAGERDUTY_SERVICE_INTEGRATION" | "SERVICENOW_INCIDENTS" | "JIRA_CLASSIC" | "JIRA_NEXTGEN" | "MOBILE_PUSH";
+    product: "IINT" | "ERROR_TRACKING" | "DISCUSSIONS";
+    name: string;
+    properties: {
+        value: string;
+        key: string;
+    }[];
+    accountId: string;
+    destinationId: string;
+    newRelicApiKey?: string | undefined;
+}, any>;
+export declare const updateAiNotificationsChannel: import("ai").Tool<{
+    channel: {
+        name?: string | undefined;
+        active?: boolean | undefined;
+    };
+    accountId: string;
+    channelId: string;
+    newRelicApiKey?: string | undefined;
+}, any>;
+export declare const deleteAiNotificationsChannel: import("ai").Tool<{
+    accountId: string;
+    channelId: string;
+    newRelicApiKey?: string | undefined;
+}, any>;
+export declare const testAiNotificationsChannel: import("ai").Tool<{
+    channel: {
+        type: "WEBHOOK" | "EMAIL" | "SLACK" | "PAGERDUTY_ACCOUNT_INTEGRATION" | "PAGERDUTY_SERVICE_INTEGRATION" | "SERVICENOW_INCIDENTS" | "JIRA_CLASSIC" | "SLACK_COLLABORATION";
+        product: "IINT" | "ERROR_TRACKING" | "DISCUSSIONS";
+        name: string;
+        properties: {
+            value: string;
+            key: string;
+        }[];
+        destinationId: string;
+    };
+    accountId: number;
+    newRelicApiKey?: string | undefined;
+}, any>;
+export declare const testNotificationChannel: import("ai").Tool<{
+    accountId: number;
+    channelId: string;
+    newRelicApiKey?: string | undefined;
+}, any>;
+export declare const createAiNotificationsDestination: import("ai").Tool<{
+    destination: {
+        type: "WEBHOOK" | "EMAIL" | "SLACK" | "JIRA" | "SERVICENOW" | "PAGERDUTY";
+        name: string;
+        properties: {
+            value: string;
+            key: string;
+        }[];
+        auth?: {
+            type: "BASIC" | "TOKEN" | "OAUTH2";
+            basic?: {
+                password: string;
+                user: string;
+            } | undefined;
+        } | undefined;
+    };
+    accountId: number;
+    newRelicApiKey?: string | undefined;
+}, any>;
+export declare const updateAiNotificationsDestination: import("ai").Tool<{
+    destination: {
+        name: string;
+    };
+    accountId: number;
+    destinationId: string;
+    newRelicApiKey?: string | undefined;
+}, any>;
+export declare const deleteAiNotificationsDestination: import("ai").Tool<{
+    accountId: number;
+    destinationId: string;
+    newRelicApiKey?: string | undefined;
+}, any>;
+export declare const testAiNotificationsDestination: import("ai").Tool<{
+    destination: {
+        type: string;
+        name: string;
+        properties: {
+            value: string;
+            key: string;
+        }[];
+    };
+    accountId: number;
+    newRelicApiKey?: string | undefined;
+}, any>;
+export declare const testAiNotificationDestinationById: import("ai").Tool<{
+    accountId: number;
+    destinationId: string;
+    newRelicApiKey?: string | undefined;
+}, any>;
+export declare const createAiWorkflow: import("ai").Tool<{
+    name: string;
+    accountId: number;
+    issuesFilter: {
+        name: string;
+        predicates: {
+            values: string[];
+            operator: string;
+            attribute: string;
+        }[];
+        type?: string | undefined;
+    };
+    destinationConfigurations: {
+        channelId: string;
+        notificationTriggers: string[];
+    }[];
+    newRelicApiKey?: string | undefined;
+    enrichments?: {
+        nrql?: {
+            name: string;
+            nrql: string;
+        }[] | undefined;
+    } | undefined;
+    workflowEnabled?: boolean | undefined;
+    enrichmentsEnabled?: boolean | undefined;
+    destinationsEnabled?: boolean | undefined;
+    mutingRulesHandling?: "DONT_NOTIFY_FULLY_MUTED_ISSUES" | "NOTIFY_ALL_ISSUES" | "DONT_NOTIFY_FULLY_OR_PARTIALLY_MUTED_ISSUES" | undefined;
+}, any>;
+export declare const updateWorkflow: import("ai").Tool<{
+    accountId: number;
+    updateWorkflowData: {
+        id: string;
+        name?: string | undefined;
+        issuesFilter?: Record<string, any> | undefined;
+        destinationConfigurations?: {
+            channelId: string;
+            notificationTriggers?: string[] | undefined;
+        }[] | undefined;
+        enrichments?: Record<string, any>[] | undefined;
+        workflowEnabled?: boolean | undefined;
+        enrichmentsEnabled?: boolean | undefined;
+        destinationsEnabled?: boolean | undefined;
+        mutingRulesHandling?: string | undefined;
+    };
+    newRelicApiKey?: string | undefined;
+}, any>;
+export declare const createAlertChannel: import("ai").Tool<{
+    type: "email" | "slack" | "webhook" | "pagerduty" | "opsgenie" | "victorops";
+    name: string;
+    configuration: {
+        recipients?: string | undefined;
+        apiKey?: string | undefined;
+        url?: string | undefined;
+        key?: string | undefined;
+        teams?: string | undefined;
+        channel?: string | undefined;
+        tags?: string | undefined;
+        serviceKey?: string | undefined;
+        routeKey?: string | undefined;
+        authUsername?: string | undefined;
+        authPassword?: string | undefined;
+    };
+    newRelicApiKey?: string | undefined;
+}, any>;
+export declare const getAlertChannels: import("ai").Tool<{
+    page?: number | undefined;
+    newRelicApiKey?: string | undefined;
+}, any>;
+export declare const updateAlertChannel: import("ai").Tool<{
+    alertChannelId: number;
+    type?: "email" | "slack" | "webhook" | "pagerduty" | "opsgenie" | "victorops" | undefined;
+    name?: string | undefined;
+    newRelicApiKey?: string | undefined;
+    configuration?: {
+        recipients?: string | undefined;
+        apiKey?: string | undefined;
+        url?: string | undefined;
+        key?: string | undefined;
+        teams?: string | undefined;
+        channel?: string | undefined;
+        tags?: string | undefined;
+        serviceKey?: string | undefined;
+        routeKey?: string | undefined;
+        authUsername?: string | undefined;
+        authPassword?: string | undefined;
+    } | undefined;
+}, any>;
+export declare const deleteAlertChannel: import("ai").Tool<{
+    channelId: number;
+    newRelicApiKey?: string | undefined;
+}, any>;
+//# sourceMappingURL=notifications.d.ts.map

package/dist/toolkits/new-relic/tools/notifications.js

@@ -0,0 +1,232 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { accountIdField, nerdgraph, newRelicApiKeyField, restV2 } from './client.js';
+const channelProperty = z.object({
+    key: z.string().describe("Property key, e.g. 'channelId', 'payload', 'subject'"),
+    value: z.string().describe('Property value (JSON payloads as escaped strings)'),
+});
+const CHANNEL_SELECT = 'channel { id name type }';
+// ---- AI notification channels ----
+export const createAiNotificationsChannel = tool({
+    description: 'Creates an AI Notifications channel for Applied Intelligence alerts. Needs a pre-existing destination (create one first).',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        accountId: z.string().describe('Account ID for the channel'),
+        type: z.enum(['WEBHOOK', 'EMAIL', 'SLACK', 'PAGERDUTY_ACCOUNT_INTEGRATION', 'PAGERDUTY_SERVICE_INTEGRATION', 'SERVICENOW_INCIDENTS', 'JIRA_CLASSIC', 'JIRA_NEXTGEN', 'MOBILE_PUSH']),
+        name: z.string().describe("Channel name, e.g. 'Production Slack Alerts'"),
+        destinationId: z.string().describe('Destination UUID (create destination first)'),
+        product: z.enum(['IINT', 'ERROR_TRACKING', 'DISCUSSIONS']).describe('IINT = Applied Intelligence alerts'),
+        properties: z.array(channelProperty).min(1).describe("Type-specific props: SLACK needs channelId; WEBHOOK needs payload"),
+    }),
+    execute: async ({ newRelicApiKey, accountId, ...channel }) => nerdgraph(newRelicApiKey, `mutation($accountId: Int!, $channel: AiNotificationsChannelInput!) { aiNotificationsCreateChannel(accountId: $accountId, channel: $channel) { ${CHANNEL_SELECT} } }`, { accountId: Number(accountId), channel }, 'create AI notifications channel'),
+});
+export const updateAiNotificationsChannel = tool({
+    description: 'Updates an AI channel name or active status. Only provided fields change.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        accountId: z.string().describe('Account ID owning the channel'),
+        channelId: z.string().describe('Channel UUID to update'),
+        channel: z.object({
+            name: z.string().optional().describe('New channel name'),
+            active: z.boolean().optional().describe('Activate/deactivate'),
+        }).describe('Fields to update'),
+    }),
+    execute: async ({ newRelicApiKey, accountId, channelId, channel }) => nerdgraph(newRelicApiKey, `mutation($accountId: Int!, $channelId: ID!, $channel: AiNotificationsChannelUpdateInput!) { aiNotificationsUpdateChannel(accountId: $accountId, channelId: $channelId, channel: $channel) { ${CHANNEL_SELECT} } }`, { accountId: Number(accountId), channelId, channel }, 'update AI notifications channel'),
+});
+export const deleteAiNotificationsChannel = tool({
+    description: 'Deletes an AI notifications channel by ID after confirming ownership.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        accountId: z.string().describe('Account ID owning the channel'),
+        channelId: z.string().describe('Channel UUID to delete'),
+    }),
+    execute: async ({ newRelicApiKey, accountId, channelId }) => nerdgraph(newRelicApiKey, 'mutation($accountId: Int!, $channelId: ID!) { aiNotificationsDeleteChannel(accountId: $accountId, channelId: $channelId) { ids } }', { accountId: Number(accountId), channelId }, 'delete AI notifications channel'),
+});
+export const testAiNotificationsChannel = tool({
+    description: 'Tests an AI channel configuration before saving by sending a trial notification. Reports SUCCESS/FAIL.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        accountId: accountIdField('Account ID for the test'),
+        channel: z.object({
+            type: z.enum(['EMAIL', 'WEBHOOK', 'PAGERDUTY_ACCOUNT_INTEGRATION', 'PAGERDUTY_SERVICE_INTEGRATION', 'SLACK', 'SLACK_COLLABORATION', 'SERVICENOW_INCIDENTS', 'JIRA_CLASSIC']),
+            name: z.string().describe('Display name for the test channel'),
+            destinationId: z.string().describe('Destination endpoint UUID'),
+            product: z.enum(['DISCUSSIONS', 'ERROR_TRACKING', 'IINT']),
+            properties: z.array(channelProperty).min(1),
+        }).describe('Channel configuration to test'),
+    }),
+    execute: async ({ newRelicApiKey, accountId, channel }) => nerdgraph(newRelicApiKey, 'mutation($accountId: Int!, $channel: AiNotificationsChannelInput!) { aiNotificationsTestChannel(accountId: $accountId, channel: $channel) { result details error { details } } }', { accountId, channel }, 'test AI notifications channel'),
+});
+export const testNotificationChannel = tool({
+    description: 'Sends a test notification through an existing AI channel to verify it delivers correctly.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        accountId: accountIdField('Account ID owning the channel'),
+        channelId: z.string().describe('Channel UUID to test'),
+    }),
+    execute: async ({ newRelicApiKey, accountId, channelId }) => nerdgraph(newRelicApiKey, 'mutation($accountId: Int!, $channelId: ID!) { aiNotificationsTestChannelById(accountId: $accountId, channelId: $channelId) { result details error { details } } }', { accountId, channelId }, 'test notification channel'),
+});
+// ---- AI notification destinations ----
+const destinationProperty = z.object({
+    key: z.string().describe("Property key, e.g. 'url' for Jira/webhook, 'email' for EMAIL"),
+    value: z.string().describe('Property value'),
+});
+export const createAiNotificationsDestination = tool({
+    description: 'Creates an AI notifications destination (Jira, ServiceNow, webhook, Slack, PagerDuty). Channels attach to destinations.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        accountId: accountIdField('Account ID for the destination'),
+        destination: z.object({
+            type: z.enum(['JIRA', 'SERVICENOW', 'WEBHOOK', 'EMAIL', 'SLACK', 'PAGERDUTY']),
+            name: z.string().describe('Destination name'),
+            properties: z.array(destinationProperty).min(1).describe("Config props: Jira needs 'url'"),
+            auth: z.object({
+                type: z.enum(['BASIC', 'TOKEN', 'OAUTH2']),
+                basic: z.object({ user: z.string(), password: z.string() }).optional().describe('BASIC credentials'),
+            }).optional(),
+        }).describe('Destination configuration'),
+    }),
+    execute: async ({ newRelicApiKey, accountId, destination }) => nerdgraph(newRelicApiKey, 'mutation($accountId: Int!, $destination: AiNotificationsDestinationInput!) { aiNotificationsCreateDestination(accountId: $accountId, destination: $destination) { destination { id name } error { type description } } }', { accountId, destination }, 'create AI notifications destination'),
+});
+export const updateAiNotificationsDestination = tool({
+    description: 'Renames an AI destination. Partial update — only provided fields change.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        accountId: accountIdField('Account ID owning the destination'),
+        destinationId: z.string().describe('Destination UUID to update'),
+        destination: z.object({ name: z.string().describe('New destination name') }).describe('Fields to update'),
+    }),
+    execute: async ({ newRelicApiKey, accountId, destinationId, destination }) => nerdgraph(newRelicApiKey, 'mutation($accountId: Int!, $destinationId: ID!, $destination: AiNotificationsDestinationUpdateInput!) { aiNotificationsUpdateDestination(accountId: $accountId, destinationId: $destinationId, destination: $destination) { destination { id name type } error { type description } } }', { accountId, destinationId, destination }, 'update AI notifications destination'),
+});
+export const deleteAiNotificationsDestination = tool({
+    description: 'Deletes an AI notifications destination by ID after confirming ownership.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        accountId: accountIdField('Account ID owning the destination'),
+        destinationId: z.string().describe('Destination UUID to delete'),
+    }),
+    execute: async ({ newRelicApiKey, accountId, destinationId }) => nerdgraph(newRelicApiKey, 'mutation($accountId: Int!, $destinationId: ID!) { aiNotificationsDeleteDestination(accountId: $accountId, destinationId: $destinationId) { ids } }', { accountId, destinationId }, 'delete AI notifications destination'),
+});
+export const testAiNotificationsDestination = tool({
+    description: 'Validates a destination configuration (EMAIL/WEBHOOK/etc.) before or after creating it.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        accountId: accountIdField('Account ID for the test'),
+        destination: z.object({
+            type: z.string().describe("Destination type, e.g. 'EMAIL', 'WEBHOOK', 'SLACK_COLLABORATION'"),
+            name: z.string().describe('Test destination name'),
+            properties: z.array(destinationProperty).min(1).describe("EMAIL needs 'email'; WEBHOOK needs 'url'"),
+        }).describe('Destination configuration to test'),
+    }),
+    execute: async ({ newRelicApiKey, accountId, destination }) => nerdgraph(newRelicApiKey, 'mutation($accountId: Int!, $destination: AiNotificationsDestinationInput!) { aiNotificationsTestDestination(accountId: $accountId, destination: $destination) { result details error { details } } }', { accountId, destination }, 'test AI notifications destination'),
+});
+export const testAiNotificationDestinationById = tool({
+    description: 'Tests an existing destination by UUID to verify it can receive messages.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        accountId: accountIdField('Account ID owning the destination'),
+        destinationId: z.string().describe('Destination UUID to test'),
+    }),
+    execute: async ({ newRelicApiKey, accountId, destinationId }) => nerdgraph(newRelicApiKey, 'mutation($accountId: Int!, $destinationId: ID!) { aiNotificationsTestDestinationById(accountId: $accountId, destinationId: $destinationId) { result details error { details } } }', { accountId, destinationId }, 'test AI notification destination by ID'),
+});
+// ---- AI workflows ----
+const workflowPredicate = z.object({
+    attribute: z.string().describe("Filter attribute, e.g. 'priority', 'labels.policyIds'"),
+    operator: z.string().describe("Operator, e.g. 'EQUAL', 'EXACTLY_MATCHES', 'CONTAINS'"),
+    values: z.array(z.string()).min(1),
+});
+export const createAiWorkflow = tool({
+    description: 'Creates an AI workflow routing filtered issues to channels with optional NRQL enrichments. Needs channel UUIDs from AI channels first.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        accountId: accountIdField('Account ID for the workflow'),
+        name: z.string().describe("Workflow name, e.g. 'Production Alert Workflow'"),
+        issuesFilter: z.object({
+            name: z.string().describe('Filter name'),
+            type: z.string().optional().describe("Must be 'FILTER' if provided"),
+            predicates: z.array(workflowPredicate).min(1),
+        }).describe('Which issues trigger the workflow (at least one predicate)'),
+        destinationConfigurations: z.array(z.object({
+            channelId: z.string().describe('Notification channel UUID'),
+            notificationTriggers: z.array(z.string()).min(1).describe("e.g. ['ACTIVATED','CLOSED']"),
+        })).min(1).describe('Channels to notify (at least one)'),
+        enrichments: z.object({ nrql: z.array(z.object({ name: z.string(), nrql: z.string() })).optional() }).optional().describe('NRQL enrichments adding context'),
+        workflowEnabled: z.boolean().optional().describe('Active on creation (default true)'),
+        enrichmentsEnabled: z.boolean().optional(),
+        destinationsEnabled: z.boolean().optional(),
+        mutingRulesHandling: z.enum(['DONT_NOTIFY_FULLY_MUTED_ISSUES', 'NOTIFY_ALL_ISSUES', 'DONT_NOTIFY_FULLY_OR_PARTIALLY_MUTED_ISSUES']).optional(),
+    }),
+    execute: async ({ newRelicApiKey, accountId, ...workflow }) => nerdgraph(newRelicApiKey, `mutation($accountId: Int!, $workflow: AiWorkflowsCreateWorkflowInput!) { aiWorkflowsCreateWorkflow(accountId: $accountId, workflow: $workflow) { workflow { id name workflowEnabled destinationsEnabled } errors { type description } } }`, { accountId, workflow: { workflowEnabled: true, destinationsEnabled: true, ...workflow } }, 'create AI workflow'),
+});
+export const updateWorkflow = tool({
+    description: 'Updates an AI workflow (name, toggles, destinations, enrichments, filters). Only the ID is required; other fields change if provided.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        accountId: accountIdField('Account ID owning the workflow'),
+        updateWorkflowData: z.object({
+            id: z.string().describe('Workflow UUID to update'),
+            name: z.string().optional(),
+            workflowEnabled: z.boolean().optional(),
+            enrichmentsEnabled: z.boolean().optional(),
+            destinationsEnabled: z.boolean().optional(),
+            mutingRulesHandling: z.string().optional(),
+            enrichments: z.array(z.record(z.any())).optional(),
+            issuesFilter: z.record(z.any()).optional().describe("Filter update wrapped as {filterInput: {name, type, predicates}}"),
+            destinationConfigurations: z.array(z.object({ channelId: z.string(), notificationTriggers: z.array(z.string()).optional() })).optional(),
+        }).describe('Workflow update (id required)'),
+    }),
+    execute: async ({ newRelicApiKey, accountId, updateWorkflowData }) => nerdgraph(newRelicApiKey, 'mutation($accountId: Int!, $updateWorkflowData: AiWorkflowsUpdateWorkflowInput!) { aiWorkflowsUpdateWorkflow(accountId: $accountId, updateWorkflowData: $updateWorkflowData) { workflow { id name workflowEnabled } errors { type description } } }', { accountId, updateWorkflowData }, 'update AI workflow'),
+});
+// ---- Legacy REST notification channels ----
+const channelConfig = z.object({
+    recipients: z.string().optional().describe("Email: comma-separated addresses (required for 'email')"),
+    url: z.string().optional().describe("Webhook/Slack URL (required for 'webhook'/'slack')"),
+    channel: z.string().optional().describe("Slack channel name without '#'"),
+    serviceKey: z.string().optional().describe("PagerDuty service key (required for 'pagerduty')"),
+    apiKey: z.string().optional().describe("OpsGenie API key (required for 'opsgenie')"),
+    tags: z.string().optional().describe('OpsGenie tags'),
+    teams: z.string().optional().describe('OpsGenie teams'),
+    routeKey: z.string().optional().describe("VictorOps routing key (required for 'victorops')"),
+    key: z.string().optional().describe("VictorOps API key (required for 'victorops')"),
+    authUsername: z.string().optional().describe('Webhook basic-auth username'),
+    authPassword: z.string().optional().describe('Webhook basic-auth password'),
+}).describe('Type-specific channel configuration');
+export const createAlertChannel = tool({
+    description: 'Registers a legacy alert channel endpoint (email, Slack, webhook, PagerDuty, OpsGenie, VictorOps). Link it to policies afterwards.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        type: z.enum(['email', 'slack', 'webhook', 'pagerduty', 'opsgenie', 'victorops']),
+        name: z.string().describe('Human-readable channel name'),
+        configuration: channelConfig,
+    }),
+    execute: async ({ newRelicApiKey, ...channel }) => restV2(newRelicApiKey, 'POST', '/alerts_channels.json', { body: { channel } }, 'create alert channel'),
+});
+export const getAlertChannels = tool({
+    description: 'Lists legacy alert channels (IDs, names, types, policy links) to discover linkable channels. Paginated.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        page: z.number().int().min(1).optional().describe('Page number (1-indexed)'),
+    }),
+    execute: async ({ newRelicApiKey, page }) => restV2(newRelicApiKey, 'GET', '/alerts_channels.json', { query: { page } }, 'list alert channels'),
+});
+export const updateAlertChannel = tool({
+    description: 'Updates a legacy alert channel (name, type, configuration) after verifying its ID.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        alertChannelId: z.number().int().min(1).describe('Channel ID to update'),
+        name: z.string().optional().describe('New channel name'),
+        type: z.enum(['email', 'slack', 'webhook', 'pagerduty', 'opsgenie', 'victorops']).optional().describe('Provide only to change type'),
+        configuration: channelConfig.optional(),
+    }),
+    execute: async ({ newRelicApiKey, alertChannelId, ...channel }) => restV2(newRelicApiKey, 'PUT', `/alerts_channels/${alertChannelId}.json`, { body: { channel } }, 'update alert channel'),
+});
+export const deleteAlertChannel = tool({
+    description: 'Deletes a legacy alert channel by ID after confirming ownership.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        channelId: z.number().int().describe('Channel ID to delete'),
+    }),
+    execute: async ({ newRelicApiKey, channelId }) => restV2(newRelicApiKey, 'DELETE', `/alerts_channels/${channelId}.json`, undefined, 'delete alert channel'),
+});
+//# sourceMappingURL=notifications.js.map

package/dist/toolkits/new-relic/tools/nrql-conditions.d.ts

@@ -0,0 +1,105 @@
+export declare const createStaticNrqlCondition: import("ai").Tool<{
+    name: string;
+    accountId: number;
+    policyId: string;
+    nrql: {
+        query: string;
+    };
+    signal: {
+        aggregationWindow: number;
+        aggregationMethod: "EVENT_FLOW" | "EVENT_TIMER" | "CADENCE";
+        aggregationDelay?: number | undefined;
+    };
+    terms: {
+        priority: "CRITICAL" | "WARNING";
+        threshold: number;
+        thresholdDuration: number;
+        thresholdOccurrences: "ALL" | "AT_LEAST_ONCE";
+        operator: "ABOVE" | "ABOVE_OR_EQUALS" | "BELOW" | "BELOW_OR_EQUALS" | "EQUALS" | "NOT_EQUALS";
+    };
+    valueFunction: "SINGLE_VALUE" | "SUM";
+    violationTimeLimitSeconds: number;
+    description?: string | undefined;
+    enabled?: boolean | undefined;
+    newRelicApiKey?: string | undefined;
+    expiration?: {
+        expirationDuration?: number | undefined;
+        openViolationOnExpiration?: boolean | undefined;
+        closeViolationsOnExpiration?: boolean | undefined;
+    } | undefined;
+}, any>;
+export declare const updateStaticNrqlCondition: import("ai").Tool<{
+    id: string;
+    accountId: number;
+    condition: Record<string, any>;
+    newRelicApiKey?: string | undefined;
+}, any>;
+export declare const createNrqlBaselineCondition: import("ai").Tool<{
+    accountId: number;
+    policyId: number;
+    condition: {
+        enabled: boolean;
+        name: string;
+        nrql: {
+            query: string;
+        };
+        signal: {
+            aggregationWindow: number;
+            aggregationMethod: "EVENT_FLOW" | "EVENT_TIMER" | "CADENCE";
+            aggregationDelay?: number | undefined;
+        };
+        terms: {
+            priority: "CRITICAL" | "WARNING";
+            threshold: number;
+            thresholdDuration: number;
+            thresholdOccurrences: "ALL" | "AT_LEAST_ONCE";
+            operator: "ABOVE" | "BELOW" | "EQUALS";
+        }[];
+        baselineDirection: "LOWER_ONLY" | "UPPER_ONLY" | "UPPER_AND_LOWER";
+        description?: string | undefined;
+        runbookUrl?: string | undefined;
+    };
+    newRelicApiKey?: string | undefined;
+}, any>;
+export declare const updateNrqlBaselineCondition: import("ai").Tool<{
+    id: string;
+    accountId: number;
+    condition: Record<string, any>;
+    newRelicApiKey?: string | undefined;
+}, any>;
+export declare const createNrqlCondition: import("ai").Tool<{
+    policyId: number;
+    nrqlCondition: {
+        enabled: boolean;
+        name: string;
+        nrql: {
+            query: string;
+        };
+        terms: {
+            priority: "warning" | "critical";
+            duration: string;
+            threshold: string;
+            operator: "above" | "below" | "equal";
+            timeFunction: "all" | "any";
+        }[];
+        type?: "static" | undefined;
+        valueFunction?: string | undefined;
+        runbookUrl?: string | undefined;
+    };
+    newRelicApiKey?: string | undefined;
+}, any>;
+export declare const updateNrqlCondition: import("ai").Tool<{
+    nrqlCondition: Record<string, any>;
+    conditionId: number;
+    newRelicApiKey?: string | undefined;
+}, any>;
+export declare const deleteNrqlCondition: import("ai").Tool<{
+    conditionId: number;
+    newRelicApiKey?: string | undefined;
+}, any>;
+export declare const listNrqlConditions: import("ai").Tool<{
+    policyId: number;
+    page?: number | undefined;
+    newRelicApiKey?: string | undefined;
+}, any>;
+//# sourceMappingURL=nrql-conditions.d.ts.map