@rnsk/toolkits 0.0.9 → 0.0.11

package/dist/toolkits/convex/tools/projects.js

@@ -0,0 +1,111 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { convexMgmt, toConvexError, requireToken } from './client.js';
+const tokenField = z.string().optional().describe('Injected by system; do not provide');
+const teamIdField = z.union([z.string(), z.number()]).describe('Team ID (numeric)');
+export const convexCreateProject = tool({
+    description: 'Create a project on a team, optionally provisioning a dev or prod deployment alongside it. Returns the projectId (and deployment URL/name when requested).',
+    inputSchema: z.object({
+        convexToken: tokenField,
+        teamId: teamIdField,
+        projectName: z.string().describe('Project name as shown in the dashboard'),
+        deploymentType: z.string().optional().describe("Provision a deployment: 'dev' or 'prod' (omit for none)"),
+        deploymentClass: z.string().optional().describe('Deployment class (defaults to the team default)'),
+        deploymentRegion: z.string().optional().describe('Deployment region (defaults to the team default)'),
+    }),
+    execute: async ({ convexToken, teamId, projectName, deploymentType, deploymentClass, deploymentRegion }) => {
+        try {
+            const missing = requireToken(convexToken);
+            if (missing)
+                return missing;
+            return await convexMgmt(convexToken, 'POST', `/teams/${teamId}/create_project`, {
+                body: {
+                    projectName,
+                    deploymentType,
+                    deploymentClass,
+                    deploymentRegion,
+                },
+            });
+        }
+        catch (error) {
+            return toConvexError(error, 'Failed to create project');
+        }
+    },
+});
+export const convexListProjects = tool({
+    description: 'List all projects for a team by team ID. Use to discover project IDs before deployment operations.',
+    inputSchema: z.object({
+        convexToken: tokenField,
+        teamId: teamIdField,
+    }),
+    execute: async ({ convexToken, teamId }) => {
+        try {
+            const missing = requireToken(convexToken);
+            if (missing)
+                return missing;
+            const data = await convexMgmt(convexToken, 'GET', `/teams/${teamId}/projects`);
+            return Array.isArray(data) ? { projects: data } : data;
+        }
+        catch (error) {
+            return toConvexError(error, 'Failed to list projects');
+        }
+    },
+});
+export const convexGetProjectById = tool({
+    description: 'Get project metadata (name, slug, team, creation time) by numeric project ID.',
+    inputSchema: z.object({
+        convexToken: tokenField,
+        projectId: z.number().describe('Numeric project ID'),
+    }),
+    execute: async ({ convexToken, projectId }) => {
+        try {
+            const missing = requireToken(convexToken);
+            if (missing)
+                return missing;
+            return await convexMgmt(convexToken, 'GET', `/projects/${projectId}`);
+        }
+        catch (error) {
+            return toConvexError(error, 'Failed to get project');
+        }
+    },
+});
+export const convexGetProjectBySlug = tool({
+    description: 'Get a project by its human-readable slug within a team. Accepts a numeric team ID or team slug.',
+    inputSchema: z.object({
+        convexToken: tokenField,
+        teamIdOrSlug: z.union([z.string(), z.number()]).describe('Team ID (numeric) or team slug'),
+        projectSlug: z.string().describe('Project slug within the team'),
+    }),
+    execute: async ({ convexToken, teamIdOrSlug, projectSlug }) => {
+        try {
+            const missing = requireToken(convexToken);
+            if (missing)
+                return missing;
+            return await convexMgmt(convexToken, 'GET', `/teams/${teamIdOrSlug}/projects/${projectSlug}`);
+        }
+        catch (error) {
+            return toConvexError(error, 'Failed to get project');
+        }
+    },
+});
+export const convexDeleteProject = tool({
+    description: 'Permanently delete a project and all its deployments and data. Irreversible — confirm with the user first.',
+    inputSchema: z.object({
+        convexToken: tokenField,
+        projectId: z.number().describe('Numeric project ID to delete'),
+    }),
+    execute: async ({ convexToken, projectId }) => {
+        try {
+            const missing = requireToken(convexToken);
+            if (missing)
+                return missing;
+            await convexMgmt(convexToken, 'POST', `/projects/${projectId}/delete`, { body: {} });
+            return { success: true, project_id: projectId };
+        }
+        catch (error) {
+            return toConvexError(error, 'Failed to delete project');
+        }
+    },
+});
+//# sourceMappingURL=projects.js.map

package/dist/toolkits/convex/tools/teams.d.ts

@@ -0,0 +1,12 @@
+export declare const convexGetTokenDetails: import("ai").Tool<{
+    convexToken?: string | undefined;
+}, any>;
+export declare const convexListDeploymentClasses: import("ai").Tool<{
+    teamId: string | number;
+    convexToken?: string | undefined;
+}, any>;
+export declare const convexListDeploymentRegions: import("ai").Tool<{
+    teamId: string | number;
+    convexToken?: string | undefined;
+}, any>;
+//# sourceMappingURL=teams.d.ts.map

package/dist/toolkits/convex/tools/teams.js

@@ -0,0 +1,62 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { convexMgmt, toConvexError, requireToken } from './client.js';
+const tokenField = z.string().optional().describe('Injected by system; do not provide');
+const teamIdField = z.union([z.string(), z.number()]).describe('Team ID (numeric)');
+export const convexGetTokenDetails = tool({
+    description: 'Get details for the connected token itself: type (team or project) and the team or project ID it belongs to. No parameters. Use after connecting to identify the token scope.',
+    inputSchema: z.object({
+        convexToken: tokenField,
+    }),
+    execute: async ({ convexToken }) => {
+        try {
+            const missing = requireToken(convexToken);
+            if (missing)
+                return missing;
+            return await convexMgmt(convexToken, 'GET', '/token_details');
+        }
+        catch (error) {
+            return toConvexError(error, 'Failed to get token details');
+        }
+    },
+});
+export const convexListDeploymentClasses = tool({
+    description: 'List deployment classes available to a team with availability flags. Use before creating a deployment with an explicit class.',
+    inputSchema: z.object({
+        convexToken: tokenField,
+        teamId: teamIdField,
+    }),
+    execute: async ({ convexToken, teamId }) => {
+        try {
+            const missing = requireToken(convexToken);
+            if (missing)
+                return missing;
+            const data = await convexMgmt(convexToken, 'GET', `/teams/${teamId}/list_deployment_classes`);
+            return Array.isArray(data) ? { items: data } : data;
+        }
+        catch (error) {
+            return toConvexError(error, 'Failed to list deployment classes');
+        }
+    },
+});
+export const convexListDeploymentRegions = tool({
+    description: 'List deployment regions available to a team with availability flags. Use before creating a deployment in a specific region.',
+    inputSchema: z.object({
+        convexToken: tokenField,
+        teamId: teamIdField,
+    }),
+    execute: async ({ convexToken, teamId }) => {
+        try {
+            const missing = requireToken(convexToken);
+            if (missing)
+                return missing;
+            const data = await convexMgmt(convexToken, 'GET', `/teams/${teamId}/list_deployment_regions`);
+            return Array.isArray(data) ? { items: data } : data;
+        }
+        catch (error) {
+            return toConvexError(error, 'Failed to list deployment regions');
+        }
+    },
+});
+//# sourceMappingURL=teams.js.map

package/dist/toolkits/datadog/icon.d.ts

@@ -0,0 +1,5 @@
+export declare const DATADOG_ICON: {
+    kind: "svg";
+    dataUri: string;
+};
+//# sourceMappingURL=icon.d.ts.map

package/dist/toolkits/datadog/icon.js

@@ -0,0 +1,6 @@
+const SVG = `<svg width="800px" height="800px" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" fill="none"><path fill="#632CA6" fill-rule="evenodd" d="M12.886 10.938l-1.157-.767-.965 1.622-1.122-.33-.988 1.517.05.478 5.374-.996-.313-3.378-.879 1.854zm-5.01-1.456l.861-.12c.14.064.237.088.404.13.26.069.562.134 1.009-.092.104-.052.32-.251.408-.365l3.532-.644.36 4.388L8.4 13.876l-.524-4.394zm6.56-1.581l-.348.067-.67-6.964L2.004 2.336l1.407 11.481 1.335-.195a3.03 3.03 0 00-.556-.576c-.393-.33-.254-.888-.022-1.24.307-.596 1.889-1.354 1.8-2.307-.033-.346-.088-.797-.407-1.106-.012.128.01.252.01.252s-.132-.169-.197-.398c-.065-.088-.116-.117-.185-.234-.05.136-.043.294-.043.294s-.107-.255-.125-.47a.752.752 0 00-.08.279s-.139-.403-.107-.62c-.064-.188-.252-.562-.199-1.412.348.245 1.115.187 1.414-.256.1-.147.167-.548-.05-1.337-.139-.506-.483-1.26-.618-1.546l-.016.012c.071.23.217.713.273.947.17.71.215.958.136 1.285-.068.285-.23.471-.642.68-.412.208-.958-.3-.993-.328-.4-.32-.709-.844-.744-1.098-.035-.278.16-.445.258-.672-.14.04-.298.112-.298.112s.188-.195.419-.364c.095-.063.152-.104.252-.188-.146-.003-.264.002-.264.002s.243-.133.496-.23c-.185-.007-.362 0-.362 0s.544-.245.973-.424c.295-.122.583-.086.745.15.212.308.436.476.909.58.29-.13.379-.197.744-.297.321-.355.573-.401.573-.401s-.125.115-.158.297c.182-.145.382-.265.382-.265s-.078.096-.15.249l.017.025c.213-.129.463-.23.463-.23s-.072.091-.156.209c.16-.002.486.006.612.02.745.017.9-.8 1.185-.902.358-.129.518-.206 1.128.396.523.518.932 1.444.73 1.652-.171.172-.507-.068-.879-.534a2.026 2.026 0 01-.415-.911c-.059-.313-.288-.495-.288-.495s.133.297.133.56c0 .142.018.678.246.979-.022.044-.033.217-.058.25-.265-.323-.836-.554-.929-.622.315.26 1.039.856 1.317 1.428.263.54.108 1.035.24 1.164.039.037.566.698.668 1.03.177.58.01 1.188-.222 1.566l-.647.101c-.094-.026-.158-.04-.243-.09.047-.082.14-.29.14-.333l-.036-.065a2.737 2.737 0 01-.819.726c-.367.21-.79.177-1.065.092-.781-.243-1.52-.774-1.698-.914 0 0-.005.112.028.137.197.223.648.628 1.085.91l-.93.102.44 3.444c-.196.029-.226.042-.44.073-.187-.669-.547-1.105-.94-1.36-.347-.223-.825-.274-1.283-.183l-.03.034c.319-.033.695.014 1.08.26.38.24.685.863.797 1.238.144.479.244.991-.144 1.534-.275.386-1.08.6-1.73.138.174.281.409.51.725.554.469.064.914-.018 1.22-.334.262-.27.4-.836.364-1.432l.414-.06.15 1.069 6.852-.83-.56-5.487zm-4.168-2.905c-.02.044-.05.073-.005.216l.003.008.007.019.02.042c.08.168.17.326.32.406.038-.006.078-.01.12-.013a.546.546 0 01.284.047.607.607 0 00.003-.13c-.01-.212.042-.573-.363-.762-.153-.072-.367-.05-.439.04a.175.175 0 01.034.007c.108.038.035.075.015.12zm1.134 1.978c-.053-.03-.301-.018-.475.003-.333.04-.691.155-.77.217-.143.111-.078.305.027.384.297.223.556.372.83.336.168-.022.317-.29.422-.534.072-.167.072-.348-.034-.406zM8.461 5.259c.093-.09-.467-.207-.902.09-.32.221-.33.693-.024.96.03.027.056.046.08.06a2.75 2.75 0 01.809-.24c.065-.072.14-.2.121-.434-.025-.315-.263-.265-.084-.436z" clip-rule="evenodd"/></svg>`;
+export const DATADOG_ICON = {
+    kind: 'svg',
+    dataUri: `data:image/svg+xml;base64,${Buffer.from(SVG).toString('base64')}`,
+};
+//# sourceMappingURL=icon.js.map

package/dist/toolkits/datadog/manifest.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("../../index.js").ToolkitManifest;
+export default _default;
+//# sourceMappingURL=manifest.d.ts.map

package/dist/toolkits/datadog/manifest.js

@@ -0,0 +1,44 @@
+import { defineToolkit, defineTool } from '../../core/define.js';
+import { inferToolScope } from '../../core/scope.js';
+import { DATADOG_ICON } from './icon.js';
+import { datadogTools } from './tools/index.js';
+export default defineToolkit({
+    id: 'datadog',
+    displayName: 'Datadog',
+    shortDescription: 'Logs, metrics, monitors, dashboards, APM, and on-call.',
+    category: 'Analytics & Data',
+    icon: DATADOG_ICON,
+    auth: {
+        type: 'service_account',
+        tokenField: 'datadogCredentials',
+        provider: {
+            fields: ['apiKey', 'appKey', 'site'],
+            connectDescription: 'Connect Datadog with an API key and an Application key (Organization Settings > API Keys / Application Keys), plus the API host for your site, e.g. api.datadoghq.com (US1), api.datadoghq.eu (EU), api.us3.datadoghq.com, api.us5.datadoghq.com, api.ap1.datadoghq.com, or api.ap2.datadoghq.com. Short site codes (us1, eu, ap1, ...) are also accepted.',
+        },
+    },
+    allowedHosts: [
+        'api.datadoghq.com',
+        'api.us3.datadoghq.com',
+        'api.us5.datadoghq.com',
+        'api.datadoghq.eu',
+        'api.ap1.datadoghq.com',
+        'api.ap2.datadoghq.com',
+        'api.ddog-gov.com',
+        'api.us2.ddog-gov.com',
+        'api.uk1.datadoghq.com',
+    ],
+    tools: datadogTools.map((entry) => defineTool({
+        name: entry.name,
+        description: entry.description,
+        tool: entry.tool,
+        requiredAuth: entry.requiredAuth,
+        scope: entry.scope ?? inferToolScope(entry.name),
+    })),
+    meta: {
+        since: '0.0.10',
+        homepage: 'https://www.datadoghq.com',
+        docsUrl: 'https://docs.datadoghq.com/api/latest/',
+        apiDocsUrl: 'https://docs.datadoghq.com/api/latest/',
+    },
+});
+//# sourceMappingURL=manifest.js.map

package/dist/toolkits/datadog/tools/api-keys.d.ts

@@ -0,0 +1,21 @@
+export declare const datadogListApiKeys: import("ai").Tool<{
+    datadogCredentials: string;
+    sort?: "name" | "created_at" | "last4" | "modified_at" | undefined;
+    page_size?: number | undefined;
+    page_number?: number | undefined;
+    filter_created_at_start?: string | undefined;
+    filter_created_at_end?: string | undefined;
+    filter_modified_at_start?: string | undefined;
+    filter_modified_at_end?: string | undefined;
+}, {
+    error: string;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+} | {
+    data: any;
+    meta: any;
+    total_count: any;
+}>;
+//# sourceMappingURL=api-keys.d.ts.map

package/dist/toolkits/datadog/tools/api-keys.js

@@ -0,0 +1,42 @@
+// @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 datadogListApiKeys = tool({
+    description: 'List API key metadata (names, owners, last-used) for auditing and rotation planning. Handle output securely — restrict to authorized personnel.',
+    inputSchema: z.object({
+        datadogCredentials: credsField,
+        sort: z.enum(['created_at', 'last4', 'modified_at', 'name']).optional().describe('Sort field'),
+        page_size: z.number().min(1).max(1000).optional().describe('Keys per page (default 20, max 1000)'),
+        page_number: z.number().min(0).optional().describe('Page number (0-indexed)'),
+        filter_created_at_start: z.string().optional().describe('ISO: keys created after this time'),
+        filter_created_at_end: z.string().optional().describe('ISO: keys created before this time'),
+        filter_modified_at_start: z.string().optional().describe('ISO: keys modified after this time'),
+        filter_modified_at_end: z.string().optional().describe('ISO: keys modified before this time'),
+    }),
+    execute: async ({ datadogCredentials, page_size, page_number, sort, ...filters }) => {
+        try {
+            const data = await ddApi(datadogCredentials, 'GET', '/api/v2/api_keys', {
+                query: {
+                    sort,
+                    'page[size]': page_size,
+                    'page[number]': page_number,
+                    'filter[created_at][start]': filters.filter_created_at_start,
+                    'filter[created_at][end]': filters.filter_created_at_end,
+                    'filter[modified_at][start]': filters.filter_modified_at_start,
+                    'filter[modified_at][end]': filters.filter_modified_at_end,
+                },
+            });
+            return {
+                data: data?.data ?? [],
+                meta: data?.meta,
+                total_count: data?.meta?.page?.total_count ?? data?.data?.length ?? 0,
+            };
+        }
+        catch (error) {
+            return toDatadogError(error, 'Failed to list API keys');
+        }
+    },
+});
+//# sourceMappingURL=api-keys.js.map

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

@@ -0,0 +1,51 @@
+export declare const datadogListApmServices: import("ai").Tool<{
+    env: string;
+    datadogCredentials: string;
+}, {
+    error: string;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+} | {
+    services: any;
+    total_count: any;
+}>;
+export declare const datadogSearchTraces: import("ai").Tool<{
+    filter: {
+        from_time: string;
+        to_time: string;
+        query?: string | undefined;
+    };
+    datadogCredentials: string;
+    options?: Record<string, any> | undefined;
+    sort?: {
+        order?: string | undefined;
+        field?: string | undefined;
+    } | undefined;
+    page?: Record<string, any> | undefined;
+}, {
+    error: string;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+} | {
+    data: any;
+    meta: any;
+    links: any;
+    total_count: any;
+}>;
+export declare const datadogSearchSpansAnalytics: import("ai").Tool<{
+    filter: {
+        query?: string | undefined;
+        indexes?: string[] | undefined;
+        from_time?: string | undefined;
+        to_time?: string | undefined;
+    };
+    datadogCredentials: string;
+    options?: Record<string, any> | undefined;
+    compute?: Record<string, any>[] | undefined;
+    group_by?: Record<string, any>[] | undefined;
+}, any>;
+//# sourceMappingURL=apm.d.ts.map

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