@rnsk/toolkits 0.0.10 → 0.0.12

package/dist/toolkits/new-relic/tools/alert-policies.js

@@ -0,0 +1,136 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { accountIdField, nerdgraph, newRelicApiKeyField, restV2 } from './client.js';
+const incidentPreference = z.enum(['PER_POLICY', 'PER_CONDITION', 'PER_CONDITION_AND_TARGET']).optional();
+const POLICY_SELECT = 'id name incidentPreference';
+export const createAlertPolicy = tool({
+    description: 'Creates an alert policy via REST API v2 (container for conditions; defines incident grouping). Use for basic policy setup.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        name: z.string().describe('Policy name, unique within the account'),
+        incidentPreference: z.enum(['PER_POLICY', 'PER_CONDITION', 'PER_CONDITION_AND_TARGET']).optional().describe('Incident grouping (default PER_POLICY)'),
+    }),
+    execute: async ({ newRelicApiKey, name, incidentPreference }) => restV2(newRelicApiKey, 'POST', '/alerts_policies.json', { body: { policy: { name, incident_preference: incidentPreference ?? 'PER_POLICY' } } }, 'create alert policy'),
+});
+export const getAlertPolicies = tool({
+    description: 'Lists alert policies with optional name filter and pagination. Use to find policy IDs for conditions and channels.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        name: z.string().optional().describe('Partial-match name filter'),
+        incidentPreference: incidentPreference.describe('Filter by incident preference'),
+        page: z.number().int().min(1).optional().describe('Page number (starts at 1)'),
+    }),
+    execute: async ({ newRelicApiKey, name, incidentPreference, page }) => restV2(newRelicApiKey, 'GET', '/alerts_policies.json', { query: { 'filter[name]': name, 'filter[incident_preference]': incidentPreference, page } }, 'list alert policies'),
+});
+export const updateAlertPolicyRest = tool({
+    description: 'Updates a policy name and/or incident preference via REST API v2. Provide at least one field.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        policyId: z.number().int().min(1).describe('Policy ID to update'),
+        name: z.string().optional().describe('New unique policy name'),
+        incidentPreference: incidentPreference.describe('New incident preference'),
+    }),
+    execute: async ({ newRelicApiKey, policyId, name, incidentPreference }) => {
+        if (!name && !incidentPreference)
+            return { error: 'Provide at least one of name or incidentPreference' };
+        return restV2(newRelicApiKey, 'PUT', `/alerts_policies/${policyId}.json`, { body: { policy: { name, incident_preference: incidentPreference } } }, 'update alert policy');
+    },
+});
+export const deleteAlertPolicy = tool({
+    description: 'Deletes an alert policy via REST API v2 after confirming the policy ID. Conditions in the policy are removed with it.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        policyId: z.string().describe('Policy ID to delete'),
+    }),
+    execute: async ({ newRelicApiKey, policyId }) => restV2(newRelicApiKey, 'DELETE', `/alerts_policies/${policyId}.json`, undefined, 'delete alert policy'),
+});
+export const createAlertPolicyGraphql = tool({
+    description: 'Creates an alert policy via NerdGraph. Prefer over REST when already working in GraphQL flows.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        accountId: accountIdField('Account ID for the new policy'),
+        name: z.string().describe('Policy name, unique within the account'),
+        incidentPreference: z.enum(['PER_POLICY', 'PER_CONDITION', 'PER_CONDITION_AND_TARGET']).optional().describe('Incident grouping (default PER_POLICY)'),
+    }),
+    execute: async ({ newRelicApiKey, accountId, name, incidentPreference }) => nerdgraph(newRelicApiKey, `mutation($accountId: Int!, $policy: AlertsPolicyInput!) { alertsPolicyCreate(accountId: $accountId, policy: $policy) { ${POLICY_SELECT} } }`, { accountId, policy: { name, incidentPreference: incidentPreference ?? 'PER_POLICY' } }, 'create alert policy'),
+});
+export const updateAlertPolicy = tool({
+    description: 'Updates a policy name and/or incident preference via NerdGraph. Provide at least one field in policy.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        accountId: accountIdField('Account ID owning the policy'),
+        policyId: z.string().describe('Policy ID to update'),
+        policy: z.object({
+            name: z.string().optional().describe('New unique policy name'),
+            incidentPreference: z.enum(['PER_POLICY', 'PER_CONDITION', 'PER_CONDITION_AND_TARGET']).optional(),
+        }).describe('Fields to update (at least one)'),
+    }),
+    execute: async ({ newRelicApiKey, accountId, policyId, policy }) => nerdgraph(newRelicApiKey, `mutation($accountId: Int!, $id: ID!, $policy: AlertsPolicyUpdateInput!) { alertsPolicyUpdate(accountId: $accountId, id: $id, policy: $policy) { ${POLICY_SELECT} } }`, { accountId, id: policyId, policy }, 'update alert policy'),
+});
+export const deleteAlertPolicyGraphql = tool({
+    description: 'Deletes an alert policy via NerdGraph. Use when operating in GraphQL flows instead of REST.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        accountId: accountIdField('Account ID owning the policy'),
+        policyId: z.string().describe('Policy ID to delete'),
+    }),
+    execute: async ({ newRelicApiKey, accountId, policyId }) => nerdgraph(newRelicApiKey, 'mutation($accountId: Int!, $id: ID!) { alertsPolicyDelete(accountId: $accountId, id: $id) { id } }', { accountId, id: policyId }, 'delete alert policy'),
+});
+export const deleteAlertsCondition = tool({
+    description: 'Deletes any alert condition type by ID via NerdGraph (NRQL static/baseline/outlier all supported). Only the id is returned.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        accountId: accountIdField('Account ID owning the condition'),
+        id: z.number().int().describe('Condition ID to delete'),
+    }),
+    execute: async ({ newRelicApiKey, accountId, id }) => nerdgraph(newRelicApiKey, 'mutation($accountId: Int!, $id: ID!) { alertsConditionDelete(accountId: $accountId, id: $id) { id } }', { accountId, id: String(id) }, 'delete alert condition'),
+});
+export const updateCrossAccountElections = tool({
+    description: 'Enables/disables cross-account alerting elections for up to 20 accounts (alerts visible across account boundaries).',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        accountIds: z.array(z.number().int()).min(1).max(20).describe('Account IDs to update (max 20)'),
+        electionStatus: z.boolean().describe('true to enable cross-account alerting, false to disable'),
+    }),
+    execute: async ({ newRelicApiKey, accountIds, electionStatus }) => nerdgraph(newRelicApiKey, 'mutation($accountIds: [Int!]!, $electionStatus: Boolean!) { alertsUpdateCrossAccountElections(accountIds: $accountIds, electionStatus: $electionStatus) { electionStatus } }', { accountIds, electionStatus }, 'update cross-account elections'),
+});
+export const addNotificationChannelsToPolicy = tool({
+    description: 'Associates existing notification channels with an alert policy via NerdGraph. Pass one or comma-separated channel IDs.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        accountId: accountIdField('Account ID containing the policy and channels'),
+        policyId: z.string().describe('Policy ID to add channels to'),
+        notificationChannelIds: z.string().describe("Channel ID(s), e.g. '888888' or '888888,888889'"),
+    }),
+    execute: async ({ newRelicApiKey, accountId, policyId, notificationChannelIds }) => nerdgraph(newRelicApiKey, 'mutation($accountId: Int!, $policyId: ID!, $ids: [ID!]!) { alertsNotificationChannelsAddToPolicy(accountId: $accountId, policyId: $policyId, notificationChannelIds: $ids) { policyId } }', { accountId, policyId, ids: notificationChannelIds.split(',').map((s) => s.trim()).filter(Boolean) }, 'add notification channels to policy'),
+});
+export const removeNotificationChannelsFromPolicy = tool({
+    description: 'Detaches notification channels from a policy via NerdGraph without deleting the channels themselves.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        accountId: accountIdField('Account ID containing the policy'),
+        policyId: z.number().int().describe('Policy ID to remove channels from'),
+        notificationChannelIds: z.array(z.number().int()).min(1).describe('Channel IDs to detach'),
+    }),
+    execute: async ({ newRelicApiKey, accountId, policyId, notificationChannelIds }) => nerdgraph(newRelicApiKey, 'mutation($accountId: Int!, $policyId: ID!, $ids: [ID!]!) { alertsNotificationChannelsRemoveFromPolicy(accountId: $accountId, policyId: $policyId, notificationChannelIds: $ids) { policyId } }', { accountId, policyId: String(policyId), ids: notificationChannelIds.map(String) }, 'remove notification channels from policy'),
+});
+export const updatePolicyChannels = tool({
+    description: 'Replaces all notification-channel associations on a policy via REST API v2 (existing links are overwritten).',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        policyId: z.number().int().describe('Policy ID to associate channels with'),
+        channelIds: z.array(z.number().int()).min(1).describe('Channel IDs (replaces existing associations)'),
+    }),
+    execute: async ({ newRelicApiKey, policyId, channelIds }) => restV2(newRelicApiKey, 'PUT', '/alerts_policy_channels.json', { query: { policy_id: policyId, channel_ids: channelIds.join(',') } }, 'update policy channels'),
+});
+export const deletePolicyChannel = tool({
+    description: 'Removes one notification channel from a policy via REST API v2 without deleting either resource.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        policyId: z.number().int().describe('Policy ID to remove the channel from'),
+        channelId: z.number().int().describe('Channel ID to remove'),
+    }),
+    execute: async ({ newRelicApiKey, policyId, channelId }) => restV2(newRelicApiKey, 'DELETE', '/alerts_policy_channels.json', { query: { policy_id: policyId, channel_id: channelId } }, 'remove channel from policy'),
+});
+//# sourceMappingURL=alert-policies.js.map

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

@@ -0,0 +1,129 @@
+import { accountIdField } from './client.js';
+export declare const getApplications: import("ai").Tool<{
+    host?: string | undefined;
+    name?: string | undefined;
+    page?: number | undefined;
+    newRelicApiKey?: string | undefined;
+    ids?: string | undefined;
+}, any>;
+export declare const getAppMetricsNames: import("ai").Tool<{
+    applicationId: number;
+    name?: string | undefined;
+    page?: number | undefined;
+    newRelicApiKey?: string | undefined;
+    cursor?: string | undefined;
+}, any>;
+export declare const getAppMetricData: import("ai").Tool<{
+    names: string[];
+    applicationId: number;
+    values?: string[] | undefined;
+    raw?: boolean | undefined;
+    from?: string | undefined;
+    to?: string | undefined;
+    period?: number | undefined;
+    newRelicApiKey?: string | undefined;
+    summarize?: boolean | undefined;
+}, any>;
+export declare const listDeployments: import("ai").Tool<{
+    applicationId: number;
+    page?: number | undefined;
+    newRelicApiKey?: string | undefined;
+}, any>;
+export declare const listKeyTransactions: import("ai").Tool<{
+    name?: string | undefined;
+    page?: number | undefined;
+    newRelicApiKey?: string | undefined;
+    ids?: string | undefined;
+}, any>;
+export declare const getBrowserApplications: import("ai").Tool<{
+    name?: string | undefined;
+    page?: number | undefined;
+    newRelicApiKey?: string | undefined;
+}, any>;
+export declare const listMobileApplications: import("ai").Tool<{
+    name?: string | undefined;
+    page?: number | undefined;
+    newRelicApiKey?: string | undefined;
+}, any>;
+export declare const getMobileApplication: import("ai").Tool<{
+    id: number;
+    newRelicApiKey?: string | undefined;
+}, any>;
+export declare const getMobileApplicationMetrics: import("ai").Tool<{
+    mobileApplicationId: number;
+    name?: string | undefined;
+    page?: number | undefined;
+    newRelicApiKey?: string | undefined;
+    cursor?: string | undefined;
+}, any>;
+export declare const getMobileMetricData: import("ai").Tool<{
+    names: string[];
+    mobileApplicationId: number;
+    values?: string[] | undefined;
+    raw?: boolean | undefined;
+    from?: string | undefined;
+    to?: string | undefined;
+    period?: number | undefined;
+    newRelicApiKey?: string | undefined;
+    summarize?: boolean | undefined;
+}, any>;
+export declare const createSecureCredential: import("ai").Tool<{
+    value: string;
+    key: string;
+    description?: string | undefined;
+    newRelicApiKey?: string | undefined;
+}, any>;
+export declare const getSecureCredential: import("ai").Tool<{
+    key: string;
+    newRelicApiKey?: string | undefined;
+}, any>;
+export declare const listSecureCredentials: import("ai").Tool<{
+    newRelicApiKey?: string | undefined;
+}, any>;
+export declare const updateSecureCredential: import("ai").Tool<{
+    value: string;
+    key: string;
+    description?: string | undefined;
+    newRelicApiKey?: string | undefined;
+}, any>;
+export declare const deleteSecureCredential: import("ai").Tool<{
+    key: string;
+    newRelicApiKey?: string | undefined;
+}, any>;
+export declare const createLookupTable: import("ai").Tool<{
+    accountId: string;
+    table: {
+        headers: string[];
+        rows: string[][];
+    };
+    tableName: string;
+    description?: string | undefined;
+    newRelicApiKey?: string | undefined;
+}, any>;
+export declare const getLookupTable: import("ai").Tool<{
+    accountId: string;
+    tableName: string;
+    newRelicApiKey?: string | undefined;
+    includeTable?: boolean | undefined;
+}, any>;
+export declare const listLookupTables: import("ai").Tool<{
+    accountId: string;
+    newRelicApiKey?: string | undefined;
+}, any>;
+export declare const updateLookupTable: import("ai").Tool<{
+    accountId: string;
+    table: {
+        headers: string[];
+        rows: string[][];
+    };
+    tableName: string;
+    description?: string | undefined;
+    newRelicApiKey?: string | undefined;
+}, any>;
+export declare const deleteLookupTable: import("ai").Tool<{
+    accountId: string;
+    tableName: string;
+    newRelicApiKey?: string | undefined;
+}, any>;
+export { accountIdField };
+//# sourceMappingURL=apm.d.ts.map

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

@@ -0,0 +1,228 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { accountIdField, lookupsApi, newRelicApiKeyField, restV2, synthApi } from './client.js';
+// ---- APM applications ----
+export const getApplications = tool({
+    description: 'Lists APM applications with health, Apdex, and throughput. Filter by name, host, or IDs.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        name: z.string().optional().describe('Case-insensitive partial name match'),
+        host: z.string().optional().describe('Case-insensitive partial host match'),
+        ids: z.string().optional().describe("Comma-separated IDs, e.g. '123,456'"),
+        page: z.number().int().min(1).optional().describe('Page number (1-indexed)'),
+    }),
+    execute: async ({ newRelicApiKey, name, host, ids, page }) => restV2(newRelicApiKey, 'GET', '/applications.json', { query: { 'filter[name]': name, 'filter[host]': host, 'filter[ids]': ids, page } }, 'list applications'),
+});
+export const getAppMetricsNames = tool({
+    description: 'Lists available metric names for an app. Run before getAppMetricData to discover queryable metrics.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        applicationId: z.number().int().describe('Application ID'),
+        name: z.string().optional().describe('Partial metric-name filter'),
+        cursor: z.string().optional().describe('Pagination cursor (preferred over page)'),
+        page: z.number().int().min(1).optional().describe('Page number (deprecated, use cursor)'),
+    }),
+    execute: async ({ newRelicApiKey, applicationId, name, cursor, page }) => restV2(newRelicApiKey, 'GET', `/applications/${applicationId}/metrics.json`, { query: { name, cursor, page } }, 'list application metric names'),
+});
+export const getAppMetricData = tool({
+    description: 'Fetches metric timeslice data (call counts, response times) for an app over a time range. Discover names via getAppMetricsNames first.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        applicationId: z.number().int().describe('Application ID'),
+        names: z.array(z.string()).min(1).describe("Metrics, e.g. ['HttpDispatcher','EndUser']"),
+        values: z.array(z.string()).optional().describe("Values, e.g. ['call_count','average_response_time'] (default all)"),
+        from: z.string().optional().describe("Range start ISO-8601, e.g. '2014-05-20T23:00:00+00:00'"),
+        to: z.string().optional().describe('Range end ISO-8601'),
+        period: z.number().int().min(1).optional().describe('Timeslice seconds'),
+        summarize: z.boolean().optional().describe('Single summary timeslice for the range'),
+        raw: z.boolean().optional().describe('Unformatted raw values'),
+    }),
+    execute: async ({ newRelicApiKey, applicationId, names, ...rest }) => {
+        const query = { ...rest };
+        query['names[]'] = names;
+        if (rest.values)
+            query['values[]'] = rest.values;
+        delete query.values;
+        return restV2(newRelicApiKey, 'GET', `/applications/${applicationId}/metrics/data.json`, { query }, 'get application metric data');
+    },
+});
+export const listDeployments = tool({
+    description: 'Lists deployment markers for an app (history for correlating releases with performance). Paginated.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        applicationId: z.number().int().describe('Application ID'),
+        page: z.number().int().min(1).optional().describe('Page number (1-indexed)'),
+    }),
+    execute: async ({ newRelicApiKey, applicationId, page }) => restV2(newRelicApiKey, 'GET', `/applications/${applicationId}/deployments.json`, { query: { page } }, 'list deployments'),
+});
+export const listKeyTransactions = tool({
+    description: 'Lists key transactions (critical paths) with Apdex and performance summaries. Filter by name or IDs.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        name: z.string().optional().describe('Partial name match'),
+        ids: z.string().optional().describe("Comma-separated IDs, e.g. '123,456'"),
+        page: z.number().int().min(1).optional(),
+    }),
+    execute: async ({ newRelicApiKey, name, ids, page }) => restV2(newRelicApiKey, 'GET', '/key_transactions.json', { query: { 'filter[name]': name, 'filter[ids]': ids, page } }, 'list key transactions'),
+});
+// ---- Browser / mobile ----
+export const getBrowserApplications = tool({
+    description: 'Lists browser applications with reporting status. Filter by name.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        name: z.string().optional().describe('Partial name match'),
+        page: z.number().int().min(1).optional(),
+    }),
+    execute: async ({ newRelicApiKey, name, page }) => restV2(newRelicApiKey, 'GET', '/browser_applications.json', { query: { 'filter[name]': name, page } }, 'list browser applications'),
+});
+export const listMobileApplications = tool({
+    description: 'Lists mobile applications with crash and performance summaries. Filter by name.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        name: z.string().optional().describe('Partial name match'),
+        page: z.number().int().min(1).optional(),
+    }),
+    execute: async ({ newRelicApiKey, name, page }) => restV2(newRelicApiKey, 'GET', '/mobile_applications.json', { query: { 'filter[name]': name, page } }, 'list mobile applications'),
+});
+export const getMobileApplication = tool({
+    description: 'Reads one mobile app (crash count/rate, active users, throughput, health).',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        id: z.number().int().describe('Mobile application ID'),
+    }),
+    execute: async ({ newRelicApiKey, id }) => restV2(newRelicApiKey, 'GET', `/mobile_applications/${id}.json`, undefined, 'get mobile application'),
+});
+export const getMobileApplicationMetrics = tool({
+    description: 'Lists available metric names for a mobile app. Run before getMobileMetricData.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        mobileApplicationId: z.number().int().describe('Mobile application ID'),
+        name: z.string().optional().describe('Partial metric-name filter'),
+        cursor: z.string().optional().describe('Pagination cursor'),
+        page: z.number().int().min(1).optional().describe('Page (deprecated, use cursor)'),
+    }),
+    execute: async ({ newRelicApiKey, mobileApplicationId, name, cursor, page }) => restV2(newRelicApiKey, 'GET', `/mobile_applications/${mobileApplicationId}/metrics.json`, { query: { name, cursor, page } }, 'list mobile application metrics'),
+});
+export const getMobileMetricData = tool({
+    description: "Fetches mobile metric timeslices (e.g. 'Mobile/Crash/All' crash count/rate). Use summarize for range totals.",
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        mobileApplicationId: z.number().int().describe('Mobile application ID'),
+        names: z.array(z.string()).min(1).describe("Metrics, e.g. ['Mobile/Crash/All']"),
+        values: z.array(z.string()).optional().describe("Values, e.g. ['call_count'] (default all)"),
+        from: z.string().optional().describe('Range start ISO-8601'),
+        to: z.string().optional().describe('Range end ISO-8601'),
+        period: z.number().int().min(1).optional().describe('Timeslice seconds'),
+        summarize: z.boolean().optional().describe('Single aggregate for the range'),
+        raw: z.boolean().optional(),
+    }),
+    execute: async ({ newRelicApiKey, mobileApplicationId, names, ...rest }) => {
+        const query = { ...rest };
+        query['names[]'] = names;
+        if (rest.values)
+            query['values[]'] = rest.values;
+        delete query.values;
+        return restV2(newRelicApiKey, 'GET', `/mobile_applications/${mobileApplicationId}/metrics/data.json`, { query }, 'get mobile metric data');
+    },
+});
+// ---- Secure credentials (Synthetics REST v3; values never returned) ----
+const credentialKey = z.string().min(1).max(64).describe('UPPERCASE key (letters, numbers, underscores)');
+export const createSecureCredential = tool({
+    description: 'Stores an encrypted credential via REST v3 for monitor scripts (API keys, passwords, tokens).',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        key: credentialKey,
+        value: z.string().min(1).max(3000).describe('Secret value (1-3000 chars, encrypted)'),
+        description: z.string().optional(),
+    }),
+    execute: async ({ newRelicApiKey, key, value, description }) => synthApi(newRelicApiKey, 'POST', '/secure_credentials', { body: { key, value, description } }, 'create secure credential'),
+});
+export const getSecureCredential = tool({
+    description: 'Reads credential metadata (key, timestamps). The secret value is never returned.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        key: credentialKey.describe('Key name to look up'),
+    }),
+    execute: async ({ newRelicApiKey, key }) => synthApi(newRelicApiKey, 'GET', `/secure_credentials/${encodeURIComponent(key)}`, undefined, 'get secure credential'),
+});
+export const listSecureCredentials = tool({
+    description: 'Lists all secure-credential metadata for auditing. Values are never returned.',
+    inputSchema: z.object({ newRelicApiKey: newRelicApiKeyField }),
+    execute: async ({ newRelicApiKey }) => synthApi(newRelicApiKey, 'GET', '/secure_credentials', undefined, 'list secure credentials'),
+});
+export const updateSecureCredential = tool({
+    description: 'Rotates a credential value and/or description. The key must already exist.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        key: credentialKey.describe('Existing key name'),
+        value: z.string().min(1).max(3000).describe('New secret value'),
+        description: z.string().optional(),
+    }),
+    execute: async ({ newRelicApiKey, key, value, description }) => synthApi(newRelicApiKey, 'PUT', `/secure_credentials/${encodeURIComponent(key)}`, { body: { value, description } }, 'update secure credential'),
+});
+export const deleteSecureCredential = tool({
+    description: 'Deletes a stored credential that is no longer needed or must be replaced.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        key: credentialKey.describe('Key name to delete'),
+    }),
+    execute: async ({ newRelicApiKey, key }) => synthApi(newRelicApiKey, 'DELETE', `/secure_credentials/${encodeURIComponent(key)}`, undefined, 'delete secure credential'),
+});
+// ---- Lookup tables (NRQL Lookups API) ----
+const tableInput = z.object({
+    headers: z.array(z.string()).describe("Column names, e.g. ['id','name','value']"),
+    rows: z.array(z.array(z.string())).describe('Data rows matching the headers'),
+}).describe('Table structure and data (replaces existing content on update)');
+const accountIdString = z.string().describe('Account ID owning the table');
+export const createLookupTable = tool({
+    description: 'Uploads a lookup table enriching telemetry in NRQL joins (user mappings, catalogs). Name must be unique in the account.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        accountId: accountIdString,
+        tableName: z.string().describe('Table name (lowercase + underscores recommended)'),
+        table: tableInput,
+        description: z.string().optional(),
+    }),
+    execute: async ({ newRelicApiKey, accountId, tableName, table, description }) => lookupsApi(newRelicApiKey, 'POST', `/accounts/${accountId}/${encodeURIComponent(tableName)}`, { body: { description, table } }, 'create lookup table'),
+});
+export const getLookupTable = tool({
+    description: 'Downloads a lookup table (metadata plus optional contents).',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        accountId: accountIdString,
+        tableName: z.string().describe('Table name to download'),
+        includeTable: z.boolean().optional().describe('Include table data (default false)'),
+    }),
+    execute: async ({ newRelicApiKey, accountId, tableName, includeTable }) => lookupsApi(newRelicApiKey, 'GET', `/accounts/${accountId}/${encodeURIComponent(tableName)}`, { query: { includeTable } }, 'get lookup table'),
+});
+export const listLookupTables = tool({
+    description: 'Lists lookup-table summaries (names, GUIDs, sizes, update info) for an account.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        accountId: accountIdString,
+    }),
+    execute: async ({ newRelicApiKey, accountId }) => lookupsApi(newRelicApiKey, 'GET', `/accounts/${accountId}`, undefined, 'list lookup tables'),
+});
+export const updateLookupTable = tool({
+    description: 'Fully replaces a lookup table (structure + data). The table must already exist.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        accountId: accountIdString,
+        tableName: z.string().describe('Existing table name to replace'),
+        table: tableInput,
+        description: z.string().optional(),
+    }),
+    execute: async ({ newRelicApiKey, accountId, tableName, table, description }) => lookupsApi(newRelicApiKey, 'PUT', `/accounts/${accountId}/${encodeURIComponent(tableName)}`, { body: { description, table } }, 'update lookup table'),
+});
+export const deleteLookupTable = tool({
+    description: 'Deletes a lookup table. Deleted tables are not recoverable.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        accountId: accountIdString,
+        tableName: z.string().describe('Table name to delete'),
+    }),
+    execute: async ({ newRelicApiKey, accountId, tableName }) => lookupsApi(newRelicApiKey, 'DELETE', `/accounts/${accountId}/${encodeURIComponent(tableName)}`, undefined, 'delete lookup table'),
+});
+export { accountIdField };
+//# sourceMappingURL=apm.js.map

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

@@ -0,0 +1,62 @@
+import { z } from 'zod';
+export declare const NERDGRAPH_URL = "https://api.newrelic.com/graphql";
+export declare const REST_V2_BASE = "https://api.newrelic.com/v2";
+export declare const INFRA_API_BASE = "https://infra-api.newrelic.com/v2";
+export declare const SYNTHETICS_API_BASE = "https://synthetics.newrelic.com/synthetics/api/v3";
+export declare const LOOKUPS_API_BASE = "https://nrql-lookup.service.newrelic.com/v1";
+export declare const EVENTS_API_BASE = "https://insights-collector.newrelic.com/v1";
+export declare const TRACE_API_BASE = "https://trace-api.newrelic.com/trace/v1";
+export declare const newRelicApiKeyField: z.ZodOptional<z.ZodString>;
+export declare function missingKey(): {
+    error: string;
+};
+export interface NrRequestOptions {
+    method?: string;
+    query?: Record<string, string | number | boolean | undefined>;
+    body?: unknown;
+    headers?: Record<string, string>;
+}
+export declare function nrFetch(url: string, apiKey: string | undefined, options?: NrRequestOptions): Promise<{
+    ok: false;
+    error: any;
+    data?: undefined;
+} | {
+    ok: true;
+    data: any;
+    error?: undefined;
+}>;
+/** NerdGraph GraphQL request. Returns raw { data, errors } on success. */
+export declare function nerdgraph(apiKey: string | undefined, query: string, variables?: Record<string, unknown>, action?: string): Promise<any>;
+/** REST API v2 request (api.newrelic.com/v2). */
+export declare function restV2(apiKey: string | undefined, method: string, path: string, options?: {
+    query?: Record<string, string | number | boolean | undefined>;
+    body?: unknown;
+}, action?: string): Promise<any>;
+/** Infrastructure alerts API (infra-api.newrelic.com/v2). Bodies are wrapped in { data }. */
+export declare function infraApi(apiKey: string | undefined, method: string, path: string, options?: {
+    query?: Record<string, string | number | boolean | undefined>;
+    data?: unknown;
+}, action?: string): Promise<any>;
+/** Synthetics REST API v3 (uses X-Api-Key with a User/Admin key). */
+export declare function synthApi(apiKey: string | undefined, method: string, path: string, options?: {
+    query?: Record<string, string | number | boolean | undefined>;
+    body?: unknown;
+}, action?: string): Promise<any>;
+/** NRQL Lookups API (lookup tables). */
+export declare function lookupsApi(apiKey: string | undefined, method: string, path: string, options?: {
+    query?: Record<string, string | number | boolean | undefined>;
+    body?: unknown;
+}, action?: string): Promise<any>;
+export declare const accountIdField: (desc?: string) => z.ZodNumber;
+export declare const tagInput: z.ZodObject<{
+    key: z.ZodString;
+    values: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    values: string[];
+    key: string;
+}, {
+    values: string[];
+    key: string;
+}>;
+export declare const RULE_RESULT_FIELDS = "errors { message type } rule { id action enabled evalOrder matchExpression notes replacement terminateChain applicationGuid applicationName createdAt }";
+//# sourceMappingURL=client.d.ts.map