@rnsk/toolkits 0.0.10 → 0.0.12

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

@@ -0,0 +1,106 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { ddApi, toDatadogError } from './client.js';
+const credsField = z.string().describe('Datadog credentials JSON with apiKey and appKey (injected by system)');
+export const datadogListApmServices = tool({
+    description: 'List APM services for an environment with performance stats. Use env "*" for all environments. Requires APM instrumentation.',
+    inputSchema: z.object({
+        datadogCredentials: credsField,
+        env: z.string().optional().default('*').describe("Environment, e.g. 'production' ('*' for all)"),
+    }),
+    execute: async ({ datadogCredentials, env = '*' }) => {
+        try {
+            const data = await ddApi(datadogCredentials, 'GET', '/api/v2/apm/services', {
+                query: { 'filter[env]': env },
+            });
+            const services = data?.data ?? [];
+            return { services, total_count: services.length };
+        }
+        catch (error) {
+            return toDatadogError(error, 'Failed to list APM services');
+        }
+    },
+});
+export const datadogSearchTraces = tool({
+    description: 'Search distributed traces for incident investigation and bottleneck analysis. Bound the window, include env and service, and prefix custom attributes with @. Paginate with page.cursor.',
+    inputSchema: z.object({
+        datadogCredentials: credsField,
+        filter: z
+            .object({
+            query: z.string().optional().describe("Trace query, e.g. 'service:api @http.status_code:>=400'"),
+            from_time: z.string().describe("Range start: ISO, 'now-1h', etc."),
+            to_time: z.string().describe("Range end: ISO or 'now'"),
+        })
+            .describe('Time-bounded filter (from_time and to_time required)'),
+        sort: z
+            .object({
+            field: z.string().optional().describe("Sort field: 'timestamp' (default), '@duration', '@http.status_code'"),
+            order: z.string().optional().describe("'asc' or 'desc' (default)"),
+        })
+            .optional()
+            .describe('Sort configuration'),
+        page: z.record(z.any()).optional().describe('Pagination, e.g. {limit: 25, cursor: "..."}'),
+        options: z.record(z.any()).optional().describe('Extra options, e.g. {timezone: "UTC"}'),
+    }),
+    execute: async ({ datadogCredentials, filter, sort, page, options }) => {
+        try {
+            const data = await ddApi(datadogCredentials, 'POST', '/api/v2/spans/events/search', {
+                body: {
+                    data: {
+                        type: 'search_request',
+                        attributes: { filter, sort, page, options },
+                    },
+                },
+            });
+            return {
+                data: data?.data ?? [],
+                meta: data?.meta,
+                links: data?.links,
+                total_count: data?.meta?.page?.total_count,
+            };
+        }
+        catch (error) {
+            return toDatadogError(error, 'Failed to search traces');
+        }
+    },
+});
+export const datadogSearchSpansAnalytics = tool({
+    description: 'Aggregate span data (error rates, latency patterns) grouped by facets. The body must be a valid aggregate_request — when filter/compute cannot satisfy the schema, use datadogSearchTraces instead.',
+    inputSchema: z.object({
+        datadogCredentials: credsField,
+        filter: z
+            .object({
+            query: z.string().optional().describe("Span query, e.g. 'env:production error.type:*'"),
+            from_time: z.string().optional().describe("Range start: ISO or relative"),
+            to_time: z.string().optional().describe("Range end: ISO or relative"),
+            indexes: z.array(z.string()).optional().describe('Indexes to search'),
+        })
+            .describe('Span filter'),
+        compute: z
+            .array(z.record(z.any()))
+            .optional()
+            .describe("Aggregations with metric+type; percentile needs the percentile field (0.5/0.75/0.9/0.95/0.98/0.99)"),
+        group_by: z
+            .array(z.record(z.any()))
+            .optional()
+            .describe("Group-bys with facet, e.g. [{facet:'service',limit:10}]"),
+        options: z.record(z.any()).optional().describe('Extra options, e.g. {timezone: "UTC"}'),
+    }),
+    execute: async ({ datadogCredentials, filter, compute, group_by, options }) => {
+        try {
+            return await ddApi(datadogCredentials, 'POST', '/api/v2/spans/analytics/aggregate', {
+                body: {
+                    data: {
+                        type: 'aggregate_request',
+                        attributes: { filter, compute, group_by, options },
+                    },
+                },
+            });
+        }
+        catch (error) {
+            return toDatadogError(error, 'Failed to search spans analytics');
+        }
+    },
+});
+//# sourceMappingURL=apm.js.map

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

@@ -0,0 +1,19 @@
+export interface DatadogCredentials {
+    apiKey: string;
+    appKey: string;
+    site: string;
+}
+/** datadogCredentials is the JSON blob injected by the framework under the manifest's tokenField. */
+export declare function parseDatadogCredentials(datadogCredentials: string): DatadogCredentials;
+export declare function ddApi(datadogCredentials: string, method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE', path: string, options?: {
+    query?: Record<string, string | number | boolean | undefined>;
+    body?: unknown;
+}): Promise<any>;
+export declare function toDatadogError(error: unknown, label: string): {
+    error: string;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+};
+//# sourceMappingURL=client.d.ts.map

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

@@ -0,0 +1,81 @@
+const SITE_HOSTS = {
+    us1: 'api.datadoghq.com',
+    us3: 'api.us3.datadoghq.com',
+    us5: 'api.us5.datadoghq.com',
+    eu: 'api.datadoghq.eu',
+    ap1: 'api.ap1.datadoghq.com',
+    ap2: 'api.ap2.datadoghq.com',
+    gov: 'api.ddog-gov.com',
+    us2gov: 'api.us2.ddog-gov.com',
+    uk1: 'api.uk1.datadoghq.com',
+};
+/** datadogCredentials is the JSON blob injected by the framework under the manifest's tokenField. */
+export function parseDatadogCredentials(datadogCredentials) {
+    let parsed;
+    try {
+        parsed = JSON.parse(datadogCredentials);
+    }
+    catch {
+        throw new Error('Datadog credentials must be a JSON object with apiKey and appKey');
+    }
+    if (!parsed?.apiKey || !parsed?.appKey) {
+        throw new Error('Datadog credentials must include apiKey and appKey');
+    }
+    let site = String(parsed.site || 'api.datadoghq.com')
+        .replace(/^https?:\/\//, '')
+        .replace(/\/$/, '');
+    const alias = SITE_HOSTS[site.toLowerCase()];
+    if (alias)
+        site = alias;
+    return { apiKey: parsed.apiKey, appKey: parsed.appKey, site };
+}
+function appendQuery(url, query) {
+    if (!query)
+        return;
+    for (const [key, value] of Object.entries(query)) {
+        if (value === undefined)
+            continue;
+        url.searchParams.set(key, String(value));
+    }
+}
+async function parseBody(response) {
+    const text = await response.text();
+    if (!text)
+        return {};
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return { raw: text };
+    }
+}
+export async function ddApi(datadogCredentials, method, path, options) {
+    const creds = parseDatadogCredentials(datadogCredentials);
+    const url = new URL(`https://${creds.site}${path}`);
+    appendQuery(url, options?.query);
+    const response = await fetch(url.toString(), {
+        method,
+        headers: {
+            'DD-API-KEY': creds.apiKey,
+            'DD-APPLICATION-KEY': creds.appKey,
+            'Content-Type': 'application/json',
+        },
+        body: options?.body !== undefined ? JSON.stringify(options.body) : undefined,
+    });
+    const data = await parseBody(response);
+    if (!response.ok) {
+        const message = data?.errors?.join?.('; ') ?? data?.message ?? data?.error ?? '';
+        throw new Error(`Datadog API request failed (HTTP ${response.status})${message ? `: ${message}` : ''}`);
+    }
+    return data;
+}
+export function toDatadogError(error, label) {
+    if (error instanceof Error && /Datadog credentials/.test(error.message)) {
+        return { error: 'Datadog credentials are missing or invalid. Connect Datadog first.' };
+    }
+    return {
+        error: label.replace('Failed', 'Error').replace('failed', 'error'),
+        message: error instanceof Error ? error.message : 'Unknown error',
+    };
+}
+//# sourceMappingURL=client.js.map

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

@@ -0,0 +1,93 @@
+export declare const datadogCreateDashboard: import("ai").Tool<{
+    title: string;
+    widgets: {
+        definition: Record<string, any>;
+        id?: number | undefined;
+        layout?: Record<string, any> | undefined;
+    }[];
+    datadogCredentials: string;
+    description?: string | undefined;
+    tags?: string[] | undefined;
+    layout_type?: "ordered" | "free" | undefined;
+    notify_list?: string[] | undefined;
+    template_variables?: {
+        name: string;
+        default?: string | undefined;
+        prefix?: string | undefined;
+        available_values?: string[] | undefined;
+    }[] | undefined;
+}, {
+    error: string;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+} | {
+    success: boolean;
+}>;
+export declare const datadogGetDashboard: import("ai").Tool<{
+    datadogCredentials: string;
+    dashboard_id: string;
+}, any>;
+export declare const datadogUpdateDashboard: import("ai").Tool<{
+    datadogCredentials: string;
+    dashboard_id: string;
+    description?: string | undefined;
+    title?: string | undefined;
+    tags?: string[] | undefined;
+    widgets?: {
+        definition: Record<string, any>;
+        id?: number | undefined;
+        layout?: Record<string, any> | undefined;
+    }[] | undefined;
+    layout_type?: string | undefined;
+    notify_list?: string[] | undefined;
+    template_variables?: {
+        name: string;
+        default?: string | undefined;
+        prefix?: string | undefined;
+        available_values?: string[] | undefined;
+    }[] | undefined;
+    reflow_type?: string | undefined;
+    is_read_only?: boolean | undefined;
+    pause_auto_refresh?: boolean | undefined;
+}, {
+    error: string;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+} | {
+    success: boolean;
+}>;
+export declare const datadogDeleteDashboard: import("ai").Tool<{
+    datadogCredentials: string;
+    dashboard_id: string;
+}, {
+    error: string;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+} | {
+    deleted_dashboard_id: any;
+    message: string;
+    success: boolean;
+}>;
+export declare const datadogListDashboards: import("ai").Tool<{
+    datadogCredentials: string;
+    count?: number | undefined;
+    start?: number | undefined;
+    filter_shared?: boolean | undefined;
+    filter_deleted?: boolean | undefined;
+}, {
+    error: string;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+} | {
+    dashboards: any;
+    total_count: any;
+}>;
+//# sourceMappingURL=dashboards.d.ts.map

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

@@ -0,0 +1,127 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { ddApi, toDatadogError } from './client.js';
+const credsField = z.string().describe('Datadog credentials JSON with apiKey and appKey (injected by system)');
+const widgetSchema = z.object({
+    definition: z.record(z.any()).describe('Widget definition with type, requests, styling'),
+    id: z.number().optional().describe('Widget ID (auto-generated when omitted)'),
+    layout: z.record(z.any()).optional().describe('Layout (x, y, width, height for free layouts)'),
+});
+const templateVariableSchema = z.object({
+    name: z.string().describe('Variable name'),
+    prefix: z.string().optional().describe('Variable prefix'),
+    default: z.string().optional().describe('Default value'),
+    available_values: z.array(z.string()).optional().describe('Allowed values'),
+});
+export const datadogCreateDashboard = tool({
+    description: 'Create a dashboard with widgets for unified monitoring views. For log/APM/RUM widget queries keep group_by inside the query object, not at request level.',
+    inputSchema: z.object({
+        datadogCredentials: credsField,
+        title: z.string().min(1).max(80).describe('Dashboard title'),
+        widgets: z.array(widgetSchema).min(1).describe('Widgets to include'),
+        description: z.string().max(500).optional().describe('Dashboard description'),
+        layout_type: z.enum(['ordered', 'free']).optional().describe('Layout (default ordered)'),
+        tags: z.array(z.string()).optional().describe('Dashboard tags'),
+        notify_list: z.array(z.string()).optional().describe('Users to notify of changes'),
+        template_variables: z.array(templateVariableSchema).optional().describe('Template variables'),
+    }),
+    execute: async ({ datadogCredentials, ...body }) => {
+        try {
+            const data = await ddApi(datadogCredentials, 'POST', '/api/v1/dashboard', { body });
+            return { ...data, success: true };
+        }
+        catch (error) {
+            return toDatadogError(error, 'Failed to create dashboard');
+        }
+    },
+});
+export const datadogGetDashboard = tool({
+    description: 'Get a dashboard by ID with widgets, layout, and template variables. Keep reflow_type and pause_auto_refresh from the response for round-trip updates.',
+    inputSchema: z.object({
+        datadogCredentials: credsField,
+        dashboard_id: z.string().describe('Dashboard ID'),
+    }),
+    execute: async ({ datadogCredentials, dashboard_id }) => {
+        try {
+            return await ddApi(datadogCredentials, 'GET', `/api/v1/dashboard/${dashboard_id}`);
+        }
+        catch (error) {
+            return toDatadogError(error, 'Failed to get dashboard');
+        }
+    },
+});
+export const datadogUpdateDashboard = tool({
+    description: 'Update a dashboard; only provided fields change. Omit reflow_type and pause_auto_refresh to preserve existing values.',
+    inputSchema: z.object({
+        datadogCredentials: credsField,
+        dashboard_id: z.string().describe('Dashboard ID to update'),
+        title: z.string().min(1).max(80).optional().describe('Dashboard title'),
+        widgets: z.array(widgetSchema).optional().describe('Replacement widgets'),
+        description: z.string().max(500).optional().describe('Dashboard description'),
+        layout_type: z.string().optional().describe("Layout: 'ordered' or 'free'"),
+        tags: z.array(z.string()).optional().describe('Replacement tags'),
+        notify_list: z.array(z.string()).optional().describe('Replacement notify list'),
+        template_variables: z.array(templateVariableSchema).optional().describe('Replacement variables'),
+        reflow_type: z.string().optional().describe("Reflow for ordered layouts: 'auto' or 'fixed'"),
+        is_read_only: z.boolean().optional().describe('Read-only flag'),
+        pause_auto_refresh: z.boolean().optional().describe('Pause automatic refresh'),
+    }),
+    execute: async ({ datadogCredentials, dashboard_id, ...body }) => {
+        try {
+            const data = await ddApi(datadogCredentials, 'PUT', `/api/v1/dashboard/${dashboard_id}`, { body });
+            return { ...data, success: true };
+        }
+        catch (error) {
+            return toDatadogError(error, 'Failed to update dashboard');
+        }
+    },
+});
+export const datadogDeleteDashboard = tool({
+    description: 'Permanently delete a dashboard. Irreversible — confirm with the user first.',
+    inputSchema: z.object({
+        datadogCredentials: credsField,
+        dashboard_id: z.string().describe('Dashboard ID to delete'),
+    }),
+    execute: async ({ datadogCredentials, dashboard_id }) => {
+        try {
+            const data = await ddApi(datadogCredentials, 'DELETE', `/api/v1/dashboard/${dashboard_id}`);
+            return {
+                deleted_dashboard_id: data?.deleted_dashboard_id ?? dashboard_id,
+                message: 'Dashboard deleted',
+                success: true,
+            };
+        }
+        catch (error) {
+            return toDatadogError(error, 'Failed to delete dashboard');
+        }
+    },
+});
+export const datadogListDashboards = tool({
+    description: 'List dashboards with shared/deleted filters and start/count pagination.',
+    inputSchema: z.object({
+        datadogCredentials: credsField,
+        filter_shared: z.boolean().optional().describe('Filter by shared status'),
+        filter_deleted: z.boolean().optional().describe('Include deleted dashboards'),
+        count: z.number().optional().describe('Max dashboards to return'),
+        start: z.number().optional().describe('Offset: skip this many dashboards'),
+    }),
+    execute: async ({ datadogCredentials, filter_shared, filter_deleted, count, start }) => {
+        try {
+            const data = await ddApi(datadogCredentials, 'GET', '/api/v1/dashboard', {
+                query: {
+                    'filter[shared]': filter_shared,
+                    'filter[deleted]': filter_deleted,
+                    count,
+                    start,
+                },
+            });
+            const dashboards = data?.dashboards ?? (Array.isArray(data) ? data : []);
+            return { dashboards, total_count: dashboards.length };
+        }
+        catch (error) {
+            return toDatadogError(error, 'Failed to list dashboards');
+        }
+    },
+});
+//# sourceMappingURL=dashboards.js.map

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

@@ -0,0 +1,35 @@
+export declare const datadogCreateEvent: import("ai").Tool<{
+    title: string;
+    text: string;
+    datadogCredentials: string;
+    priority?: "low" | "normal" | undefined;
+    host?: string | undefined;
+    tags?: string[] | undefined;
+    device_name?: string | undefined;
+    alert_type?: "error" | "success" | "warning" | "info" | undefined;
+    source_type_name?: string | undefined;
+    aggregation_key?: string | undefined;
+    date_happened?: number | undefined;
+}, any>;
+export declare const datadogListEvents: import("ai").Tool<{
+    start: number;
+    end: number;
+    datadogCredentials: string;
+    priority?: "low" | "normal" | undefined;
+    sources?: string | undefined;
+    page?: number | undefined;
+    tags?: string[] | undefined;
+    unaggregated?: boolean | undefined;
+    exclude_aggregate?: boolean | undefined;
+}, {
+    error: string;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+} | {
+    events: any;
+    total_count: any;
+    status: any;
+}>;
+//# sourceMappingURL=events.d.ts.map

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

@@ -0,0 +1,56 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { ddApi, toDatadogError } from './client.js';
+const credsField = z.string().describe('Datadog credentials JSON with apiKey and appKey (injected by system)');
+export const datadogCreateEvent = tool({
+    description: 'Post an event for deployments, outages, or config changes. Markdown is supported in text.',
+    inputSchema: z.object({
+        datadogCredentials: credsField,
+        title: z.string().max(100).describe('Event title'),
+        text: z.string().describe('Event body (markdown supported)'),
+        host: z.string().optional().describe('Associated host'),
+        device_name: z.string().optional().describe('Associated device'),
+        tags: z.array(z.string()).optional().describe('Event tags'),
+        priority: z.enum(['normal', 'low']).optional().describe('Priority'),
+        alert_type: z.enum(['error', 'warning', 'info', 'success']).optional().describe('Alert type'),
+        source_type_name: z.string().optional().describe("Source, e.g. 'jenkins', 'docker'"),
+        aggregation_key: z.string().optional().describe('Key for grouping events'),
+        date_happened: z.number().optional().describe('Seconds epoch (defaults to now)'),
+    }),
+    execute: async ({ datadogCredentials, ...body }) => {
+        try {
+            return await ddApi(datadogCredentials, 'POST', '/api/v1/events', { body });
+        }
+        catch (error) {
+            return toDatadogError(error, 'Failed to create event');
+        }
+    },
+});
+export const datadogListEvents = tool({
+    description: 'List events in a seconds-epoch window. Start broad (few filters, narrow range) and narrow incrementally — combined filters on wide ranges can return empty or huge results.',
+    inputSchema: z.object({
+        datadogCredentials: credsField,
+        start: z.number().describe('Range start as seconds epoch'),
+        end: z.number().describe('Range end as seconds epoch'),
+        tags: z.array(z.string()).optional().describe('Tag filters'),
+        sources: z.string().optional().describe('Comma-separated sources, e.g. jenkins,docker'),
+        priority: z.enum(['normal', 'low']).optional().describe('Priority filter'),
+        page: z.number().optional().describe('Page number'),
+        unaggregated: z.boolean().optional().describe('Return unaggregated events'),
+        exclude_aggregate: z.boolean().optional().describe('Exclude aggregated events'),
+    }),
+    execute: async ({ datadogCredentials, tags, ...rest }) => {
+        try {
+            const data = await ddApi(datadogCredentials, 'GET', '/api/v1/events', {
+                query: { ...rest, tags: tags?.join(',') },
+            });
+            const events = data?.events ?? (Array.isArray(data) ? data : []);
+            return { events, total_count: events.length, status: data?.status };
+        }
+        catch (error) {
+            return toDatadogError(error, 'Failed to list events');
+        }
+    },
+});
+//# sourceMappingURL=events.js.map

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

@@ -0,0 +1,49 @@
+export declare const datadogListHosts: import("ai").Tool<{
+    datadogCredentials: string;
+    filter?: string | undefined;
+    count?: number | undefined;
+    start?: number | undefined;
+    from_timestamp?: number | undefined;
+    sort_field?: "status" | "name" | "cpu" | "iowait" | "load" | undefined;
+    sort_dir?: "asc" | "desc" | undefined;
+    include_hosts_metadata?: boolean | undefined;
+    include_muted_hosts_data?: boolean | undefined;
+}, any>;
+export declare const datadogGetHostTags: import("ai").Tool<{
+    datadogCredentials: string;
+    host_name: string;
+    source?: string | undefined;
+}, any>;
+export declare const datadogListAllTags: import("ai").Tool<{
+    datadogCredentials: string;
+    source?: string | undefined;
+}, {
+    error: string;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+} | {
+    tags: {
+        name: string;
+        count: number;
+    }[];
+    total_count: number;
+}>;
+export declare const datadogUpdateHostTags: import("ai").Tool<{
+    tags: string[];
+    datadogCredentials: string;
+    host_name: string;
+    source?: string | undefined;
+}, {
+    error: string;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+} | {
+    host: string;
+    tags: any;
+    source: string | undefined;
+}>;
+//# sourceMappingURL=hosts.d.ts.map

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

@@ -0,0 +1,87 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { ddApi, toDatadogError } from './client.js';
+const credsField = z.string().describe('Datadog credentials JSON with apiKey and appKey (injected by system)');
+export const datadogListHosts = tool({
+    description: 'List infrastructure hosts with metrics, tags, and status. Filter by tag query and sort by status, name, cpu, iowait, or load.',
+    inputSchema: z.object({
+        datadogCredentials: credsField,
+        filter: z.string().optional().describe("Tag filter, e.g. 'env:production'"),
+        sort_field: z.enum(['status', 'name', 'cpu', 'iowait', 'load']).optional().describe('Sort field'),
+        sort_dir: z.enum(['asc', 'desc']).optional().describe('Sort direction'),
+        start: z.number().optional().describe('Pagination offset'),
+        count: z.number().max(1000).optional().describe('Hosts to return (max 1000)'),
+        from_timestamp: z.number().optional().describe('Activity window start as seconds epoch'),
+        include_hosts_metadata: z.boolean().optional().describe('Include host metadata'),
+        include_muted_hosts_data: z.boolean().optional().describe('Include muted hosts'),
+    }),
+    execute: async ({ datadogCredentials, ...query }) => {
+        try {
+            return await ddApi(datadogCredentials, 'GET', '/api/v1/hosts', { query });
+        }
+        catch (error) {
+            return toDatadogError(error, 'Failed to list hosts');
+        }
+    },
+});
+export const datadogGetHostTags = tool({
+    description: 'Get all tags for a host, optionally filtered by source (users, chef, puppet, aws, datadog).',
+    inputSchema: z.object({
+        datadogCredentials: credsField,
+        host_name: z.string().describe('Host name'),
+        source: z.string().optional().describe('Tag source to filter by'),
+    }),
+    execute: async ({ datadogCredentials, host_name, source }) => {
+        try {
+            return await ddApi(datadogCredentials, 'GET', `/api/v1/tags/hosts/${encodeURIComponent(host_name)}`, {
+                query: { source },
+            });
+        }
+        catch (error) {
+            return toDatadogError(error, 'Failed to get host tags');
+        }
+    },
+});
+export const datadogListAllTags = tool({
+    description: 'List all tags in use across the organization, optionally filtered by source. Use to discover tag keys for filters.',
+    inputSchema: z.object({
+        datadogCredentials: credsField,
+        source: z.string().optional().describe("Source filter, e.g. 'chef', 'users', 'datadog'"),
+    }),
+    execute: async ({ datadogCredentials, source }) => {
+        try {
+            const data = await ddApi(datadogCredentials, 'GET', '/api/v1/tags/hosts', {
+                query: { source },
+            });
+            const tagMap = data?.tags ?? {};
+            const tags = Object.entries(tagMap).map(([name, hosts]) => ({
+                name,
+                count: Array.isArray(hosts) ? hosts.length : 0,
+            }));
+            return { tags, total_count: tags.length };
+        }
+        catch (error) {
+            return toDatadogError(error, 'Failed to list tags');
+        }
+    },
+});
+export const datadogUpdateHostTags = tool({
+    description: 'Replace all tags from one source on a host (defaults to users source). This overwrites — include the full desired tag set.',
+    inputSchema: z.object({
+        datadogCredentials: credsField,
+        host_name: z.string().describe('Host name'),
+        tags: z.array(z.string()).describe('Complete replacement tag list'),
+        source: z.string().optional().describe("Tag source (defaults to 'users')"),
+    }),
+    execute: async ({ datadogCredentials, host_name, tags, source }) => {
+        try {
+            const data = await ddApi(datadogCredentials, 'PUT', `/api/v1/tags/hosts/${encodeURIComponent(host_name)}`, { query: { source }, body: { tags } });
+            return { host: host_name, tags: data?.tags ?? tags, source };
+        }
+        catch (error) {
+            return toDatadogError(error, 'Failed to update host tags');
+        }
+    },
+});
+//# sourceMappingURL=hosts.js.map

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

@@ -0,0 +1,18 @@
+export declare const datadogListIncidents: import("ai").Tool<{
+    page_size: number;
+    datadogCredentials: string;
+    page_offset: number;
+    sort?: "public_id" | "-public_id" | undefined;
+    include?: string | undefined;
+    filter_query?: string | undefined;
+}, {
+    error: string;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+} | {
+    incidents: any;
+    total_count: any;
+}>;
+//# sourceMappingURL=incidents.d.ts.map