@jaypie/mcp 0.1.9 → 0.2.0

package/dist/index.js

@@ -7,12 +7,801 @@ import { z } from 'zod';
 import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
 import matter from 'gray-matter';
+import * as https from 'node:https';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
 import { randomUUID } from 'node:crypto';
 
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-const PROMPTS_PATH = path.join(__dirname, "..", "prompts");
+/**
+ * Datadog API integration module
+ */
+const nullLogger = {
+    info: () => { },
+    error: () => { },
+};
+/**
+ * Get Datadog credentials from environment variables
+ */
+function getDatadogCredentials() {
+    const apiKey = process.env.DATADOG_API_KEY || process.env.DD_API_KEY;
+    const appKey = process.env.DATADOG_APP_KEY ||
+        process.env.DATADOG_APPLICATION_KEY ||
+        process.env.DD_APP_KEY ||
+        process.env.DD_APPLICATION_KEY;
+    if (!apiKey || !appKey) {
+        return null;
+    }
+    return { apiKey, appKey };
+}
+/**
+ * Build query string from environment variables and options
+ */
+function buildDatadogQuery(options) {
+    const ddEnv = process.env.DD_ENV;
+    const ddService = process.env.DD_SERVICE;
+    const ddSource = process.env.DD_SOURCE;
+    const ddQuery = process.env.DD_QUERY;
+    const queryParts = [];
+    // Add source (parameter > env var > default 'lambda')
+    const effectiveSource = options.source || ddSource || "lambda";
+    queryParts.push(`source:${effectiveSource}`);
+    // Add env (parameter > env var)
+    const effectiveEnv = options.env || ddEnv;
+    if (effectiveEnv) {
+        queryParts.push(`env:${effectiveEnv}`);
+    }
+    // Add service (parameter > env var)
+    const effectiveService = options.service || ddService;
+    if (effectiveService) {
+        queryParts.push(`service:${effectiveService}`);
+    }
+    // Add base query from DD_QUERY if available
+    if (ddQuery) {
+        queryParts.push(ddQuery);
+    }
+    // Add user-provided query terms
+    if (options.query) {
+        queryParts.push(options.query);
+    }
+    return queryParts.join(" ");
+}
+/**
+ * Search Datadog logs
+ */
+async function searchDatadogLogs(credentials, options = {}, logger = nullLogger) {
+    const effectiveQuery = buildDatadogQuery(options);
+    const effectiveFrom = options.from || "now-15m";
+    const effectiveTo = options.to || "now";
+    const effectiveLimit = Math.min(options.limit || 50, 1000);
+    const effectiveSort = options.sort || "-timestamp";
+    logger.info(`Effective query: ${effectiveQuery}`);
+    logger.info(`Search params: from=${effectiveFrom}, to=${effectiveTo}, limit=${effectiveLimit}, sort=${effectiveSort}`);
+    const requestBody = JSON.stringify({
+        filter: {
+            query: effectiveQuery,
+            from: effectiveFrom,
+            to: effectiveTo,
+        },
+        page: {
+            limit: effectiveLimit,
+        },
+        sort: effectiveSort,
+    });
+    return new Promise((resolve) => {
+        const requestOptions = {
+            hostname: "api.datadoghq.com",
+            port: 443,
+            path: "/api/v2/logs/events/search",
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "DD-API-KEY": credentials.apiKey,
+                "DD-APPLICATION-KEY": credentials.appKey,
+                "Content-Length": Buffer.byteLength(requestBody),
+            },
+        };
+        const req = https.request(requestOptions, (res) => {
+            let data = "";
+            res.on("data", (chunk) => {
+                data += chunk.toString();
+            });
+            res.on("end", () => {
+                logger.info(`Response status: ${res.statusCode}`);
+                if (res.statusCode !== 200) {
+                    logger.error(`Datadog API error: ${res.statusCode}`);
+                    let errorMessage = `Datadog API returned status ${res.statusCode}: ${data}`;
+                    if (res.statusCode === 400) {
+                        errorMessage = `Invalid query syntax. Check your query: "${effectiveQuery}". Datadog error: ${data}`;
+                    }
+                    else if (res.statusCode === 403) {
+                        errorMessage =
+                            "Access denied. Verify your API and Application keys have logs_read permission.";
+                    }
+                    else if (res.statusCode === 429) {
+                        errorMessage =
+                            "Rate limited by Datadog. Wait a moment and try again, or reduce your query scope.";
+                    }
+                    resolve({
+                        success: false,
+                        query: effectiveQuery,
+                        timeRange: { from: effectiveFrom, to: effectiveTo },
+                        logs: [],
+                        error: errorMessage,
+                    });
+                    return;
+                }
+                try {
+                    const response = JSON.parse(data);
+                    const logs = (response.data || []).map((log) => {
+                        const attrs = log.attributes || {};
+                        return {
+                            id: log.id,
+                            timestamp: attrs.timestamp,
+                            status: attrs.status,
+                            service: attrs.service,
+                            message: attrs.message,
+                            attributes: attrs.attributes,
+                        };
+                    });
+                    logger.info(`Retrieved ${logs.length} log entries`);
+                    resolve({
+                        success: true,
+                        query: effectiveQuery,
+                        timeRange: { from: effectiveFrom, to: effectiveTo },
+                        logs,
+                    });
+                }
+                catch (parseError) {
+                    logger.error("Failed to parse Datadog response:", parseError);
+                    resolve({
+                        success: false,
+                        query: effectiveQuery,
+                        timeRange: { from: effectiveFrom, to: effectiveTo },
+                        logs: [],
+                        error: `Failed to parse response: ${parseError instanceof Error ? parseError.message : "Unknown error"}`,
+                    });
+                }
+            });
+        });
+        req.on("error", (error) => {
+            logger.error("Request error:", error);
+            resolve({
+                success: false,
+                query: effectiveQuery,
+                timeRange: { from: effectiveFrom, to: effectiveTo },
+                logs: [],
+                error: `Connection error: ${error.message}`,
+            });
+        });
+        req.write(requestBody);
+        req.end();
+    });
+}
+/**
+ * Aggregate Datadog logs using the Analytics API
+ * Groups logs by specified fields and computes aggregations
+ */
+async function aggregateDatadogLogs(credentials, options, logger = nullLogger) {
+    const effectiveQuery = buildDatadogQuery(options);
+    const effectiveFrom = options.from || "now-15m";
+    const effectiveTo = options.to || "now";
+    const groupBy = options.groupBy;
+    const compute = options.compute || [{ aggregation: "count" }];
+    logger.info(`Analytics query: ${effectiveQuery}`);
+    logger.info(`Group by: ${groupBy.join(", ")}`);
+    logger.info(`Time range: ${effectiveFrom} to ${effectiveTo}`);
+    // Build compute array - each item needs aggregation and type
+    const computeItems = compute.map((c) => {
+        const item = {
+            aggregation: c.aggregation,
+            type: "total",
+        };
+        if (c.metric) {
+            item.metric = c.metric;
+        }
+        return item;
+    });
+    // Build group_by with proper sort configuration
+    const groupByItems = groupBy.map((field) => {
+        const item = {
+            facet: field,
+            limit: 100,
+            sort: {
+                type: "measure",
+                order: "desc",
+                aggregation: compute[0]?.aggregation || "count",
+            },
+        };
+        return item;
+    });
+    const requestBody = JSON.stringify({
+        filter: {
+            query: effectiveQuery,
+            from: effectiveFrom,
+            to: effectiveTo,
+        },
+        group_by: groupByItems,
+        compute: computeItems,
+        page: {
+            limit: 100,
+        },
+    });
+    return new Promise((resolve) => {
+        const requestOptions = {
+            hostname: "api.datadoghq.com",
+            port: 443,
+            path: "/api/v2/logs/analytics/aggregate",
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "DD-API-KEY": credentials.apiKey,
+                "DD-APPLICATION-KEY": credentials.appKey,
+                "Content-Length": Buffer.byteLength(requestBody),
+            },
+        };
+        const req = https.request(requestOptions, (res) => {
+            let data = "";
+            res.on("data", (chunk) => {
+                data += chunk.toString();
+            });
+            res.on("end", () => {
+                logger.info(`Response status: ${res.statusCode}`);
+                if (res.statusCode !== 200) {
+                    logger.error(`Datadog Analytics API error: ${res.statusCode}`);
+                    let errorMessage = `Datadog API returned status ${res.statusCode}: ${data}`;
+                    if (res.statusCode === 400) {
+                        errorMessage = `Invalid query or groupBy fields. Verify facet names exist: ${groupBy.join(", ")}. Datadog error: ${data}`;
+                    }
+                    else if (res.statusCode === 403) {
+                        errorMessage =
+                            "Access denied. Verify your API and Application keys have logs_read permission.";
+                    }
+                    else if (res.statusCode === 429) {
+                        errorMessage =
+                            "Rate limited by Datadog. Wait a moment and try again, or reduce your query scope.";
+                    }
+                    resolve({
+                        success: false,
+                        query: effectiveQuery,
+                        timeRange: { from: effectiveFrom, to: effectiveTo },
+                        groupBy,
+                        buckets: [],
+                        error: errorMessage,
+                    });
+                    return;
+                }
+                try {
+                    const response = JSON.parse(data);
+                    const buckets = (response.data?.buckets || []).map((bucket) => ({
+                        by: bucket.by || {},
+                        computes: bucket.computes || {},
+                    }));
+                    logger.info(`Retrieved ${buckets.length} aggregation buckets`);
+                    resolve({
+                        success: true,
+                        query: effectiveQuery,
+                        timeRange: { from: effectiveFrom, to: effectiveTo },
+                        groupBy,
+                        buckets,
+                    });
+                }
+                catch (parseError) {
+                    logger.error("Failed to parse Datadog analytics response:", parseError);
+                    resolve({
+                        success: false,
+                        query: effectiveQuery,
+                        timeRange: { from: effectiveFrom, to: effectiveTo },
+                        groupBy,
+                        buckets: [],
+                        error: `Failed to parse response: ${parseError instanceof Error ? parseError.message : "Unknown error"}`,
+                    });
+                }
+            });
+        });
+        req.on("error", (error) => {
+            logger.error("Request error:", error);
+            resolve({
+                success: false,
+                query: effectiveQuery,
+                timeRange: { from: effectiveFrom, to: effectiveTo },
+                groupBy,
+                buckets: [],
+                error: `Connection error: ${error.message}`,
+            });
+        });
+        req.write(requestBody);
+        req.end();
+    });
+}
+/**
+ * List Datadog monitors with optional filtering
+ */
+async function listDatadogMonitors(credentials, options = {}, logger = nullLogger) {
+    logger.info("Fetching Datadog monitors");
+    const queryParams = new URLSearchParams();
+    if (options.tags && options.tags.length > 0) {
+        queryParams.set("tags", options.tags.join(","));
+    }
+    if (options.monitorTags && options.monitorTags.length > 0) {
+        queryParams.set("monitor_tags", options.monitorTags.join(","));
+    }
+    if (options.name) {
+        queryParams.set("name", options.name);
+    }
+    const queryString = queryParams.toString();
+    const path = `/api/v1/monitor${queryString ? `?${queryString}` : ""}`;
+    logger.info(`Request path: ${path}`);
+    return new Promise((resolve) => {
+        const requestOptions = {
+            hostname: "api.datadoghq.com",
+            port: 443,
+            path,
+            method: "GET",
+            headers: {
+                "DD-API-KEY": credentials.apiKey,
+                "DD-APPLICATION-KEY": credentials.appKey,
+            },
+        };
+        const req = https.request(requestOptions, (res) => {
+            let data = "";
+            res.on("data", (chunk) => {
+                data += chunk.toString();
+            });
+            res.on("end", () => {
+                logger.info(`Response status: ${res.statusCode}`);
+                if (res.statusCode !== 200) {
+                    logger.error(`Datadog Monitors API error: ${res.statusCode}`);
+                    let errorMessage = `Datadog API returned status ${res.statusCode}: ${data}`;
+                    if (res.statusCode === 403) {
+                        errorMessage =
+                            "Access denied. Verify your API and Application keys have monitors_read permission.";
+                    }
+                    else if (res.statusCode === 429) {
+                        errorMessage =
+                            "Rate limited by Datadog. Wait a moment and try again.";
+                    }
+                    resolve({
+                        success: false,
+                        monitors: [],
+                        error: errorMessage,
+                    });
+                    return;
+                }
+                try {
+                    const response = JSON.parse(data);
+                    let monitors = response.map((monitor) => ({
+                        id: monitor.id,
+                        name: monitor.name,
+                        type: monitor.type,
+                        status: monitor.overall_state || "Unknown",
+                        message: monitor.message,
+                        tags: monitor.tags || [],
+                        priority: monitor.priority,
+                        query: monitor.query,
+                        overallState: monitor.overall_state,
+                    }));
+                    // Filter by status if specified
+                    if (options.status && options.status.length > 0) {
+                        monitors = monitors.filter((m) => options.status.includes(m.status));
+                    }
+                    logger.info(`Retrieved ${monitors.length} monitors`);
+                    resolve({
+                        success: true,
+                        monitors,
+                    });
+                }
+                catch (parseError) {
+                    logger.error("Failed to parse Datadog monitors response:", parseError);
+                    resolve({
+                        success: false,
+                        monitors: [],
+                        error: `Failed to parse response: ${parseError instanceof Error ? parseError.message : "Unknown error"}`,
+                    });
+                }
+            });
+        });
+        req.on("error", (error) => {
+            logger.error("Request error:", error);
+            resolve({
+                success: false,
+                monitors: [],
+                error: `Connection error: ${error.message}`,
+            });
+        });
+        req.end();
+    });
+}
+/**
+ * List Datadog Synthetic tests
+ */
+async function listDatadogSynthetics(credentials, options = {}, logger = nullLogger) {
+    logger.info("Fetching Datadog Synthetic tests");
+    return new Promise((resolve) => {
+        const requestOptions = {
+            hostname: "api.datadoghq.com",
+            port: 443,
+            path: "/api/v1/synthetics/tests",
+            method: "GET",
+            headers: {
+                "DD-API-KEY": credentials.apiKey,
+                "DD-APPLICATION-KEY": credentials.appKey,
+            },
+        };
+        const req = https.request(requestOptions, (res) => {
+            let data = "";
+            res.on("data", (chunk) => {
+                data += chunk.toString();
+            });
+            res.on("end", () => {
+                logger.info(`Response status: ${res.statusCode}`);
+                if (res.statusCode !== 200) {
+                    logger.error(`Datadog Synthetics API error: ${res.statusCode}`);
+                    let errorMessage = `Datadog API returned status ${res.statusCode}: ${data}`;
+                    if (res.statusCode === 403) {
+                        errorMessage =
+                            "Access denied. Verify your API and Application keys have synthetics_read permission.";
+                    }
+                    else if (res.statusCode === 429) {
+                        errorMessage =
+                            "Rate limited by Datadog. Wait a moment and try again.";
+                    }
+                    resolve({
+                        success: false,
+                        tests: [],
+                        error: errorMessage,
+                    });
+                    return;
+                }
+                try {
+                    const response = JSON.parse(data);
+                    let tests = (response.tests || []).map((test) => ({
+                        publicId: test.public_id,
+                        name: test.name,
+                        type: test.type,
+                        status: test.status,
+                        tags: test.tags || [],
+                        locations: test.locations || [],
+                        message: test.message,
+                    }));
+                    // Filter by type if specified
+                    if (options.type) {
+                        tests = tests.filter((t) => t.type === options.type);
+                    }
+                    // Filter by tags if specified
+                    if (options.tags && options.tags.length > 0) {
+                        tests = tests.filter((t) => options.tags.some((tag) => t.tags.includes(tag)));
+                    }
+                    logger.info(`Retrieved ${tests.length} synthetic tests`);
+                    resolve({
+                        success: true,
+                        tests,
+                    });
+                }
+                catch (parseError) {
+                    logger.error("Failed to parse Datadog synthetics response:", parseError);
+                    resolve({
+                        success: false,
+                        tests: [],
+                        error: `Failed to parse response: ${parseError instanceof Error ? parseError.message : "Unknown error"}`,
+                    });
+                }
+            });
+        });
+        req.on("error", (error) => {
+            logger.error("Request error:", error);
+            resolve({
+                success: false,
+                tests: [],
+                error: `Connection error: ${error.message}`,
+            });
+        });
+        req.end();
+    });
+}
+/**
+ * Get recent results for a specific Synthetic test
+ */
+async function getDatadogSyntheticResults(credentials, publicId, logger = nullLogger) {
+    logger.info(`Fetching results for Synthetic test: ${publicId}`);
+    return new Promise((resolve) => {
+        const requestOptions = {
+            hostname: "api.datadoghq.com",
+            port: 443,
+            path: `/api/v1/synthetics/tests/${publicId}/results`,
+            method: "GET",
+            headers: {
+                "DD-API-KEY": credentials.apiKey,
+                "DD-APPLICATION-KEY": credentials.appKey,
+            },
+        };
+        const req = https.request(requestOptions, (res) => {
+            let data = "";
+            res.on("data", (chunk) => {
+                data += chunk.toString();
+            });
+            res.on("end", () => {
+                logger.info(`Response status: ${res.statusCode}`);
+                if (res.statusCode !== 200) {
+                    logger.error(`Datadog Synthetics Results API error: ${res.statusCode}`);
+                    let errorMessage = `Datadog API returned status ${res.statusCode}: ${data}`;
+                    if (res.statusCode === 403) {
+                        errorMessage =
+                            "Access denied. Verify your API and Application keys have synthetics_read permission.";
+                    }
+                    else if (res.statusCode === 404) {
+                        errorMessage = `Synthetic test '${publicId}' not found. Use datadog_synthetics (without testId) to list available tests.`;
+                    }
+                    else if (res.statusCode === 429) {
+                        errorMessage =
+                            "Rate limited by Datadog. Wait a moment and try again.";
+                    }
+                    resolve({
+                        success: false,
+                        publicId,
+                        results: [],
+                        error: errorMessage,
+                    });
+                    return;
+                }
+                try {
+                    const response = JSON.parse(data);
+                    const results = (response.results || []).map((result) => ({
+                        publicId,
+                        resultId: result.result_id,
+                        status: result.status,
+                        checkTime: result.check_time,
+                        passed: result.result?.passed ?? result.status === 0,
+                        location: result.dc_id?.toString(),
+                    }));
+                    logger.info(`Retrieved ${results.length} synthetic results`);
+                    resolve({
+                        success: true,
+                        publicId,
+                        results,
+                    });
+                }
+                catch (parseError) {
+                    logger.error("Failed to parse Datadog synthetic results:", parseError);
+                    resolve({
+                        success: false,
+                        publicId,
+                        results: [],
+                        error: `Failed to parse response: ${parseError instanceof Error ? parseError.message : "Unknown error"}`,
+                    });
+                }
+            });
+        });
+        req.on("error", (error) => {
+            logger.error("Request error:", error);
+            resolve({
+                success: false,
+                publicId,
+                results: [],
+                error: `Connection error: ${error.message}`,
+            });
+        });
+        req.end();
+    });
+}
+/**
+ * Query Datadog metrics
+ */
+async function queryDatadogMetrics(credentials, options, logger = nullLogger) {
+    logger.info(`Querying metrics: ${options.query}`);
+    logger.info(`Time range: ${options.from} to ${options.to}`);
+    const queryParams = new URLSearchParams({
+        query: options.query,
+        from: options.from.toString(),
+        to: options.to.toString(),
+    });
+    return new Promise((resolve) => {
+        const requestOptions = {
+            hostname: "api.datadoghq.com",
+            port: 443,
+            path: `/api/v1/query?${queryParams.toString()}`,
+            method: "GET",
+            headers: {
+                "DD-API-KEY": credentials.apiKey,
+                "DD-APPLICATION-KEY": credentials.appKey,
+            },
+        };
+        const req = https.request(requestOptions, (res) => {
+            let data = "";
+            res.on("data", (chunk) => {
+                data += chunk.toString();
+            });
+            res.on("end", () => {
+                logger.info(`Response status: ${res.statusCode}`);
+                if (res.statusCode !== 200) {
+                    logger.error(`Datadog Metrics API error: ${res.statusCode}`);
+                    let errorMessage = `Datadog API returned status ${res.statusCode}: ${data}`;
+                    if (res.statusCode === 400) {
+                        errorMessage = `Invalid metric query. Check format: 'aggregation:metric.name{tags}'. Query: "${options.query}". Datadog error: ${data}`;
+                    }
+                    else if (res.statusCode === 403) {
+                        errorMessage =
+                            "Access denied. Verify your API and Application keys have metrics_read permission.";
+                    }
+                    else if (res.statusCode === 429) {
+                        errorMessage =
+                            "Rate limited by Datadog. Wait a moment and try again, or reduce your time range.";
+                    }
+                    resolve({
+                        success: false,
+                        query: options.query,
+                        timeRange: { from: options.from, to: options.to },
+                        series: [],
+                        error: errorMessage,
+                    });
+                    return;
+                }
+                try {
+                    const response = JSON.parse(data);
+                    const series = (response.series || []).map((s) => ({
+                        metric: s.metric,
+                        scope: s.scope,
+                        pointlist: s.pointlist,
+                        unit: s.unit?.[0]?.name,
+                    }));
+                    logger.info(`Retrieved ${series.length} metric series`);
+                    resolve({
+                        success: true,
+                        query: options.query,
+                        timeRange: { from: options.from, to: options.to },
+                        series,
+                    });
+                }
+                catch (parseError) {
+                    logger.error("Failed to parse Datadog metrics response:", parseError);
+                    resolve({
+                        success: false,
+                        query: options.query,
+                        timeRange: { from: options.from, to: options.to },
+                        series: [],
+                        error: `Failed to parse response: ${parseError instanceof Error ? parseError.message : "Unknown error"}`,
+                    });
+                }
+            });
+        });
+        req.on("error", (error) => {
+            logger.error("Request error:", error);
+            resolve({
+                success: false,
+                query: options.query,
+                timeRange: { from: options.from, to: options.to },
+                series: [],
+                error: `Connection error: ${error.message}`,
+            });
+        });
+        req.end();
+    });
+}
+/**
+ * Search Datadog RUM events
+ */
+async function searchDatadogRum(credentials, options = {}, logger = nullLogger) {
+    const effectiveQuery = options.query || "*";
+    const effectiveFrom = options.from || "now-15m";
+    const effectiveTo = options.to || "now";
+    const effectiveLimit = Math.min(options.limit || 50, 1000);
+    const effectiveSort = options.sort || "-timestamp";
+    logger.info(`RUM query: ${effectiveQuery}`);
+    logger.info(`Time range: ${effectiveFrom} to ${effectiveTo}`);
+    const requestBody = JSON.stringify({
+        filter: {
+            query: effectiveQuery,
+            from: effectiveFrom,
+            to: effectiveTo,
+        },
+        page: {
+            limit: effectiveLimit,
+        },
+        sort: effectiveSort,
+    });
+    return new Promise((resolve) => {
+        const requestOptions = {
+            hostname: "api.datadoghq.com",
+            port: 443,
+            path: "/api/v2/rum/events/search",
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "DD-API-KEY": credentials.apiKey,
+                "DD-APPLICATION-KEY": credentials.appKey,
+                "Content-Length": Buffer.byteLength(requestBody),
+            },
+        };
+        const req = https.request(requestOptions, (res) => {
+            let data = "";
+            res.on("data", (chunk) => {
+                data += chunk.toString();
+            });
+            res.on("end", () => {
+                logger.info(`Response status: ${res.statusCode}`);
+                if (res.statusCode !== 200) {
+                    logger.error(`Datadog RUM API error: ${res.statusCode}`);
+                    let errorMessage = `Datadog API returned status ${res.statusCode}: ${data}`;
+                    // Check for specific "No valid indexes" error which means no RUM app is configured
+                    if (data.includes("No valid indexes")) {
+                        errorMessage =
+                            "No RUM application found. Ensure you have a RUM application configured in Datadog and it has collected data. " +
+                                "You can create a RUM application at https://app.datadoghq.com/rum/list";
+                    }
+                    else if (res.statusCode === 400) {
+                        errorMessage = `Invalid RUM query. Check syntax: "${effectiveQuery}". Datadog error: ${data}`;
+                    }
+                    else if (res.statusCode === 403) {
+                        errorMessage =
+                            "Access denied. Verify your API and Application keys have rum_read permission.";
+                    }
+                    else if (res.statusCode === 429) {
+                        errorMessage =
+                            "Rate limited by Datadog. Wait a moment and try again, or reduce your query scope.";
+                    }
+                    resolve({
+                        success: false,
+                        query: effectiveQuery,
+                        timeRange: { from: effectiveFrom, to: effectiveTo },
+                        events: [],
+                        error: errorMessage,
+                    });
+                    return;
+                }
+                try {
+                    const response = JSON.parse(data);
+                    const events = (response.data || []).map((event) => {
+                        const attrs = event.attributes?.attributes || {};
+                        return {
+                            id: event.id,
+                            type: event.type,
+                            timestamp: event.attributes?.timestamp,
+                            sessionId: attrs.session?.id,
+                            viewUrl: attrs.view?.url,
+                            viewName: attrs.view?.name,
+                            errorMessage: attrs.error?.message,
+                            errorType: attrs.error?.type,
+                            attributes: attrs,
+                        };
+                    });
+                    logger.info(`Retrieved ${events.length} RUM events`);
+                    resolve({
+                        success: true,
+                        query: effectiveQuery,
+                        timeRange: { from: effectiveFrom, to: effectiveTo },
+                        events,
+                    });
+                }
+                catch (parseError) {
+                    logger.error("Failed to parse Datadog RUM response:", parseError);
+                    resolve({
+                        success: false,
+                        query: effectiveQuery,
+                        timeRange: { from: effectiveFrom, to: effectiveTo },
+                        events: [],
+                        error: `Failed to parse response: ${parseError instanceof Error ? parseError.message : "Unknown error"}`,
+                    });
+                }
+            });
+        });
+        req.on("error", (error) => {
+            logger.error("Request error:", error);
+            resolve({
+                success: false,
+                query: effectiveQuery,
+                timeRange: { from: effectiveFrom, to: effectiveTo },
+                events: [],
+                error: `Connection error: ${error.message}`,
+            });
+        });
+        req.write(requestBody);
+        req.end();
+    });
+}
+
+const BUILD_VERSION_STRING = "@jaypie/mcp@0.2.0"
+    ;
+const __filename$1 = fileURLToPath(import.meta.url);
+const __dirname$1 = path.dirname(__filename$1);
+const PROMPTS_PATH = path.join(__dirname$1, "..", "prompts");
 // Logger utility
 function createLogger(verbose) {
     return {
@@ -79,7 +868,7 @@ function createMcpServer(options = {}) {
         capabilities: {},
     });
     log.info("Registering tools...");
-    server.tool("list_prompts", "Returns a bulleted list of all .md files in the prompts directory with their descriptions and requirements", {}, async () => {
+    server.tool("list_prompts", "List available Jaypie development prompts and guides. Use this FIRST when starting work on a Jaypie project to discover relevant documentation. Returns filenames, descriptions, and which file patterns each prompt applies to (e.g., 'Required for packages/express/**').", {}, async () => {
         log.info("Tool called: list_prompts");
         log.info(`Reading directory: ${PROMPTS_PATH}`);
         try {
@@ -111,10 +900,10 @@ function createMcpServer(options = {}) {
         }
     });
     log.info("Registered tool: list_prompts");
-    server.tool("read_prompt", "Returns the contents of a specified prompt file", {
+    server.tool("read_prompt", "Read a Jaypie prompt/guide by filename. Call list_prompts first to see available prompts. These contain best practices, templates, code patterns, and step-by-step guides for Jaypie development tasks.", {
         filename: z
             .string()
-            .describe("The name of the prompt file to read (e.g., example_prompt.md)"),
+            .describe("The prompt filename from list_prompts (e.g., 'Jaypie_Express_Package.md', 'Development_Process.md')"),
     }, async ({ filename }) => {
         log.info(`Tool called: read_prompt (filename: ${filename})`);
         try {
@@ -155,6 +944,672 @@ function createMcpServer(options = {}) {
         }
     });
     log.info("Registered tool: read_prompt");
+    server.tool("version", `Prints the current version and hash, \`${BUILD_VERSION_STRING}\``, {}, async () => {
+        log.info("Tool called: version");
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: BUILD_VERSION_STRING,
+                },
+            ],
+        };
+    });
+    log.info("Registered tool: version");
+    // Datadog Logs Tool
+    server.tool("datadog_logs", "Search and retrieve individual Datadog log entries. Use this to view actual log messages and details. For aggregated counts/statistics (e.g., 'how many errors by service?'), use datadog_log_analytics instead. Requires DATADOG_API_KEY and DATADOG_APP_KEY environment variables.", {
+        query: z
+            .string()
+            .optional()
+            .describe("Search query to filter logs. Examples: 'status:error', '@http.status_code:500', '*timeout*', '@requestId:abc123'. Combined with DD_ENV, DD_SERVICE, DD_SOURCE env vars if set."),
+        source: z
+            .string()
+            .optional()
+            .describe("Override the log source (e.g., 'lambda', 'auth0', 'nginx'). If not provided, uses DD_SOURCE env var or defaults to 'lambda'."),
+        env: z
+            .string()
+            .optional()
+            .describe("Override the environment (e.g., 'sandbox', 'kitchen', 'lab', 'studio', 'production'). If not provided, uses DD_ENV env var."),
+        service: z
+            .string()
+            .optional()
+            .describe("Override the service name. If not provided, uses DD_SERVICE env var."),
+        from: z
+            .string()
+            .optional()
+            .describe("Start time. Formats: relative ('now-15m', 'now-1h', 'now-1d'), ISO 8601 ('2024-01-15T10:00:00Z'). Defaults to 'now-15m'."),
+        to: z
+            .string()
+            .optional()
+            .describe("End time. Formats: 'now', relative ('now-5m'), or ISO 8601. Defaults to 'now'."),
+        limit: z
+            .number()
+            .optional()
+            .describe("Max logs to return (1-1000). Defaults to 50."),
+        sort: z
+            .enum(["timestamp", "-timestamp"])
+            .optional()
+            .describe("Sort order: 'timestamp' (oldest first) or '-timestamp' (newest first, default)."),
+    }, async ({ query, source, env, service, from, to, limit, sort }) => {
+        log.info("Tool called: datadog_logs");
+        const credentials = getDatadogCredentials();
+        if (!credentials) {
+            const missingApiKey = !process.env.DATADOG_API_KEY && !process.env.DD_API_KEY;
+            const missingAppKey = !process.env.DATADOG_APP_KEY &&
+                !process.env.DATADOG_APPLICATION_KEY &&
+                !process.env.DD_APP_KEY &&
+                !process.env.DD_APPLICATION_KEY;
+            if (missingApiKey) {
+                log.error("No Datadog API key found in environment");
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: "Error: No Datadog API key found. Please set DATADOG_API_KEY or DD_API_KEY environment variable.",
+                        },
+                    ],
+                };
+            }
+            if (missingAppKey) {
+                log.error("No Datadog Application key found in environment");
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: "Error: No Datadog Application key found. Please set DATADOG_APP_KEY or DD_APP_KEY environment variable. The Logs Search API requires both an API key and an Application key.",
+                        },
+                    ],
+                };
+            }
+        }
+        // credentials is guaranteed to be non-null here
+        const result = await searchDatadogLogs(credentials, {
+            query,
+            source,
+            env,
+            service,
+            from,
+            to,
+            limit,
+            sort,
+        }, log);
+        if (!result.success) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error from Datadog API: ${result.error}`,
+                    },
+                ],
+            };
+        }
+        if (result.logs.length === 0) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `No logs found for query: ${result.query}\nTime range: ${result.timeRange.from} to ${result.timeRange.to}`,
+                    },
+                ],
+            };
+        }
+        const resultText = [
+            `Query: ${result.query}`,
+            `Time range: ${result.timeRange.from} to ${result.timeRange.to}`,
+            `Found ${result.logs.length} log entries:`,
+            "",
+            JSON.stringify(result.logs, null, 2),
+        ].join("\n");
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: resultText,
+                },
+            ],
+        };
+    });
+    log.info("Registered tool: datadog_logs");
+    // Datadog Log Analytics Tool
+    server.tool("datadog_log_analytics", "Aggregate and analyze Datadog logs by grouping them by fields. Use this for statistics and counts (e.g., 'errors by service', 'requests by status code'). For viewing individual log entries, use datadog_logs instead.", {
+        groupBy: z
+            .array(z.string())
+            .describe("Fields to group by. Examples: ['source'], ['service', 'status'], ['@http.status_code']. Common facets: source, service, status, host, @http.status_code, @env."),
+        query: z
+            .string()
+            .optional()
+            .describe("Filter query. Examples: 'status:error', '*timeout*', '@http.method:POST'. Use '*' for all logs."),
+        source: z
+            .string()
+            .optional()
+            .describe("Override the log source filter. Use '*' to include all sources. If not provided, uses DD_SOURCE env var or defaults to 'lambda'."),
+        env: z
+            .string()
+            .optional()
+            .describe("Override the environment filter. If not provided, uses DD_ENV env var."),
+        service: z
+            .string()
+            .optional()
+            .describe("Override the service name filter. If not provided, uses DD_SERVICE env var."),
+        from: z
+            .string()
+            .optional()
+            .describe("Start time. Formats: relative ('now-15m', 'now-1h', 'now-1d'), ISO 8601 ('2024-01-15T10:00:00Z'). Defaults to 'now-15m'."),
+        to: z
+            .string()
+            .optional()
+            .describe("End time. Formats: 'now', relative ('now-5m'), or ISO 8601. Defaults to 'now'."),
+        aggregation: z
+            .enum(["count", "avg", "sum", "min", "max", "cardinality"])
+            .optional()
+            .describe("Aggregation type. 'count' counts logs, others require a metric field. Defaults to 'count'."),
+        metric: z
+            .string()
+            .optional()
+            .describe("Metric field to aggregate when using avg, sum, min, max, or cardinality. E.g., '@duration', '@http.response_time'."),
+    }, async ({ groupBy, query, source, env, service, from, to, aggregation, metric, }) => {
+        log.info("Tool called: datadog_log_analytics");
+        const credentials = getDatadogCredentials();
+        if (!credentials) {
+            const missingApiKey = !process.env.DATADOG_API_KEY && !process.env.DD_API_KEY;
+            const missingAppKey = !process.env.DATADOG_APP_KEY &&
+                !process.env.DATADOG_APPLICATION_KEY &&
+                !process.env.DD_APP_KEY &&
+                !process.env.DD_APPLICATION_KEY;
+            if (missingApiKey) {
+                log.error("No Datadog API key found in environment");
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: "Error: No Datadog API key found. Please set DATADOG_API_KEY or DD_API_KEY environment variable.",
+                        },
+                    ],
+                };
+            }
+            if (missingAppKey) {
+                log.error("No Datadog Application key found in environment");
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: "Error: No Datadog Application key found. Please set DATADOG_APP_KEY or DD_APP_KEY environment variable.",
+                        },
+                    ],
+                };
+            }
+        }
+        const compute = aggregation
+            ? [{ aggregation, metric }]
+            : [{ aggregation: "count" }];
+        const result = await aggregateDatadogLogs(credentials, {
+            query,
+            source,
+            env,
+            service,
+            from,
+            to,
+            groupBy,
+            compute,
+        }, log);
+        if (!result.success) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error from Datadog Analytics API: ${result.error}`,
+                    },
+                ],
+            };
+        }
+        if (result.buckets.length === 0) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `No data found for query: ${result.query}\nTime range: ${result.timeRange.from} to ${result.timeRange.to}\nGrouped by: ${result.groupBy.join(", ")}`,
+                    },
+                ],
+            };
+        }
+        // Format buckets as a readable table
+        const formattedBuckets = result.buckets.map((bucket) => {
+            const byParts = Object.entries(bucket.by)
+                .map(([key, value]) => `${key}: ${value}`)
+                .join(", ");
+            const computeParts = Object.entries(bucket.computes)
+                .map(([key, value]) => `${key}: ${value}`)
+                .join(", ");
+            return `  ${byParts} => ${computeParts}`;
+        });
+        const resultText = [
+            `Query: ${result.query}`,
+            `Time range: ${result.timeRange.from} to ${result.timeRange.to}`,
+            `Grouped by: ${result.groupBy.join(", ")}`,
+            `Found ${result.buckets.length} groups:`,
+            "",
+            ...formattedBuckets,
+        ].join("\n");
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: resultText,
+                },
+            ],
+        };
+    });
+    log.info("Registered tool: datadog_log_analytics");
+    // Datadog Monitors Tool
+    server.tool("datadog_monitors", "List and check Datadog monitors. Shows monitor status (Alert, Warn, No Data, OK), name, type, and tags. Useful for quickly checking if any monitors are alerting.", {
+        status: z
+            .array(z.enum(["Alert", "Warn", "No Data", "OK"]))
+            .optional()
+            .describe("Filter monitors by status. E.g., ['Alert', 'Warn'] to see only alerting monitors."),
+        tags: z
+            .array(z.string())
+            .optional()
+            .describe("Filter monitors by resource tags (tags on the monitored resources)."),
+        monitorTags: z
+            .array(z.string())
+            .optional()
+            .describe("Filter monitors by monitor tags (tags on the monitor itself)."),
+        name: z
+            .string()
+            .optional()
+            .describe("Filter monitors by name (partial match supported)."),
+    }, async ({ status, tags, monitorTags, name }) => {
+        log.info("Tool called: datadog_monitors");
+        const credentials = getDatadogCredentials();
+        if (!credentials) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Error: Datadog credentials not found. Please set DATADOG_API_KEY and DATADOG_APP_KEY environment variables.",
+                    },
+                ],
+            };
+        }
+        const result = await listDatadogMonitors(credentials, { status, tags, monitorTags, name }, log);
+        if (!result.success) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error from Datadog Monitors API: ${result.error}`,
+                    },
+                ],
+            };
+        }
+        if (result.monitors.length === 0) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "No monitors found matching the specified criteria.",
+                    },
+                ],
+            };
+        }
+        // Group monitors by status for better readability
+        const byStatus = {};
+        for (const monitor of result.monitors) {
+            const status = monitor.status;
+            if (!byStatus[status]) {
+                byStatus[status] = [];
+            }
+            byStatus[status].push(monitor);
+        }
+        const statusOrder = ["Alert", "Warn", "No Data", "OK", "Unknown"];
+        const formattedMonitors = [];
+        for (const status of statusOrder) {
+            const monitors = byStatus[status];
+            if (monitors && monitors.length > 0) {
+                formattedMonitors.push(`\n## ${status} (${monitors.length})`);
+                for (const m of monitors) {
+                    formattedMonitors.push(`  - [${m.id}] ${m.name} (${m.type})`);
+                }
+            }
+        }
+        const resultText = [
+            `Found ${result.monitors.length} monitors:`,
+            ...formattedMonitors,
+        ].join("\n");
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: resultText,
+                },
+            ],
+        };
+    });
+    log.info("Registered tool: datadog_monitors");
+    // Datadog Synthetics Tool
+    server.tool("datadog_synthetics", "List Datadog Synthetic tests and optionally get recent results for a specific test. Shows test status, type (api/browser), and locations.", {
+        type: z
+            .enum(["api", "browser"])
+            .optional()
+            .describe("Filter tests by type: 'api' or 'browser'."),
+        tags: z.array(z.string()).optional().describe("Filter tests by tags."),
+        testId: z
+            .string()
+            .optional()
+            .describe("If provided, fetches recent results for this specific test (public_id). Otherwise lists all tests."),
+    }, async ({ type, tags, testId }) => {
+        log.info("Tool called: datadog_synthetics");
+        const credentials = getDatadogCredentials();
+        if (!credentials) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Error: Datadog credentials not found. Please set DATADOG_API_KEY and DATADOG_APP_KEY environment variables.",
+                    },
+                ],
+            };
+        }
+        // If testId is provided, get results for that specific test
+        if (testId) {
+            const result = await getDatadogSyntheticResults(credentials, testId, log);
+            if (!result.success) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Error from Datadog Synthetics API: ${result.error}`,
+                        },
+                    ],
+                };
+            }
+            if (result.results.length === 0) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `No recent results found for test: ${testId}`,
+                        },
+                    ],
+                };
+            }
+            const passedCount = result.results.filter((r) => r.passed).length;
+            const failedCount = result.results.length - passedCount;
+            const formattedResults = result.results.slice(0, 10).map((r) => {
+                const date = new Date(r.checkTime * 1000).toISOString();
+                const status = r.passed ? "✓ PASSED" : "✗ FAILED";
+                return `  ${date} - ${status}`;
+            });
+            const resultText = [
+                `Results for test: ${testId}`,
+                `Recent: ${passedCount} passed, ${failedCount} failed (showing last ${Math.min(10, result.results.length)})`,
+                "",
+                ...formattedResults,
+            ].join("\n");
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: resultText,
+                    },
+                ],
+            };
+        }
+        // Otherwise list all tests
+        const result = await listDatadogSynthetics(credentials, { type, tags }, log);
+        if (!result.success) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error from Datadog Synthetics API: ${result.error}`,
+                    },
+                ],
+            };
+        }
+        if (result.tests.length === 0) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "No synthetic tests found matching the specified criteria.",
+                    },
+                ],
+            };
+        }
+        // Group by status
+        const byStatus = {};
+        for (const test of result.tests) {
+            const status = test.status;
+            if (!byStatus[status]) {
+                byStatus[status] = [];
+            }
+            byStatus[status].push(test);
+        }
+        const formattedTests = [];
+        for (const [status, tests] of Object.entries(byStatus)) {
+            formattedTests.push(`\n## ${status} (${tests.length})`);
+            for (const t of tests) {
+                formattedTests.push(`  - [${t.publicId}] ${t.name} (${t.type})`);
+            }
+        }
+        const resultText = [
+            `Found ${result.tests.length} synthetic tests:`,
+            ...formattedTests,
+        ].join("\n");
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: resultText,
+                },
+            ],
+        };
+    });
+    log.info("Registered tool: datadog_synthetics");
+    // Datadog Metrics Tool
+    server.tool("datadog_metrics", "Query Datadog metrics. Returns timeseries data for the specified metric query. Useful for checking specific metric values.", {
+        query: z
+            .string()
+            .describe("Metric query. Format: 'aggregation:metric.name{tags}'. Examples: 'avg:system.cpu.user{*}', 'sum:aws.lambda.invocations{function:my-func}.as_count()', 'max:aws.lambda.duration{env:production}'."),
+        from: z
+            .string()
+            .optional()
+            .describe("Start time. Formats: relative ('1h', '30m', '1d'), or Unix timestamp. Defaults to '1h'."),
+        to: z
+            .string()
+            .optional()
+            .describe("End time. Formats: 'now' or Unix timestamp. Defaults to 'now'."),
+    }, async ({ query, from, to }) => {
+        log.info("Tool called: datadog_metrics");
+        const credentials = getDatadogCredentials();
+        if (!credentials) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Error: Datadog credentials not found. Please set DATADOG_API_KEY and DATADOG_APP_KEY environment variables.",
+                    },
+                ],
+            };
+        }
+        // Parse time parameters
+        const now = Math.floor(Date.now() / 1000);
+        let fromTs;
+        let toTs;
+        // Parse 'from' parameter
+        const fromStr = from || "1h";
+        if (fromStr.match(/^\d+$/)) {
+            fromTs = parseInt(fromStr, 10);
+        }
+        else if (fromStr.match(/^(\d+)h$/)) {
+            const hours = parseInt(fromStr.match(/^(\d+)h$/)[1], 10);
+            fromTs = now - hours * 3600;
+        }
+        else if (fromStr.match(/^(\d+)m$/)) {
+            const minutes = parseInt(fromStr.match(/^(\d+)m$/)[1], 10);
+            fromTs = now - minutes * 60;
+        }
+        else if (fromStr.match(/^(\d+)d$/)) {
+            const days = parseInt(fromStr.match(/^(\d+)d$/)[1], 10);
+            fromTs = now - days * 86400;
+        }
+        else {
+            fromTs = now - 3600; // Default 1 hour
+        }
+        // Parse 'to' parameter
+        const toStr = to || "now";
+        if (toStr === "now") {
+            toTs = now;
+        }
+        else if (toStr.match(/^\d+$/)) {
+            toTs = parseInt(toStr, 10);
+        }
+        else {
+            toTs = now;
+        }
+        const result = await queryDatadogMetrics(credentials, { query, from: fromTs, to: toTs }, log);
+        if (!result.success) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error from Datadog Metrics API: ${result.error}`,
+                    },
+                ],
+            };
+        }
+        if (result.series.length === 0) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `No data found for query: ${query}\nTime range: ${new Date(fromTs * 1000).toISOString()} to ${new Date(toTs * 1000).toISOString()}`,
+                    },
+                ],
+            };
+        }
+        const formattedSeries = result.series.map((s) => {
+            const points = s.pointlist.slice(-5); // Last 5 points
+            const formattedPoints = points
+                .map(([ts, val]) => {
+                const date = new Date(ts).toISOString();
+                return `    ${date}: ${val !== null ? val.toFixed(4) : "null"}`;
+            })
+                .join("\n");
+            return `\n  ${s.metric} (${s.scope})${s.unit ? ` [${s.unit}]` : ""}:\n${formattedPoints}`;
+        });
+        const resultText = [
+            `Query: ${query}`,
+            `Time range: ${new Date(fromTs * 1000).toISOString()} to ${new Date(toTs * 1000).toISOString()}`,
+            `Found ${result.series.length} series (showing last 5 points each):`,
+            ...formattedSeries,
+        ].join("\n");
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: resultText,
+                },
+            ],
+        };
+    });
+    log.info("Registered tool: datadog_metrics");
+    // Datadog RUM Tool
+    server.tool("datadog_rum", "Search Datadog RUM (Real User Monitoring) events. Find user sessions, page views, errors, and actions. Useful for debugging frontend issues and understanding user behavior.", {
+        query: z
+            .string()
+            .optional()
+            .describe("RUM search query. E.g., '@type:error', '@session.id:abc123', '@view.url:*checkout*'. Defaults to '*' (all events)."),
+        from: z
+            .string()
+            .optional()
+            .describe("Start time. Formats: relative ('now-15m', 'now-1h', 'now-1d'), ISO 8601 ('2024-01-15T10:00:00Z'). Defaults to 'now-15m'."),
+        to: z
+            .string()
+            .optional()
+            .describe("End time. Formats: 'now', relative ('now-5m'), or ISO 8601. Defaults to 'now'."),
+        limit: z
+            .number()
+            .optional()
+            .describe("Max events to return (1-1000). Defaults to 50."),
+    }, async ({ query, from, to, limit }) => {
+        log.info("Tool called: datadog_rum");
+        const credentials = getDatadogCredentials();
+        if (!credentials) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Error: Datadog credentials not found. Please set DATADOG_API_KEY and DATADOG_APP_KEY environment variables.",
+                    },
+                ],
+            };
+        }
+        const result = await searchDatadogRum(credentials, { query, from, to, limit }, log);
+        if (!result.success) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error from Datadog RUM API: ${result.error}`,
+                    },
+                ],
+            };
+        }
+        if (result.events.length === 0) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `No RUM events found for query: ${result.query}\nTime range: ${result.timeRange.from} to ${result.timeRange.to}`,
+                    },
+                ],
+            };
+        }
+        // Group events by type for better readability
+        const byType = {};
+        for (const event of result.events) {
+            const type = event.type;
+            if (!byType[type]) {
+                byType[type] = [];
+            }
+            byType[type].push(event);
+        }
+        const formattedEvents = [];
+        for (const [type, events] of Object.entries(byType)) {
+            formattedEvents.push(`\n## ${type} (${events.length})`);
+            for (const e of events.slice(0, 10)) {
+                // Limit per type
+                const parts = [e.timestamp];
+                if (e.viewName || e.viewUrl) {
+                    parts.push(e.viewName || e.viewUrl || "");
+                }
+                if (e.errorMessage) {
+                    parts.push(`Error: ${e.errorMessage}`);
+                }
+                if (e.sessionId) {
+                    parts.push(`Session: ${e.sessionId.substring(0, 8)}...`);
+                }
+                formattedEvents.push(`  - ${parts.join(" | ")}`);
+            }
+        }
+        const resultText = [
+            `Query: ${result.query}`,
+            `Time range: ${result.timeRange.from} to ${result.timeRange.to}`,
+            `Found ${result.events.length} RUM events:`,
+            ...formattedEvents,
+        ].join("\n");
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: resultText,
+                },
+            ],
+        };
+    });
+    log.info("Registered tool: datadog_rum");
     log.info("MCP server configuration complete");
     return server;
 }