@rnsk/toolkits 0.0.10 → 0.0.11

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

@@ -0,0 +1,73 @@
+export declare const createMetricNormalizationRule: import("ai").Tool<{
+    rule: {
+        action: "REPLACE" | "IGNORE" | "DENY_NEW_METRICS";
+        matchExpression: string;
+        evalOrder: number;
+        enabled?: boolean | undefined;
+        notes?: string | undefined;
+        replacement?: string | undefined;
+        terminateChain?: boolean | undefined;
+        applicationGuid?: string | undefined;
+    };
+    accountId: string;
+    newRelicApiKey?: string | undefined;
+}, any>;
+export declare const editMetricNormalizationRule: import("ai").Tool<{
+    rule: {
+        id: number;
+        action: "REPLACE" | "IGNORE" | "DENY_NEW_METRICS";
+        enabled: boolean;
+        notes?: string | undefined;
+        matchExpression?: string | undefined;
+        replacement?: string | undefined;
+    };
+    accountId: string;
+    newRelicApiKey?: string | undefined;
+}, any>;
+export declare const enableMetricNormalizationRule: import("ai").Tool<{
+    accountId: string;
+    ruleId: number;
+    newRelicApiKey?: string | undefined;
+}, any>;
+export declare const disableMetricNormalizationRule: import("ai").Tool<{
+    accountId: string;
+    ruleId: number;
+    newRelicApiKey?: string | undefined;
+}, any>;
+export declare const createLogDataPartitionRule: import("ai").Tool<{
+    description: string;
+    enabled: boolean;
+    accountId: number;
+    nrql: string;
+    targetDataPartition: string;
+    retentionPolicy: "STANDARD" | "SECONDARY";
+    newRelicApiKey?: string | undefined;
+}, any>;
+export declare const updateDataPartitionRule: import("ai").Tool<{
+    rule: {
+        id: string;
+        description?: string | undefined;
+        enabled?: boolean | undefined;
+        nrql?: string | undefined;
+    };
+    accountId: number;
+    newRelicApiKey?: string | undefined;
+}, any>;
+export declare const deleteDataPartitionRule: import("ai").Tool<{
+    id: string;
+    accountId: number;
+    newRelicApiKey?: string | undefined;
+}, any>;
+export declare const fetchBrowserConfiguration: import("ai").Tool<{
+    guid: string;
+    newRelicApiKey?: string | undefined;
+}, any>;
+export declare const fetchBrowserJavaScriptSnippet: import("ai").Tool<{
+    guid: string;
+    newRelicApiKey?: string | undefined;
+}, any>;
+export declare const fetchMobileApplicationToken: import("ai").Tool<{
+    guid: string;
+    newRelicApiKey?: string | undefined;
+}, any>;
+//# sourceMappingURL=config.d.ts.map

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

@@ -0,0 +1,131 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { RULE_RESULT_FIELDS, accountIdField, nerdgraph, newRelicApiKeyField } from './client.js';
+// ---- Metric normalization rules ----
+const normalizationRule = {
+    action: z.enum(['REPLACE', 'IGNORE', 'DENY_NEW_METRICS']).describe('REPLACE: rewrite match; IGNORE: drop; DENY_NEW_METRICS: block new names'),
+    matchExpression: z.string().describe("Full-match regex, e.g. '^WebTransaction/Uri/users/[0-9]+$'"),
+    evalOrder: z.number().int().min(0).optional().describe('Ascending eval order (use 2000 for custom rules)'),
+    replacement: z.string().optional().describe("Replacement for REPLACE (capture groups like '{id}'), e.g. 'WebTransaction/Uri/users/{id}'"),
+    notes: z.string().optional(),
+    enabled: z.boolean().optional().describe('Active when true'),
+    terminateChain: z.boolean().optional().describe('Stop further rules after match'),
+    applicationGuid: z.string().optional().describe('Scope to one app (omit for account-wide)'),
+};
+export const createMetricNormalizationRule = tool({
+    description: 'Creates a metric normalization rule (rename/drop/block metrics) to consolidate names and reduce cardinality. Regex must be ^...$ anchored.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        accountId: z.string().describe('Account ID for the rule'),
+        rule: z.object({
+            action: normalizationRule.action,
+            matchExpression: normalizationRule.matchExpression,
+            evalOrder: z.number().int().min(0).describe('Ascending eval order (use 2000 for custom rules)'),
+            replacement: normalizationRule.replacement,
+            notes: normalizationRule.notes,
+            enabled: z.boolean().optional().describe('Active when true (default true)'),
+            terminateChain: normalizationRule.terminateChain,
+            applicationGuid: normalizationRule.applicationGuid,
+        }).describe('Rule configuration'),
+    }),
+    execute: async ({ newRelicApiKey, accountId, rule }) => nerdgraph(newRelicApiKey, `mutation($accountId: String!, $rule: MetricNormalizationRuleInput!) { metricNormalizationCreateRule(accountId: $accountId, rule: $rule) { ${RULE_RESULT_FIELDS} } }`, { accountId, rule: { enabled: true, ...rule } }, 'create metric normalization rule'),
+});
+export const editMetricNormalizationRule = tool({
+    description: 'Edits a normalization rule (match, action, enabled, replacement). Only provided fields change; action + enabled are required by the API — resend current values.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        accountId: z.string().describe('Account ID owning the rule'),
+        rule: z.object({
+            id: z.number().int().positive().describe('Rule ID to edit'),
+            action: normalizationRule.action,
+            enabled: z.boolean(),
+            matchExpression: normalizationRule.matchExpression.optional(),
+            replacement: normalizationRule.replacement,
+            notes: normalizationRule.notes,
+        }).describe('Rule ID + fields to update'),
+    }),
+    execute: async ({ newRelicApiKey, accountId, rule }) => nerdgraph(newRelicApiKey, `mutation($accountId: String!, $rule: MetricNormalizationEditRuleInput!) { metricNormalizationEditRule(accountId: $accountId, rule: $rule) { ${RULE_RESULT_FIELDS} } }`, { accountId, rule }, 'edit metric normalization rule'),
+});
+export const enableMetricNormalizationRule = tool({
+    description: 'Reactivates a disabled normalization rule by ID.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        accountId: z.string().describe('Account ID owning the rule'),
+        ruleId: z.number().int().positive().describe('Rule ID to enable'),
+    }),
+    execute: async ({ newRelicApiKey, accountId, ruleId }) => nerdgraph(newRelicApiKey, `mutation($accountId: String!, $ruleId: ID!) { metricNormalizationEnableRule(accountId: $accountId, ruleId: $ruleId) { ${RULE_RESULT_FIELDS} } }`, { accountId, ruleId: String(ruleId) }, 'enable metric normalization rule'),
+});
+export const disableMetricNormalizationRule = tool({
+    description: 'Deactivates a normalization rule without deleting it (reversible via enable).',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        accountId: z.string().describe('Account ID owning the rule'),
+        ruleId: z.number().int().positive().describe('Rule ID to disable'),
+    }),
+    execute: async ({ newRelicApiKey, accountId, ruleId }) => nerdgraph(newRelicApiKey, `mutation($accountId: String!, $ruleId: ID!) { metricNormalizationDisableRule(accountId: $accountId, ruleId: $ruleId) { ${RULE_RESULT_FIELDS} } }`, { accountId, ruleId: String(ruleId) }, 'disable metric normalization rule'),
+});
+// ---- Log data partition rules ----
+const PARTITION_RESULT = 'rule { id targetDataPartition description enabled } errors { type message }';
+export const createLogDataPartitionRule = tool({
+    description: 'Creates a log partition rule routing matching logs to a Log_* partition with STANDARD or SECONDARY (30-day) retention.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        accountId: accountIdField('Account ID for the rule'),
+        targetDataPartition: z.string().describe("Target partition, must start with 'Log_', e.g. 'Log_ProductionLogs'"),
+        description: z.string().describe('Purpose of the rule'),
+        nrql: z.string().describe("WHERE clause without WHERE keyword, e.g. \"appName = 'prod' AND level = 'error'\""),
+        retentionPolicy: z.enum(['STANDARD', 'SECONDARY']).describe('STANDARD: account default; SECONDARY: 30-day rolling'),
+        enabled: z.boolean().describe('Route matching logs when true'),
+    }),
+    execute: async ({ newRelicApiKey, accountId, ...rule }) => nerdgraph(newRelicApiKey, `mutation($accountId: Int!, $rule: LogsDataPartitionRuleCreateInput!) { logConfigurationsDataPartitionRuleCreate(accountId: $accountId, rule: $rule) { ${PARTITION_RESULT} } }`, { accountId, rule }, 'create log data partition rule'),
+});
+export const updateDataPartitionRule = tool({
+    description: 'Updates a partition rule (description, NRQL criteria, enabled). All non-ID fields optional — partial updates supported.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        accountId: accountIdField('Account ID owning the rule'),
+        rule: z.object({
+            id: z.string().describe('Rule ID to update'),
+            description: z.string().optional(),
+            nrql: z.string().optional().describe("New WHERE clause, e.g. \"logtype = 'apache'\""),
+            enabled: z.boolean().optional().describe('false disables without deleting'),
+        }).describe('Rule ID + fields to update'),
+    }),
+    execute: async ({ newRelicApiKey, accountId, rule }) => nerdgraph(newRelicApiKey, `mutation($accountId: Int!, $rule: LogsDataPartitionRuleUpdateInput!) { logConfigurationsDataPartitionRuleUpdate(accountId: $accountId, rule: $rule) { ${PARTITION_RESULT} } }`, { accountId, rule }, 'update data partition rule'),
+});
+export const deleteDataPartitionRule = tool({
+    description: 'Deletes a log partition rule. Already-partitioned data is retained per its retention policy.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        accountId: accountIdField('Account ID owning the rule'),
+        id: z.string().describe('Rule ID to delete'),
+    }),
+    execute: async ({ newRelicApiKey, accountId, id }) => nerdgraph(newRelicApiKey, 'mutation($accountId: Int!, $id: ID!) { logConfigurationsDataPartitionRuleDelete(accountId: $accountId, id: $id) { errors { type message } } }', { accountId, id }, 'delete data partition rule'),
+});
+// ---- Browser / mobile fetchers ----
+export const fetchBrowserConfiguration = tool({
+    description: 'Reads browser app JS config (jsConfig for source code, jsConfigScript for head-tag injection) by entity GUID.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        guid: z.string().describe('Browser application entity GUID'),
+    }),
+    execute: async ({ newRelicApiKey, guid }) => nerdgraph(newRelicApiKey, `query($guid: EntityGuid!) { actor { entity(guid: $guid) { guid name ... on BrowserApplicationEntity { browserProperties { jsConfig jsConfigScript } } } } }`, { guid }, 'fetch browser configuration'),
+});
+export const fetchBrowserJavaScriptSnippet = tool({
+    description: 'Reads the browser loader script snippet (jsLoaderScript) to embed for browser monitoring.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        guid: z.string().describe('Browser application entity GUID'),
+    }),
+    execute: async ({ newRelicApiKey, guid }) => nerdgraph(newRelicApiKey, `query($guid: EntityGuid!) { actor { entity(guid: $guid) { guid name ... on BrowserApplicationEntity { browserProperties { jsLoaderScript } } } } }`, { guid }, 'fetch browser JavaScript snippet'),
+});
+export const fetchMobileApplicationToken = tool({
+    description: 'Reads the mobile application token (applicationToken) for SDK authentication and setup.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        guid: z.string().describe('Mobile application entity GUID'),
+    }),
+    execute: async ({ newRelicApiKey, guid }) => nerdgraph(newRelicApiKey, `query($guid: EntityGuid!) { actor { entity(guid: $guid) { guid name ... on MobileApplicationEntity { mobileProperties { applicationToken } } } } } }`, { guid }, 'fetch mobile application token'),
+});
+//# sourceMappingURL=config.js.map

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

@@ -0,0 +1,204 @@
+export declare const createDashboard: import("ai").Tool<{
+    pages: {
+        name: string;
+        widgets: {
+            title: string;
+            configuration: {
+                markdown?: {
+                    text: string;
+                } | undefined;
+                line?: {
+                    nrqlQueries: {
+                        query: string;
+                        accountId: number;
+                    }[];
+                } | undefined;
+                area?: {
+                    nrqlQueries: {
+                        query: string;
+                        accountId: number;
+                    }[];
+                } | undefined;
+                bar?: {
+                    nrqlQueries: {
+                        query: string;
+                        accountId: number;
+                    }[];
+                } | undefined;
+                pie?: {
+                    nrqlQueries: {
+                        query: string;
+                        accountId: number;
+                    }[];
+                } | undefined;
+                table?: {
+                    nrqlQueries: {
+                        query: string;
+                        accountId: number;
+                    }[];
+                } | undefined;
+                billboard?: {
+                    nrqlQueries: {
+                        query: string;
+                        accountId: number;
+                    }[];
+                } | undefined;
+            };
+            layout: {
+                column: number;
+                row: number;
+                width: number;
+                height: number;
+            };
+        }[];
+        description?: string | undefined;
+    }[];
+    name: string;
+    accountId: number;
+    description?: string | undefined;
+    newRelicApiKey?: string | undefined;
+    permissions?: "PRIVATE" | "PUBLIC_READ_ONLY" | "PUBLIC_READ_WRITE" | undefined;
+}, any>;
+export declare const updateDashboard: import("ai").Tool<{
+    pages: {
+        name: string;
+        widgets: {
+            title: string;
+            visualization: string;
+            rawConfiguration: Record<string, any>;
+            id?: string | undefined;
+            layout?: Record<string, number> | undefined;
+            linkedEntityGuids?: string[] | undefined;
+        }[];
+        description?: string | undefined;
+        guid?: string | undefined;
+    }[];
+    name: string;
+    permissions: "PRIVATE" | "PUBLIC_READ_ONLY" | "PUBLIC_READ_WRITE";
+    guid: string;
+    description?: string | undefined;
+    newRelicApiKey?: string | undefined;
+}, any>;
+export declare const deleteDashboard: import("ai").Tool<{
+    guid: string;
+    newRelicApiKey?: string | undefined;
+}, any>;
+export declare const undeleteDashboard: import("ai").Tool<{
+    guid: string;
+    newRelicApiKey?: string | undefined;
+}, any>;
+export declare const createDashboardSnapshotUrl: import("ai").Tool<{
+    guid: string;
+    newRelicApiKey?: string | undefined;
+}, any>;
+export declare const getDashboardEntity: import("ai").Tool<{
+    guid: string;
+    newRelicApiKey?: string | undefined;
+}, any>;
+export declare const addWidgetsToDashboardPage: import("ai").Tool<{
+    widgets: {
+        title: string;
+        configuration: {
+            markdown?: {
+                text: string;
+            } | undefined;
+            line?: {
+                nrqlQueries: {
+                    query: string;
+                    accountId: number;
+                }[];
+            } | undefined;
+            area?: {
+                nrqlQueries: {
+                    query: string;
+                    accountId: number;
+                }[];
+            } | undefined;
+            bar?: {
+                nrqlQueries: {
+                    query: string;
+                    accountId: number;
+                }[];
+            } | undefined;
+            pie?: {
+                nrqlQueries: {
+                    query: string;
+                    accountId: number;
+                }[];
+            } | undefined;
+            table?: {
+                nrqlQueries: {
+                    query: string;
+                    accountId: number;
+                }[];
+            } | undefined;
+            billboard?: {
+                nrqlQueries: {
+                    query: string;
+                    accountId: number;
+                }[];
+            } | undefined;
+        };
+        layout: {
+            column: number;
+            row: number;
+            width: number;
+            height: number;
+        };
+    }[];
+    guid: string;
+    newRelicApiKey?: string | undefined;
+}, any>;
+export declare const updateDashboardPage: import("ai").Tool<{
+    page: {
+        name: string;
+        widgets: {
+            title: string;
+            id: string;
+            layout: {
+                column: number;
+                row: number;
+                width: number;
+                height: number;
+            };
+            visualization: {
+                id: string;
+            };
+            rawConfiguration: {
+                text?: string | undefined;
+                nrqlQueries?: {
+                    query: string;
+                    accountId: number;
+                }[] | undefined;
+            };
+        }[];
+        description?: string | undefined;
+    };
+    guid: string;
+    newRelicApiKey?: string | undefined;
+}, any>;
+export declare const updateDashboardWidgetsInPage: import("ai").Tool<{
+    widgets: {
+        title: string;
+        id: string;
+        configuration: Record<string, any>;
+        layout: {
+            column: number;
+            row: number;
+            width: number;
+            height: number;
+        };
+        visualization: {
+            id: string;
+        };
+        linkedEntityGuids?: string[] | undefined;
+    }[];
+    guid: string;
+    newRelicApiKey?: string | undefined;
+}, any>;
+export declare const updateDashboardLiveUrlCreationPolicies: import("ai").Tool<{
+    accountIds: number[];
+    liveUrlCreationAllowed: boolean;
+    newRelicApiKey?: string | undefined;
+}, any>;
+//# sourceMappingURL=dashboards.d.ts.map

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

@@ -0,0 +1,159 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { accountIdField, nerdgraph, newRelicApiKeyField } from './client.js';
+const nrqlQueryInput = z.object({
+    accountId: z.number().int().positive().describe('Account ID to query data from'),
+    query: z.string().describe("NRQL query, e.g. 'SELECT count(*) FROM Transaction TIMESERIES'"),
+});
+const widgetConfiguration = z.object({
+    line: z.object({ nrqlQueries: z.array(nrqlQueryInput).min(1) }).optional(),
+    area: z.object({ nrqlQueries: z.array(nrqlQueryInput).min(1) }).optional(),
+    bar: z.object({ nrqlQueries: z.array(nrqlQueryInput).min(1) }).optional(),
+    pie: z.object({ nrqlQueries: z.array(nrqlQueryInput).min(1) }).optional(),
+    table: z.object({ nrqlQueries: z.array(nrqlQueryInput).min(1) }).optional(),
+    billboard: z.object({ nrqlQueries: z.array(nrqlQueryInput).min(1) }).optional(),
+    markdown: z.object({ text: z.string().describe('Markdown content') }).optional(),
+}).describe('Exactly one visualization key (line/area/bar/pie/table/billboard/markdown)');
+const widgetLayout = z.object({
+    column: z.number().int().min(1).max(12).describe('Start column (1-12)'),
+    row: z.number().int().min(1).describe('Start row (1+)'),
+    width: z.number().int().min(1).max(12).describe('Width in columns (1-12)'),
+    height: z.number().int().min(1).describe('Height in rows (1+)'),
+});
+const createWidget = z.object({
+    title: z.string().describe('Widget title on the dashboard'),
+    configuration: widgetConfiguration,
+    layout: widgetLayout.describe('Grid position and size'),
+});
+const createPage = z.object({
+    name: z.string().describe('Page name'),
+    description: z.string().optional(),
+    widgets: z.array(createWidget).min(1),
+});
+const DASHBOARD_ERRORS = 'errors { description type }';
+export const createDashboard = tool({
+    description: 'Creates a dashboard with pages and NRQL/markdown widgets. At least one page with one widget is required.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        accountId: accountIdField('Account ID for the dashboard'),
+        name: z.string().describe('Dashboard name, unique within the account'),
+        pages: z.array(createPage).min(1),
+        description: z.string().optional(),
+        permissions: z.enum(['PRIVATE', 'PUBLIC_READ_ONLY', 'PUBLIC_READ_WRITE']).optional().describe('Access control (default PRIVATE)'),
+    }),
+    execute: async ({ newRelicApiKey, accountId, ...dashboard }) => nerdgraph(newRelicApiKey, `mutation($accountId: Int!, $dashboard: DashboardInput!) { dashboardCreate(accountId: $accountId, dashboard: $dashboard) { entityResult { guid name } ${DASHBOARD_ERRORS} } }`, { accountId, dashboard: { permissions: 'PRIVATE', ...dashboard } }, 'create dashboard'),
+});
+export const updateDashboard = tool({
+    description: 'Updates a dashboard (name, permissions, pages, widgets). Include page GUIDs and widget IDs to preserve them — omitted ones are removed.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        guid: z.string().describe('Dashboard entity GUID to update'),
+        name: z.string().describe('Updated dashboard name'),
+        permissions: z.enum(['PRIVATE', 'PUBLIC_READ_ONLY', 'PUBLIC_READ_WRITE']).describe('Updated access control'),
+        pages: z.array(z.object({
+            guid: z.string().optional().describe('Page GUID (required to keep an existing page)'),
+            name: z.string(),
+            description: z.string().optional(),
+            widgets: z.array(z.object({
+                id: z.string().optional().describe('Widget ID (required to keep an existing widget)'),
+                title: z.string(),
+                visualization: z.string().describe("Viz ID, e.g. 'viz.line', 'viz.markdown'"),
+                rawConfiguration: z.record(z.any()).describe("Viz config: markdown {text} or NRQL {nrqlQueries:[{accountId,query}]}"),
+                layout: z.record(z.number()).optional().describe('{column,row,width,height}'),
+                linkedEntityGuids: z.array(z.string()).max(1).optional(),
+            })),
+        })).describe('Full replacement page list'),
+        description: z.string().optional().describe('Updated description (omit to retain)'),
+    }),
+    execute: async ({ newRelicApiKey, guid, ...dashboard }) => nerdgraph(newRelicApiKey, `mutation($guid: EntityGuid!, $dashboard: DashboardUpdateInput!) { dashboardUpdate(guid: $guid, dashboard: $dashboard) { entityResult { guid name } ${DASHBOARD_ERRORS} } }`, { guid, dashboard }, 'update dashboard'),
+});
+export const deleteDashboard = tool({
+    description: 'Permanently deletes a dashboard by entity GUID. Recoverable via undeleteDashboard (tags are not recovered).',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        guid: z.string().describe('Dashboard entity GUID to delete'),
+    }),
+    execute: async ({ newRelicApiKey, guid }) => nerdgraph(newRelicApiKey, `mutation($guid: EntityGuid!) { dashboardDelete(guid: $guid) { status ${DASHBOARD_ERRORS} } }`, { guid }, 'delete dashboard'),
+});
+export const undeleteDashboard = tool({
+    description: 'Recovers a logically deleted dashboard by GUID. Custom tags cannot be recovered.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        guid: z.string().describe('Deleted dashboard entity GUID to recover'),
+    }),
+    execute: async ({ newRelicApiKey, guid }) => nerdgraph(newRelicApiKey, `mutation($guid: EntityGuid!) { dashboardUndelete(guid: $guid) { ${DASHBOARD_ERRORS} } }`, { guid }, 'undelete dashboard'),
+});
+export const createDashboardSnapshotUrl = tool({
+    description: 'Generates a shareable snapshot URL (PDF) of a dashboard page at its current state for distribution/archiving.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        guid: z.string().describe('Dashboard page entity GUID to snapshot'),
+    }),
+    execute: async ({ newRelicApiKey, guid }) => nerdgraph(newRelicApiKey, 'mutation($guid: EntityGuid!) { dashboardCreateSnapshotUrl(guid: $guid) }', { guid }, 'create dashboard snapshot URL'),
+});
+export const getDashboardEntity = tool({
+    description: 'Reads full dashboard configuration (pages, widgets, owner, permissions) by entity GUID. Use before updates to capture IDs.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        guid: z.string().describe('Dashboard entity GUID to query'),
+    }),
+    execute: async ({ newRelicApiKey, guid }) => nerdgraph(newRelicApiKey, `query($guid: EntityGuid!) { actor { entity(guid: $guid) { guid name ... on DashboardEntity { description permissions owner { email userId } pages { guid name description createdAt updatedAt widgets { id title visualization { id } rawConfiguration } } createdAt updatedAt } } } }`, { guid }, 'query dashboard entity'),
+});
+export const addWidgetsToDashboardPage = tool({
+    description: 'Adds visualization widgets (line/area/bar/pie/table/billboard/markdown) to an existing dashboard page by page GUID.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        guid: z.string().describe('Dashboard page entity GUID'),
+        widgets: z.array(createWidget).min(1),
+    }),
+    execute: async ({ newRelicApiKey, guid, widgets }) => nerdgraph(newRelicApiKey, `mutation($guid: EntityGuid!, $widgets: [DashboardAddWidgetsToPageWidgetInput!]!) { dashboardAddWidgetsToPage(guid: $guid, widgets: $widgets) { ${DASHBOARD_ERRORS} } }`, { guid, widgets }, 'add widgets to dashboard page'),
+});
+export const updateDashboardPage = tool({
+    description: 'Updates a dashboard page (name, description, widget set). Include every widget with its ID or it is removed.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        guid: z.string().describe('Dashboard page entity GUID to update'),
+        page: z.object({
+            name: z.string().describe('Page name'),
+            description: z.string().optional(),
+            widgets: z.array(z.object({
+                id: z.string().describe('Widget ID (required to preserve identity)'),
+                title: z.string(),
+                visualization: z.object({ id: z.string().describe("Viz ID, e.g. 'viz.line'") }),
+                layout: widgetLayout,
+                rawConfiguration: z.object({
+                    text: z.string().optional().describe('Markdown content'),
+                    nrqlQueries: z.array(nrqlQueryInput).optional(),
+                }).describe('NRQL queries and/or markdown text'),
+            })).min(1).describe('Complete widget list with IDs'),
+        }).describe('Updated page configuration'),
+    }),
+    execute: async ({ newRelicApiKey, guid, page }) => nerdgraph(newRelicApiKey, `mutation($guid: EntityGuid!, $page: DashboardUpdatePageInput!) { dashboardUpdatePage(guid: $guid, page: $page) { ${DASHBOARD_ERRORS} } }`, { guid, page }, 'update dashboard page'),
+});
+export const updateDashboardWidgetsInPage = tool({
+    description: 'Updates existing widgets in a page (titles, layouts, queries). Each widget needs its ID.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        guid: z.string().describe('Dashboard page entity GUID'),
+        widgets: z.array(z.object({
+            id: z.string().describe('Widget ID to update'),
+            title: z.string(),
+            visualization: z.object({ id: z.string().describe("Viz ID, e.g. 'viz.markdown'") }),
+            layout: widgetLayout,
+            configuration: z.record(z.any()).describe("Content: markdown {text} and/or nrqlQueries [{accountId,query}]"),
+            linkedEntityGuids: z.array(z.string()).optional().describe('Facet-link entity GUIDs'),
+        })).min(1),
+    }),
+    execute: async ({ newRelicApiKey, guid, widgets }) => nerdgraph(newRelicApiKey, `mutation($guid: EntityGuid!, $widgets: [DashboardUpdateWidgetsInPageWidgetInput!]!) { dashboardUpdateWidgetsInPage(guid: $guid, widgets: $widgets) { ${DASHBOARD_ERRORS} } }`, { guid, widgets }, 'update dashboard widgets in page'),
+});
+export const updateDashboardLiveUrlCreationPolicies = tool({
+    description: 'Enables/disables public live-URL creation for dashboards in up to 100 accounts. Requires Authentication Domain Manager role.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        accountIds: z.array(z.number().int()).min(1).max(100).describe('Account IDs to update (max 100)'),
+        liveUrlCreationAllowed: z.boolean().describe('true to allow public live URLs, false to block'),
+    }),
+    execute: async ({ newRelicApiKey, accountIds, liveUrlCreationAllowed }) => nerdgraph(newRelicApiKey, 'mutation($accountIds: [Int!]!, $allowed: Boolean!) { dashboardUpdateLiveUrlCreationPolicies(accountIds: $accountIds, liveUrlCreationAllowed: $allowed) { liveUrlCreationPolicies { accountId liveUrlCreationAllowed } } }', { accountIds, allowed: liveUrlCreationAllowed }, 'update dashboard live URL creation policies'),
+});
+//# sourceMappingURL=dashboards.js.map