datadog-mcp 5.4.0 → 5.6.0

package/dist/index.js

@@ -134929,7 +134929,7 @@ var require_InputSchema = __commonJS({
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.InputSchema = void 0;
-    var InputSchema21 = class _InputSchema {
+    var InputSchema24 = class _InputSchema {
       constructor() {
       }
       /**
@@ -134939,8 +134939,8 @@ var require_InputSchema = __commonJS({
         return _InputSchema.attributeTypeMap;
       }
     };
-    exports.InputSchema = InputSchema21;
-    InputSchema21.attributeTypeMap = {
+    exports.InputSchema = InputSchema24;
+    InputSchema24.attributeTypeMap = {
       parameters: {
         baseName: "parameters",
         type: "Array<InputSchemaParameters>"
@@ -281731,10 +281731,10 @@ var require_object_inspect = __commonJS({
       }
       if (!isDate(obj) && !isRegExp(obj)) {
         var ys = arrObjKeys(obj, inspect);
-        var isPlainObject3 = gPO ? gPO(obj) === Object.prototype : obj instanceof Object || obj.constructor === Object;
+        var isPlainObject4 = gPO ? gPO(obj) === Object.prototype : obj instanceof Object || obj.constructor === Object;
         var protoTag = obj instanceof Object ? "" : "null prototype";
-        var stringTag = !isPlainObject3 && toStringTag && Object(obj) === obj && toStringTag in obj ? $slice.call(toStr(obj), 8, -1) : protoTag ? "Object" : "";
-        var constructorTag = isPlainObject3 || typeof obj.constructor !== "function" ? "" : obj.constructor.name ? obj.constructor.name + " " : "";
+        var stringTag = !isPlainObject4 && toStringTag && Object(obj) === obj && toStringTag in obj ? $slice.call(toStr(obj), 8, -1) : protoTag ? "Object" : "";
+        var constructorTag = isPlainObject4 || typeof obj.constructor !== "function" ? "" : obj.constructor.name ? obj.constructor.name + " " : "";
         var tag = constructorTag + (stringTag || protoTag ? "[" + $join.call($concat.call([], stringTag || [], protoTag || []), ": ") + "] " : "");
         if (ys.length === 0) {
           return tag + "{}";
@@ -302583,7 +302583,10 @@ function createDatadogClients(config2) {
     usage: new import_datadog_api_client.v1.UsageMeteringApi(configuration),
     spans: new import_datadog_api_client.v2.SpansApi(configuration),
     services: new import_datadog_api_client.v2.ServiceDefinitionApi(configuration),
-    auth: new import_datadog_api_client.v1.AuthenticationApi(configuration)
+    auth: new import_datadog_api_client.v1.AuthenticationApi(configuration),
+    logsPipelines: new import_datadog_api_client.v1.LogsPipelinesApi(configuration),
+    logsIndexes: new import_datadog_api_client.v1.LogsIndexesApi(configuration),
+    logsArchives: new import_datadog_api_client.v2.LogsArchivesApi(configuration)
   };
 }
 
@@ -302661,7 +302664,8 @@ var WRITE_ACTIONS = /* @__PURE__ */ new Set([
   "unmute",
   "cancel",
   "add",
-  "trigger"
+  "trigger",
+  "reorder"
 ]);
 function checkReadOnly(action, readOnly) {
   if (readOnly && WRITE_ACTIONS.has(action)) {
@@ -302941,6 +302945,20 @@ var InputSchema = {
   ),
   maxEvents: external_exports.number().min(1).max(5e3).optional().describe(
     "Maximum events to fetch for grouping in top action (default: 5000, max: 5000). Higher = more accurate but slower"
+  ),
+  // Monitor transition filter (additive — see requirement 5.2 / monitors action=history)
+  transitionType: external_exports.array(
+    external_exports.enum([
+      "alert",
+      "alert recovery",
+      "warning",
+      "warning recovery",
+      "no data",
+      "no data recovery",
+      "renotify"
+    ])
+  ).optional().describe(
+    'Filter events by monitor state transition type. When set, restricts results to events with @monitor.transition.transition_type matching any value. Use ["alert","alert recovery"] to count real fires/recoveries and skip renotifies. Empty array is treated as undefined (no filter). For a fires-only count by monitor ID, prefer monitors action=history.'
   )
 };
 function extractMonitorInfo(title) {
@@ -303168,6 +303186,9 @@ async function createEventV1(api, params) {
     }
   };
 }
+function quoteIfNeeded(value) {
+  return /^[A-Za-z0-9_.-]+$/.test(value) ? value : `"${value}"`;
+}
 function buildEventQuery(params) {
   const parts = [];
   if (params.query) {
@@ -303185,6 +303206,10 @@ function buildEventQuery(params) {
   if (params.priority) {
     parts.push(`priority:${params.priority}`);
   }
+  if (params.transitionType && params.transitionType.length > 0) {
+    const inner = params.transitionType.map(quoteIfNeeded).join(" OR ");
+    parts.push(`@monitor.transition.transition_type:(${inner})`);
+  }
   return parts.length > 0 ? parts.join(" ") : "*";
 }
 async function searchEventsV2(api, params, limits, site) {
@@ -303200,7 +303225,8 @@ async function searchEventsV2(api, params, limits, site) {
     query: params.query,
     sources: params.sources,
     tags: params.tags,
-    priority: params.priority
+    priority: params.priority,
+    transitionType: params.transitionType
   });
   const effectiveLimit = params.limit ?? limits.defaultLimit;
   const body = {
@@ -303243,7 +303269,8 @@ async function aggregateEventsV2(api, params, limits, site) {
   const fullQuery = buildEventQuery({
     query: params.query,
     sources: params.sources,
-    tags: params.tags
+    tags: params.tags,
+    transitionType: params.transitionType
   });
   const groupByFields = params.groupBy ?? ["monitor_name"];
   const maxEventsToAggregate = 1e4;
@@ -303325,7 +303352,8 @@ async function topEventsV2(api, params, limits, site) {
       to: params.to,
       sources: params.sources,
       tags: effectiveTags,
-      limit: params.maxEvents ?? 5e3
+      limit: params.maxEvents ?? 5e3,
+      transitionType: params.transitionType
     },
     limits,
     site
@@ -303414,7 +303442,8 @@ async function timeseriesEventsV2(api, params, limits, site) {
   const fullQuery = buildEventQuery({
     query: params.query ?? "source:alert",
     sources: params.sources,
-    tags: params.tags
+    tags: params.tags,
+    transitionType: params.transitionType
   });
   const intervalMs = parseIntervalToMs(params.interval);
   const groupByFields = params.groupBy ?? ["monitor_name"];
@@ -303499,7 +303528,8 @@ async function incidentsEventsV2(api, params, limits, site) {
   const fullQuery = buildEventQuery({
     query: params.query ?? "source:alert",
     sources: params.sources,
-    tags: params.tags
+    tags: params.tags,
+    transitionType: params.transitionType
   });
   const dedupeWindowNs = parseDurationToNs(params.dedupeWindow ?? "5m");
   const dedupeWindowMs = dedupeWindowNs ? Math.floor(dedupeWindowNs / 1e6) : 3e5;
@@ -303687,10 +303717,17 @@ function registerEventsTool(server, apiV1, apiV2, monitorsApi, limits, readOnly
     `Track Datadog events. Actions: list, get, create, search, aggregate, top, timeseries, incidents, discover.
 For monitor alerts, use tags: ["source:alert"].
 
+IMPORTANT \u2014 re-evaluation vs transition:
+  - source:alert events INCLUDE renotifies and re-evaluations (every Datadog re-evaluation of an alerting monitor emits an event). A "how many times did monitor X fire" question answered with source:alert alone over-counts.
+  - To restrict to real state transitions, pass transitionType (e.g. ["alert","alert recovery"]). This appends @monitor.transition.transition_type:(...) to the query and matches the design's live investigation.
+  - For a fires-only numeric count rooted in a single monitor ID, prefer the higher-level primitive monitors action=history \u2014 it returns {transitions, count, meta} with the same filter applied for you.
+
+transitionType: Optional array of monitor transition types (alert, alert recovery, warning, warning recovery, no data, no data recovery, renotify). Empty array is treated as undefined.
 top: Generic event grouping by any fields (groupBy parameter). Returns groups ranked by count with optional context breakdown.
   - Example: {groupBy: ["service"], message: "...", service: "api", total_count: 50, by_context: [{context: "queue:X", count: 30}]}
   - Use for deployments, configs, custom events, or monitor alerts
   - Returns "message" field (event title), NOT monitor name (use monitors tool for real names)
+  - total_count includes renotifies when source:alert is used without transitionType \u2014 see monitors action=history for fires-only counts
 discover: Returns available tag prefixes from events.
 aggregate: Custom groupBy, returns pipe-delimited keys.
 search: Full event details.
@@ -303716,7 +303753,8 @@ incidents: Deduplicate alerts with dedupeWindow.`,
       dedupeWindow,
       enrich,
       contextTags,
-      maxEvents
+      maxEvents,
+      transitionType
     }) => {
       try {
         checkReadOnly(action, readOnly);
@@ -303765,7 +303803,8 @@ incidents: Deduplicate alerts with dedupeWindow.`,
                 tags,
                 priority,
                 limit,
-                cursor
+                cursor,
+                transitionType
               },
               limits,
               site
@@ -303787,7 +303826,8 @@ incidents: Deduplicate alerts with dedupeWindow.`,
                   sources,
                   tags,
                   groupBy,
-                  limit
+                  limit,
+                  transitionType
                 },
                 limits,
                 site
@@ -303806,7 +303846,8 @@ incidents: Deduplicate alerts with dedupeWindow.`,
                   limit,
                   groupBy,
                   contextTags,
-                  maxEvents
+                  maxEvents,
+                  transitionType
                 },
                 limits,
                 site
@@ -303839,7 +303880,8 @@ incidents: Deduplicate alerts with dedupeWindow.`,
                   tags,
                   groupBy,
                   interval,
-                  limit
+                  limit,
+                  transitionType
                 },
                 limits,
                 site
@@ -303856,7 +303898,8 @@ incidents: Deduplicate alerts with dedupeWindow.`,
                   sources,
                   tags,
                   dedupeWindow,
-                  limit
+                  limit,
+                  transitionType
                 },
                 limits,
                 site
@@ -303882,7 +303925,8 @@ var ActionSchema2 = external_exports.enum([
   "delete",
   "mute",
   "unmute",
-  "top"
+  "top",
+  "history"
 ]);
 var InputSchema2 = {
   action: ActionSchema2.describe("Action to perform"),
@@ -303903,8 +303947,117 @@ var InputSchema2 = {
   contextTags: external_exports.array(external_exports.string()).optional().describe(
     "Tag prefixes for context breakdown in top action (default: queue, service, ingress, pod_name, kube_namespace, kube_container_name)"
   ),
-  maxEvents: external_exports.number().min(1).max(5e3).optional().describe("Maximum events to fetch for top action (default: 5000, max: 5000)")
+  maxEvents: external_exports.number().min(1).max(5e3).optional().describe("Maximum events to fetch for top action (default: 5000, max: 5000)"),
+  // History action parameters
+  transitionType: external_exports.array(
+    external_exports.enum([
+      "alert",
+      "alert recovery",
+      "warning",
+      "warning recovery",
+      "no data",
+      "no data recovery",
+      "renotify"
+    ])
+  ).optional().describe(
+    'For history action: filter by monitor state transition types. Default: ["alert","alert recovery"] (real fires + recoveries, excludes renotifies). Pass ["alert"] for fires only, or include "renotify" for full chronological audit.'
+  ),
+  group: external_exports.string().optional().describe(
+    'For history action: filter transitions to a specific multi-alert monitor group (e.g., "pod_name:foo,kube_namespace:bar"). Optional; omit for all groups.'
+  )
 };
+var MonitorThresholdsSchema = external_exports.object({
+  critical: external_exports.number().optional(),
+  warning: external_exports.number().optional(),
+  ok: external_exports.number().optional(),
+  criticalRecovery: external_exports.number().optional(),
+  warningRecovery: external_exports.number().optional(),
+  unknown: external_exports.number().optional()
+}).passthrough();
+var MonitorThresholdWindowsSchema = external_exports.object({
+  triggerWindow: external_exports.string().optional(),
+  recoveryWindow: external_exports.string().optional()
+}).passthrough();
+var SchedulingOptionsSchema = external_exports.object({
+  evaluationWindow: external_exports.record(external_exports.unknown()).optional(),
+  customSchedule: external_exports.record(external_exports.unknown()).optional()
+}).passthrough();
+var MonitorOptionsSchema = external_exports.object({
+  // Notification
+  notifyNoData: external_exports.boolean().optional(),
+  noDataTimeframe: external_exports.number().optional(),
+  notifyAudit: external_exports.boolean().optional(),
+  notificationPresetName: external_exports.string().optional(),
+  // Evaluation / delay
+  newHostDelay: external_exports.number().optional(),
+  newGroupDelay: external_exports.number().optional(),
+  evaluationDelay: external_exports.number().optional(),
+  requireFullWindow: external_exports.boolean().optional(),
+  onMissingData: external_exports.string().optional(),
+  // Renotification
+  renotifyInterval: external_exports.number().nullable().optional(),
+  renotifyOccurrences: external_exports.number().optional(),
+  renotifyStatuses: external_exports.array(external_exports.string()).optional(),
+  escalationMessage: external_exports.string().optional(),
+  // Lifecycle
+  timeoutH: external_exports.number().nullable().optional(),
+  includeTags: external_exports.boolean().optional(),
+  locked: external_exports.boolean().optional(),
+  silenced: external_exports.record(external_exports.number().nullable()).optional(),
+  groupRetentionDuration: external_exports.string().optional(),
+  // Thresholds & scheduling
+  thresholds: MonitorThresholdsSchema.optional(),
+  thresholdWindows: MonitorThresholdWindowsSchema.optional(),
+  schedulingOptions: SchedulingOptionsSchema.optional()
+}).passthrough();
+var MonitorConfigSchema = external_exports.object({
+  name: external_exports.string().optional(),
+  type: external_exports.string().optional(),
+  query: external_exports.string().optional(),
+  message: external_exports.string().optional(),
+  tags: external_exports.array(external_exports.string()).optional(),
+  priority: external_exports.number().int().min(1).max(5).nullable().optional(),
+  restrictedRoles: external_exports.array(external_exports.string()).nullable().optional(),
+  multi: external_exports.boolean().optional(),
+  options: MonitorOptionsSchema.optional()
+}).passthrough();
+var KNOWN_TOP_LEVEL_KEYS = new Set(
+  Object.keys(MonitorConfigSchema.shape).filter((key) => key !== "options")
+);
+var KNOWN_OPTIONS_KEYS = new Set(
+  Object.keys(MonitorOptionsSchema.shape)
+);
+function collectUnknownKeyWarnings(config2) {
+  const warnings = [];
+  for (const key of Object.keys(config2)) {
+    if (!KNOWN_TOP_LEVEL_KEYS.has(key) && key !== "options") {
+      warnings.push(`unknown top-level key '${key}' under config forwarded without validation`);
+    }
+  }
+  const options = config2.options;
+  if (isPlainObject3(options)) {
+    for (const key of Object.keys(options)) {
+      if (!KNOWN_OPTIONS_KEYS.has(key)) {
+        warnings.push(
+          `unknown option key '${key}' under config.options forwarded without validation`
+        );
+      }
+    }
+  }
+  return warnings;
+}
+function isPlainObject3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function summarizeZodIssue(error2) {
+  const issue2 = error2.issues[0];
+  if (!issue2) {
+    return "validation failed";
+  }
+  const path = issue2.path.length > 0 ? issue2.path.join(".") : "<root>";
+  const expected = issue2.code === "invalid_type" && "expected" in issue2 ? `expected ${String(issue2.expected)}` : issue2.message;
+  return `${path}: ${expected}`;
+}
 function formatMonitor(m, site = "datadoghq.com") {
   const monitorId = m.id ?? 0;
   return {
@@ -303936,6 +304089,153 @@ function formatMonitorDetail(m, site = "datadoghq.com") {
   }
   return detail;
 }
+var DEFAULT_HISTORY_TRANSITION_TYPES = [
+  "alert",
+  "alert recovery"
+];
+function quoteIfNeeded2(value) {
+  return /^[A-Za-z0-9_.-]+$/.test(value) ? value : `"${value}"`;
+}
+function buildMonitorHistoryQuery(params) {
+  const parts = ["source:alert", `@monitor.id:${params.monitorId}`];
+  const transitionTypes = params.transitionType && params.transitionType.length > 0 ? params.transitionType : void 0;
+  if (transitionTypes) {
+    const inner = transitionTypes.map(quoteIfNeeded2).join(" OR ");
+    parts.push(`@monitor.transition.transition_type:(${inner})`);
+  }
+  if (params.group && params.group.length > 0) {
+    const escaped = params.group.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+    parts.push(`@monitor.groups:"${escaped}"`);
+  }
+  return parts.join(" ");
+}
+function isMonitorState(value) {
+  return value === "Alert" || value === "Warn" || value === "OK" || value === "No Data";
+}
+function isTransitionType(value) {
+  return value === "alert" || value === "alert recovery" || value === "warning" || value === "warning recovery" || value === "no data" || value === "no data recovery" || value === "renotify";
+}
+function extractTimestamp(outer, inner) {
+  const outerTs = outer.timestamp;
+  if (outerTs instanceof Date) {
+    return outerTs.toISOString();
+  }
+  if (typeof outerTs === "string" && outerTs.length > 0) {
+    const d = new Date(outerTs);
+    if (!Number.isNaN(d.getTime())) return d.toISOString();
+  }
+  const innerTs = inner.timestamp;
+  if (typeof innerTs === "number" && Number.isFinite(innerTs)) {
+    return new Date(innerTs).toISOString();
+  }
+  if (typeof innerTs === "string" && innerTs.length > 0) {
+    const parsed = Number.parseInt(innerTs, 10);
+    if (!Number.isNaN(parsed)) {
+      return new Date(parsed).toISOString();
+    }
+  }
+  return "";
+}
+function formatMonitorTransition(event) {
+  const outer = event.attributes ?? {};
+  const inner = outer.attributes ?? {};
+  const monitor = inner.monitor;
+  if (!monitor) {
+    return null;
+  }
+  const transition = monitor.transition ?? monitor.additionalProperties?.transition;
+  if (!transition) {
+    return null;
+  }
+  const fromState = isMonitorState(transition.source_state) ? transition.source_state : null;
+  const toState = isMonitorState(transition.destination_state) ? transition.destination_state : null;
+  const transitionType = isTransitionType(transition.transition_type) ? transition.transition_type : null;
+  if (!fromState || !toState || !transitionType) {
+    return null;
+  }
+  const groupsRaw = monitor.groups;
+  const group = Array.isArray(groupsRaw) && groupsRaw.length > 0 ? groupsRaw.map((g) => String(g)).join(",") : null;
+  const monitorId = typeof monitor.id === "number" ? monitor.id : 0;
+  const monitorName = typeof monitor.name === "string" && monitor.name.length > 0 ? monitor.name : `Monitor ${monitorId}`;
+  return {
+    timestamp: extractTimestamp(outer, inner),
+    monitorId,
+    monitorName,
+    group,
+    fromState,
+    toState,
+    transitionType,
+    eventId: String(event.id ?? "")
+  };
+}
+async function historyMonitor(eventsApi, monitorId, params, limits, site) {
+  const defaultFrom = hoursAgo(limits.defaultTimeRangeHours);
+  const defaultTo = now();
+  const [validFrom, validTo] = ensureValidTimeRange(
+    parseTime(params.from, defaultFrom),
+    parseTime(params.to, defaultTo)
+  );
+  const fromTime = new Date(validFrom * 1e3).toISOString();
+  const toTime = new Date(validTo * 1e3).toISOString();
+  const effectiveTransitionTypes = params.transitionType && params.transitionType.length > 0 ? params.transitionType : [...DEFAULT_HISTORY_TRANSITION_TYPES];
+  const query = buildMonitorHistoryQuery({
+    monitorId,
+    transitionType: effectiveTransitionTypes,
+    group: params.group
+  });
+  const transitions = [];
+  const maxEventsToProcess = 1e4;
+  const maxPages = 100;
+  let eventCount = 0;
+  let pageCount = 0;
+  const body = {
+    filter: {
+      query,
+      from: fromTime,
+      to: toTime
+    },
+    sort: "timestamp",
+    page: { limit: 1e3 }
+  };
+  let cursor;
+  while (pageCount < maxPages && eventCount < maxEventsToProcess) {
+    const pageBody = { ...body, page: { ...body.page, cursor } };
+    const response = await eventsApi.searchEvents({ body: pageBody });
+    const events = response.data ?? [];
+    if (events.length === 0) break;
+    for (const event of events) {
+      const transition = formatMonitorTransition(event);
+      if (transition !== null) {
+        transitions.push(transition);
+      }
+      eventCount++;
+      if (eventCount >= maxEventsToProcess) break;
+    }
+    cursor = response.meta?.page?.after;
+    if (!cursor) break;
+    pageCount++;
+  }
+  const truncated = eventCount >= maxEventsToProcess;
+  const resolvedGroup = params.group && params.group.length > 0 ? params.group : null;
+  const count = transitions.length;
+  const meta = {
+    monitorId,
+    query,
+    from: fromTime,
+    to: toTime,
+    transitionTypes: effectiveTransitionTypes,
+    group: resolvedGroup,
+    count,
+    totalFetched: eventCount,
+    truncated,
+    datadog_url: buildEventsUrl(query, validFrom, validTo, site)
+  };
+  return {
+    transitions,
+    count,
+    meta
+  };
+}
 async function listMonitors(api, params, limits, site) {
   const effectiveLimit = params.limit ?? limits.defaultLimit;
   const response = await api.listMonitors({
@@ -304012,6 +304312,11 @@ function normalizeMonitorConfig(config2, isUpdate = false) {
       ["include_tags", "includeTags"],
       ["require_full_window", "requireFullWindow"],
       ["escalation_message", "escalationMessage"],
+      ["notification_preset_name", "notificationPresetName"],
+      ["on_missing_data", "onMissingData"],
+      ["group_retention_duration", "groupRetentionDuration"],
+      ["threshold_windows", "thresholdWindows"],
+      ["scheduling_options", "schedulingOptions"],
       ["locked", "locked"],
       ["silenced", "silenced"]
     ];
@@ -304043,21 +304348,49 @@ function normalizeMonitorConfig(config2, isUpdate = false) {
   return normalized;
 }
 async function createMonitor(api, config2, site = "datadoghq.com") {
-  const body = normalizeMonitorConfig(config2);
+  const normalized = normalizeMonitorConfig(config2);
+  try {
+    MonitorConfigSchema.parse(normalized);
+  } catch (error2) {
+    if (error2 instanceof external_exports.ZodError) {
+      throw new Error(`EINVALID_MONITOR_CONFIG: ${summarizeZodIssue(error2)}`);
+    }
+    throw error2;
+  }
+  const warnings = collectUnknownKeyWarnings(normalized);
+  const body = normalized;
   const monitor = await api.createMonitor({ body });
-  return {
+  const result = {
     success: true,
     monitor: formatMonitorDetail(monitor, site)
   };
+  if (warnings.length > 0) {
+    result.warnings = warnings;
+  }
+  return result;
 }
 async function updateMonitor(api, id, config2, site = "datadoghq.com") {
   const monitorId = Number.parseInt(id, 10);
-  const body = normalizeMonitorConfig(config2, true);
+  const normalized = normalizeMonitorConfig(config2, true);
+  try {
+    MonitorConfigSchema.parse(normalized);
+  } catch (error2) {
+    if (error2 instanceof external_exports.ZodError) {
+      throw new Error(`EINVALID_MONITOR_CONFIG: ${summarizeZodIssue(error2)}`);
+    }
+    throw error2;
+  }
+  const warnings = collectUnknownKeyWarnings(normalized);
+  const body = normalized;
   const monitor = await api.updateMonitor({ monitorId, body });
-  return {
+  const result = {
     success: true,
     monitor: formatMonitorDetail(monitor, site)
   };
+  if (warnings.length > 0) {
+    result.warnings = warnings;
+  }
+  return result;
 }
 async function deleteMonitor(api, id) {
   const monitorId = Number.parseInt(id, 10);
@@ -304210,16 +304543,47 @@ async function topMonitors(eventsApi, monitorsApi, params, limits, site) {
 function registerMonitorsTool(server, api, eventsApi, limits, readOnly = false, site = "datadoghq.com") {
   server.tool(
     "monitors",
-    `Manage Datadog monitors. Actions: list, get, search, create, update, delete, mute, unmute, top.
+    `Manage Datadog monitors. Actions: list, get, search, create, update, delete, mute, unmute, top, history.
 Filters: name, tags, groupStates (alert/warn/ok/no data).
-get/create/update return the full options object (notify_no_data, renotify_interval, thresholds, etc.) so callers can safely read-then-patch.
+get/create/update return the full options object so callers can safely read-then-patch.
+
+create/update accept a config object validated against a typed schema covering the documented Datadog Monitor fields:
+  - Top-level: name, type, query, message, tags, priority (1-5, nullable), restrictedRoles, multi, options.
+  - options.* validated keys grouped by category:
+    - notification:    notifyNoData, noDataTimeframe, notifyAudit, notificationPresetName.
+    - evaluation/delay: newHostDelay, newGroupDelay, evaluationDelay, requireFullWindow, onMissingData.
+    - renotification:  renotifyInterval (nullable), renotifyOccurrences, renotifyStatuses, escalationMessage.
+    - lifecycle:       timeoutH (nullable), includeTags, locked, silenced (record of timestamps/null), groupRetentionDuration.
+    - thresholds:      thresholds (critical/warning/ok/criticalRecovery/warningRecovery/unknown), thresholdWindows.
+    - scheduling:      schedulingOptions.
+Unknown keys (top-level or under options) are forwarded to Datadog as-is and surfaced via an optional warnings array on the response, so the schema does not lag the API.
+snake_case aliases are accepted on input and normalized to camelCase before validation.
+Validation errors short-circuit before any HTTP call and surface as 'EINVALID_MONITOR_CONFIG: <path>: <expected>'.
+Reference: https://docs.datadoghq.com/api/latest/monitors/
 
 top: Ranked monitors by alert frequency with real monitor names and context breakdown.
   - Returns: {rank, monitor_id, name (with {{template.vars}}), message (template), total_count, by_context}
   - Perfect for weekly/daily alert reports
   - Gets real monitor names from monitors API (not event titles)
-
-For generic event grouping (deployments, configs), use events tool instead.`,
+  - WARNING: total_count is the raw alert-event count and INCLUDES renotifies/re-evaluations.
+    For monitors stuck in Alert state, Datadog emits a renotify event every renotify_interval
+    minutes, which inflates this count well beyond the number of real fires. When the question
+    is "how many times did this monitor actually fire", use action=history instead.
+
+history: Count and list real state transitions for one monitor over a time window.
+  - Inputs: id (required, monitor ID), from/to (optional time range), transitionType (optional
+    filter, defaults to ["alert","alert recovery"]), group (optional multi-alert group filter).
+  - Returns: {transitions: [{timestamp, monitorId, monitorName, group, fromState, toState,
+    transitionType, eventId}], count, meta}
+  - count = transitions.length \u2014 the number of REAL state changes (fires + recoveries by
+    default), NOT the renotify-inflated count returned by action=top or events action=search.
+  - Backed by Datadog v2 events search with a hardcoded source:alert + @monitor.transition.
+    transition_type filter that excludes renotifies by default. To include renotifies, pass
+    transitionType including "renotify".
+
+For generic event grouping (deployments, configs), use events tool instead. Note that the
+events tool's action=search with source:alert ALSO includes renotifies; use its
+transitionType filter (or this action=history) for fires-only counts.`,
     InputSchema2,
     async ({
       action,
@@ -304234,7 +304598,9 @@ For generic event grouping (deployments, configs), use events tool instead.`,
       from,
       to,
       contextTags,
-      maxEvents
+      maxEvents,
+      transitionType,
+      group
     }) => {
       try {
         checkReadOnly(action, readOnly);
@@ -304289,6 +304655,22 @@ For generic event grouping (deployments, configs), use events tool instead.`,
                 site
               )
             );
+          case "history": {
+            const monitorIdString = requireParam(id, "id", "history");
+            const monitorId = Number.parseInt(monitorIdString, 10);
+            if (Number.isNaN(monitorId)) {
+              throw new Error(`Invalid monitor ID: ${monitorIdString}`);
+            }
+            return toolResult(
+              await historyMonitor(
+                eventsApi,
+                monitorId,
+                { from, to, transitionType, group },
+                limits,
+                site
+              )
+            );
+          }
           default:
             throw new Error(`Unknown action: ${action}`);
         }
@@ -305584,6 +305966,22 @@ function registerIncidentsTool(server, api, limits, readOnly = false, _site = "d
   );
 }
 
+// src/utils/normalize.ts
+function snakeToCamel2(str) {
+  return str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+}
+function normalizeConfigKeys(obj) {
+  if (obj === null || obj === void 0) return obj;
+  if (Array.isArray(obj)) return obj.map(normalizeConfigKeys);
+  if (typeof obj !== "object") return obj;
+  const normalized = {};
+  for (const [key, value] of Object.entries(obj)) {
+    const camelKey = snakeToCamel2(key);
+    normalized[camelKey] = normalizeConfigKeys(value);
+  }
+  return normalized;
+}
+
 // src/tools/slos.ts
 var ActionSchema8 = external_exports.enum(["list", "get", "create", "update", "delete", "history"]);
 var InputSchema8 = {
@@ -305599,7 +305997,7 @@ var InputSchema8 = {
 };
 function formatSlo(s) {
   const primaryThreshold = s.thresholds?.[0];
-  return {
+  const summary = {
     id: s.id ?? "",
     name: s.name ?? "",
     description: s.description ?? null,
@@ -305617,11 +306015,24 @@ function formatSlo(s) {
     createdAt: s.createdAt ? new Date(s.createdAt * 1e3).toISOString() : "",
     modifiedAt: s.modifiedAt ? new Date(s.modifiedAt * 1e3).toISOString() : ""
   };
+  if (s.query?.numerator && s.query.denominator) {
+    summary.query = { numerator: s.query.numerator, denominator: s.query.denominator };
+  }
+  if (Array.isArray(s.monitorIds) && s.monitorIds.length > 0) {
+    summary.monitorIds = s.monitorIds;
+  }
+  if (Array.isArray(s.monitorTags) && s.monitorTags.length > 0) {
+    summary.monitorTags = s.monitorTags;
+  }
+  if (Array.isArray(s.groups) && s.groups.length > 0) {
+    summary.groups = s.groups;
+  }
+  return summary;
 }
 function formatSearchSlo(slo) {
   const attrs = slo.data?.attributes;
   const primaryThreshold = attrs?.thresholds?.[0];
-  return {
+  const summary = {
     id: slo.data?.id ?? "",
     name: attrs?.name ?? "",
     description: attrs?.description ?? null,
@@ -305645,6 +306056,16 @@ function formatSearchSlo(slo) {
     createdAt: attrs?.createdAt ? new Date(attrs.createdAt * 1e3).toISOString() : "",
     modifiedAt: attrs?.modifiedAt ? new Date(attrs.modifiedAt * 1e3).toISOString() : ""
   };
+  if (attrs?.query?.numerator && attrs.query.denominator) {
+    summary.query = { numerator: attrs.query.numerator, denominator: attrs.query.denominator };
+  }
+  if (Array.isArray(attrs?.monitorIds) && attrs.monitorIds.length > 0) {
+    summary.monitorIds = attrs.monitorIds;
+  }
+  if (Array.isArray(attrs?.groups) && attrs.groups.length > 0) {
+    summary.groups = attrs.groups;
+  }
+  return summary;
 }
 function buildSearchQuery(query, tags) {
   const parts = [];
@@ -305680,20 +306101,6 @@ async function getSlo(api, id) {
     slo: response.data ? formatSlo(response.data) : null
   };
 }
-function snakeToCamel2(str) {
-  return str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
-}
-function normalizeConfigKeys(obj) {
-  if (obj === null || obj === void 0) return obj;
-  if (Array.isArray(obj)) return obj.map(normalizeConfigKeys);
-  if (typeof obj !== "object") return obj;
-  const normalized = {};
-  for (const [key, value] of Object.entries(obj)) {
-    const camelKey = snakeToCamel2(key);
-    normalized[camelKey] = normalizeConfigKeys(value);
-  }
-  return normalized;
-}
 function normalizeSloConfig(config2) {
   const normalized = normalizeConfigKeys(config2);
   if (!normalized.name) {
@@ -307944,6 +308351,488 @@ function registerSchemaTool(server) {
   );
 }
 
+// src/tools/logs_pipelines.ts
+var ActionSchema20 = external_exports.enum(["list", "get", "create", "update", "delete", "reorder", "get_order"]);
+var InputSchema21 = {
+  action: ActionSchema20.describe("Action to perform"),
+  id: external_exports.string().optional().describe("Pipeline ID (required for get/update/delete)"),
+  config: external_exports.record(external_exports.unknown()).optional().describe(
+    "Pipeline configuration (for create/update). Requires name and filter.query. Processors are forwarded unchanged."
+  ),
+  pipeline_ids: external_exports.array(external_exports.string()).optional().describe("Ordered pipeline ID list (required for reorder)"),
+  verbose: external_exports.boolean().optional().describe("Return full SDK payload alongside summary (default false)")
+};
+function formatPipeline(p, verbose = false) {
+  const summary = {
+    id: p.id ?? "",
+    name: p.name ?? "",
+    filterQuery: p.filter?.query ?? null,
+    isEnabled: p.isEnabled ?? false,
+    isReadOnly: p.isReadOnly ?? false,
+    type: p.type ?? null,
+    processorsCount: p.processors?.length ?? 0
+  };
+  if (verbose && p.processors) {
+    summary.processors = p.processors;
+  }
+  return summary;
+}
+function normalizePipelineConfig(config2) {
+  const normalized = normalizeConfigKeys(config2);
+  if (!normalized.name) {
+    throw new Error("Pipeline config requires 'name' field");
+  }
+  const filter = normalized.filter;
+  if (!filter || typeof filter.query !== "string" || filter.query.length === 0) {
+    throw new Error("Pipeline config requires 'filter.query' field");
+  }
+  return normalized;
+}
+async function listPipelines(api, verbose = false) {
+  const response = await api.listLogsPipelines();
+  const pipelines = (response ?? []).map((p) => formatPipeline(p, verbose));
+  const result = { pipelines, total: pipelines.length };
+  if (verbose) {
+    result.raw = response;
+  }
+  return result;
+}
+async function getPipeline(api, id, verbose = false) {
+  const response = await api.getLogsPipeline({ pipelineId: id });
+  const result = { pipeline: formatPipeline(response, verbose) };
+  if (verbose) {
+    result.raw = response;
+  }
+  return result;
+}
+async function createPipeline(api, config2, verbose = false) {
+  const body = normalizePipelineConfig(config2);
+  const response = await api.createLogsPipeline({ body });
+  const result = {
+    success: true,
+    pipeline: formatPipeline(response, verbose)
+  };
+  if (verbose) {
+    result.raw = response;
+  }
+  return result;
+}
+async function updatePipeline(api, id, config2, verbose = false) {
+  const body = normalizePipelineConfig(config2);
+  const response = await api.updateLogsPipeline({ pipelineId: id, body });
+  const result = {
+    success: true,
+    pipeline: formatPipeline(response, verbose)
+  };
+  if (verbose) {
+    result.raw = response;
+  }
+  return result;
+}
+async function deletePipeline(api, id) {
+  await api.deleteLogsPipeline({ pipelineId: id });
+  return {
+    success: true,
+    message: `Pipeline ${id} deleted`
+  };
+}
+async function reorderPipelines(api, pipelineIds) {
+  const body = { pipelineIds };
+  const response = await api.updateLogsPipelineOrder({ body });
+  return {
+    success: true,
+    order: {
+      pipelineIds: response.pipelineIds ?? []
+    }
+  };
+}
+async function getPipelineOrder(api) {
+  const response = await api.getLogsPipelineOrder();
+  return {
+    order: {
+      pipelineIds: response.pipelineIds ?? []
+    }
+  };
+}
+function registerLogsPipelinesTool(server, api, _limits, readOnly = false, _site = "datadoghq.com") {
+  server.tool(
+    "logs_pipelines",
+    "Manage Datadog Logs pipelines (parsing & processor chains). Actions: list, get, create, update, delete, reorder, get_order. Pipelines run sequentially on incoming logs; reorder changes the structure of downstream data. Mutations are blocked when the server is in read-only mode. Unknown processor types in 'config.processors' are forwarded to Datadog unchanged.",
+    InputSchema21,
+    async ({ action, id, config: config2, pipeline_ids, verbose }) => {
+      try {
+        checkReadOnly(action, readOnly);
+        const isVerbose = verbose ?? false;
+        switch (action) {
+          case "list":
+            return toolResult(await listPipelines(api, isVerbose));
+          case "get": {
+            const pipelineId = requireParam(id, "id", "get");
+            return toolResult(await getPipeline(api, pipelineId, isVerbose));
+          }
+          case "create": {
+            const pipelineConfig = requireParam(config2, "config", "create");
+            return toolResult(await createPipeline(api, pipelineConfig, isVerbose));
+          }
+          case "update": {
+            const pipelineId = requireParam(id, "id", "update");
+            const pipelineConfig = requireParam(config2, "config", "update");
+            return toolResult(await updatePipeline(api, pipelineId, pipelineConfig, isVerbose));
+          }
+          case "delete": {
+            const pipelineId = requireParam(id, "id", "delete");
+            return toolResult(await deletePipeline(api, pipelineId));
+          }
+          case "reorder": {
+            const ids = requireParam(pipeline_ids, "pipeline_ids", "reorder");
+            return toolResult(await reorderPipelines(api, ids));
+          }
+          case "get_order":
+            return toolResult(await getPipelineOrder(api));
+          default:
+            throw new Error(`Unknown action: ${String(action)}`);
+        }
+      } catch (error2) {
+        handleDatadogError(error2);
+      }
+    }
+  );
+}
+
+// src/tools/logs_indexes.ts
+var ActionSchema21 = external_exports.enum(["list", "get", "update", "reorder", "get_order"]);
+var InputSchema22 = {
+  action: ActionSchema21.describe("Action to perform"),
+  name: external_exports.string().optional().describe("Index name (required for get/update). Datadog identifies indexes by name, not id."),
+  config: external_exports.record(external_exports.unknown()).optional().describe(
+    "Index configuration (for update). Requires filter.query and numRetentionDays. Exclusion filters are forwarded unchanged."
+  ),
+  index_names: external_exports.array(external_exports.string()).optional().describe("Ordered index name list (required for reorder)"),
+  verbose: external_exports.boolean().optional().describe("Return full SDK payload alongside summary (default false)")
+};
+function formatIndex(idx, verbose = false) {
+  const summary = {
+    name: idx.name ?? "",
+    filterQuery: idx.filter?.query ?? null,
+    exclusionFiltersCount: idx.exclusionFilters?.length ?? 0,
+    numRetentionDays: idx.numRetentionDays ?? null,
+    numFlexLogsRetentionDays: idx.numFlexLogsRetentionDays ?? null,
+    dailyLimit: idx.dailyLimit ?? null,
+    isRateLimited: idx.isRateLimited ?? false
+  };
+  if (verbose && idx.exclusionFilters) {
+    summary.exclusionFilters = idx.exclusionFilters;
+  }
+  return summary;
+}
+function normalizeIndexConfig(config2) {
+  const normalized = normalizeConfigKeys(config2);
+  const filter = normalized.filter;
+  if (!filter || typeof filter.query !== "string" || filter.query.length === 0) {
+    throw new Error("Index config requires 'filter.query' field");
+  }
+  if (typeof normalized.numRetentionDays !== "number") {
+    throw new Error("Index config requires 'numRetentionDays' field");
+  }
+  return normalized;
+}
+async function listIndexes(api, verbose = false) {
+  const response = await api.listLogIndexes();
+  const indexes = (response.indexes ?? []).map((idx) => formatIndex(idx, verbose));
+  const result = { indexes, total: indexes.length };
+  if (verbose) {
+    result.raw = response;
+  }
+  return result;
+}
+async function getIndex(api, name, verbose = false) {
+  const response = await api.getLogsIndex({ name });
+  const result = { index: formatIndex(response, verbose) };
+  if (verbose) {
+    result.raw = response;
+  }
+  return result;
+}
+async function updateIndex(api, name, config2, verbose = false) {
+  const body = normalizeIndexConfig(config2);
+  const response = await api.updateLogsIndex({ name, body });
+  const result = {
+    success: true,
+    index: formatIndex(response, verbose)
+  };
+  if (verbose) {
+    result.raw = response;
+  }
+  return result;
+}
+async function reorderIndexes(api, indexNames) {
+  const body = { indexNames };
+  const response = await api.updateLogsIndexOrder({ body });
+  return {
+    success: true,
+    order: {
+      indexNames: response.indexNames ?? []
+    }
+  };
+}
+async function getIndexOrder(api) {
+  const response = await api.getLogsIndexOrder();
+  return {
+    order: {
+      indexNames: response.indexNames ?? []
+    }
+  };
+}
+function registerLogsIndexesTool(server, api, _limits, readOnly = false, _site = "datadoghq.com") {
+  server.tool(
+    "logs_indexes",
+    "Manage Datadog Logs indexes (filters, retention, exclusion filters, daily limits). Actions: list, get, update, reorder, get_order. Datadog identifies indexes by 'name', not 'id'. Note: create/delete are UI-only per Datadog and not supported through the API. Mutations (update, reorder) are blocked when the server is in read-only mode.",
+    InputSchema22,
+    async ({ action, name, config: config2, index_names, verbose }) => {
+      try {
+        checkReadOnly(action, readOnly);
+        const isVerbose = verbose ?? false;
+        switch (action) {
+          case "list":
+            return toolResult(await listIndexes(api, isVerbose));
+          case "get": {
+            const indexName = requireParam(name, "name", "get");
+            return toolResult(await getIndex(api, indexName, isVerbose));
+          }
+          case "update": {
+            const indexName = requireParam(name, "name", "update");
+            const indexConfig = requireParam(config2, "config", "update");
+            return toolResult(await updateIndex(api, indexName, indexConfig, isVerbose));
+          }
+          case "reorder": {
+            const names = requireParam(index_names, "index_names", "reorder");
+            return toolResult(await reorderIndexes(api, names));
+          }
+          case "get_order":
+            return toolResult(await getIndexOrder(api));
+          default:
+            throw new Error(`Unknown action: ${String(action)}`);
+        }
+      } catch (error2) {
+        handleDatadogError(error2);
+      }
+    }
+  );
+}
+
+// src/tools/logs_archives.ts
+var ActionSchema22 = external_exports.enum(["list", "get", "create", "update", "delete", "reorder", "get_order"]);
+var InputSchema23 = {
+  action: ActionSchema22.describe("Action to perform"),
+  id: external_exports.string().optional().describe("Archive ID (required for get/update/delete)"),
+  config: external_exports.record(external_exports.unknown()).optional().describe(
+    "Archive configuration (for create/update). Requires name, query, and destination with type \u2208 { s3, gcs, azure_storage }. Provider credential / integration fields are forwarded unchanged."
+  ),
+  archive_ids: external_exports.array(external_exports.string()).optional().describe("Ordered archive ID list (required for reorder)"),
+  verbose: external_exports.boolean().optional().describe("Return full SDK payload alongside summary (default false)")
+};
+var VALID_DESTINATION_TYPES = ["s3", "gcs", "azure_storage"];
+function extractDestinationContainer(destination) {
+  if (!destination || typeof destination !== "object") return null;
+  const dest = destination;
+  if (typeof dest.bucket === "string") return dest.bucket;
+  if (typeof dest.container === "string") return dest.container;
+  return null;
+}
+function formatArchive(archive, verbose = false) {
+  const attrs = archive.attributes;
+  const destination = attrs?.destination ?? null;
+  const destinationType = destination && typeof destination === "object" && "type" in destination ? String(destination.type ?? "") : "";
+  const summary = {
+    id: archive.id ?? "",
+    name: attrs?.name ?? "",
+    query: attrs?.query ?? null,
+    destinationType,
+    destinationContainer: extractDestinationContainer(destination),
+    includeTags: attrs?.includeTags ?? false,
+    rehydrationTags: attrs?.rehydrationTags ?? [],
+    state: attrs?.state ?? null
+  };
+  if (verbose && destination) {
+    summary.destination = destination;
+  }
+  return summary;
+}
+function normalizeArchiveConfig(config2) {
+  const normalized = normalizeConfigKeys(config2);
+  if (typeof normalized.name !== "string" || normalized.name.length === 0) {
+    throw new Error("Archive config requires 'name' field");
+  }
+  if (typeof normalized.query !== "string" || normalized.query.length === 0) {
+    throw new Error("Archive config requires 'query' field");
+  }
+  const destination = normalized.destination;
+  if (!destination || typeof destination !== "object") {
+    throw new Error("Archive config requires 'destination' object");
+  }
+  const destinationType = destination.type;
+  if (typeof destinationType !== "string" || !VALID_DESTINATION_TYPES.includes(destinationType)) {
+    throw new Error("destination.type must be one of: s3, gcs, azure_storage");
+  }
+  if (destinationType === "azure_storage") {
+    ;
+    destination.type = "azure";
+  }
+  return normalized;
+}
+function buildArchiveRequestBody(normalizedConfig) {
+  const { name, query, destination, includeTags, rehydrationTags, rehydrationMaxScanSizeInGb } = normalizedConfig;
+  const attributes = {
+    name,
+    query,
+    destination
+  };
+  if (includeTags !== void 0) attributes.includeTags = includeTags;
+  if (rehydrationTags !== void 0) attributes.rehydrationTags = rehydrationTags;
+  if (rehydrationMaxScanSizeInGb !== void 0) {
+    attributes.rehydrationMaxScanSizeInGb = rehydrationMaxScanSizeInGb;
+  }
+  return {
+    data: {
+      type: "archives",
+      attributes
+    }
+  };
+}
+async function listArchives(api, verbose = false) {
+  const response = await api.listLogsArchives();
+  const archives = (response.data ?? []).map((archive) => formatArchive(archive, verbose));
+  const result = { archives, total: archives.length };
+  if (verbose) {
+    result.raw = response;
+  }
+  return result;
+}
+async function getArchive(api, id, verbose = false) {
+  const response = await api.getLogsArchive({ archiveId: id });
+  const archive = response.data;
+  if (!archive) {
+    throw new Error(`Archive ${id} returned an empty payload`);
+  }
+  const result = { archive: formatArchive(archive, verbose) };
+  if (verbose) {
+    result.raw = response;
+  }
+  return result;
+}
+async function createArchive(api, config2, verbose = false) {
+  const normalized = normalizeArchiveConfig(config2);
+  const body = buildArchiveRequestBody(normalized);
+  const response = await api.createLogsArchive({ body });
+  const archive = response.data;
+  if (!archive) {
+    throw new Error("Archive creation returned an empty payload");
+  }
+  const result = {
+    success: true,
+    archive: formatArchive(archive, verbose)
+  };
+  if (verbose) {
+    result.raw = response;
+  }
+  return result;
+}
+async function updateArchive(api, id, config2, verbose = false) {
+  const normalized = normalizeArchiveConfig(config2);
+  const body = buildArchiveRequestBody(normalized);
+  const response = await api.updateLogsArchive({ archiveId: id, body });
+  const archive = response.data;
+  if (!archive) {
+    throw new Error(`Archive ${id} update returned an empty payload`);
+  }
+  const result = {
+    success: true,
+    archive: formatArchive(archive, verbose)
+  };
+  if (verbose) {
+    result.raw = response;
+  }
+  return result;
+}
+async function deleteArchive(api, id) {
+  await api.deleteLogsArchive({ archiveId: id });
+  return {
+    success: true,
+    message: `Archive ${id} deleted`
+  };
+}
+async function reorderArchives(api, archiveIds) {
+  const body = {
+    data: {
+      type: "archive_order",
+      attributes: {
+        archiveIds
+      }
+    }
+  };
+  const response = await api.updateLogsArchiveOrder({ body });
+  const resultIds = response.data?.attributes?.archiveIds ?? [];
+  return {
+    success: true,
+    order: {
+      archiveIds: resultIds
+    }
+  };
+}
+async function getArchiveOrder(api) {
+  const response = await api.getLogsArchiveOrder();
+  const resultIds = response.data?.attributes?.archiveIds ?? [];
+  return {
+    order: {
+      archiveIds: resultIds
+    }
+  };
+}
+function registerLogsArchivesTool(server, api, _limits, readOnly = false, _site = "datadoghq.com") {
+  server.tool(
+    "logs_archives",
+    "Manage Datadog Logs archives (long-term log retention to S3 / GCS / Azure Blob). Actions: list, get, create, update, delete, reorder, get_order. Archives accept destinations of type 's3', 'gcs', or 'azure_storage'; per-provider credential and integration fields (S3 IAM role ARN, GCS service account, Azure tenant/secret) are forwarded unchanged. Mutations (create, update, delete, reorder) are blocked when the server is in read-only mode.",
+    InputSchema23,
+    async ({ action, id, config: config2, archive_ids, verbose }) => {
+      try {
+        checkReadOnly(action, readOnly);
+        const isVerbose = verbose ?? false;
+        switch (action) {
+          case "list":
+            return toolResult(await listArchives(api, isVerbose));
+          case "get": {
+            const archiveId = requireParam(id, "id", "get");
+            return toolResult(await getArchive(api, archiveId, isVerbose));
+          }
+          case "create": {
+            const archiveConfig = requireParam(config2, "config", "create");
+            return toolResult(await createArchive(api, archiveConfig, isVerbose));
+          }
+          case "update": {
+            const archiveId = requireParam(id, "id", "update");
+            const archiveConfig = requireParam(config2, "config", "update");
+            return toolResult(await updateArchive(api, archiveId, archiveConfig, isVerbose));
+          }
+          case "delete": {
+            const archiveId = requireParam(id, "id", "delete");
+            return toolResult(await deleteArchive(api, archiveId));
+          }
+          case "reorder": {
+            const ids = requireParam(archive_ids, "archive_ids", "reorder");
+            return toolResult(await reorderArchives(api, ids));
+          }
+          case "get_order":
+            return toolResult(await getArchiveOrder(api));
+          default:
+            throw new Error(`Unknown action: ${String(action)}`);
+        }
+      } catch (error2) {
+        handleDatadogError(error2);
+      }
+    }
+  );
+}
+
 // src/tools/index.ts
 function registerAllTools(server, clients, limits, features, site = "datadoghq.com", datadogConfig) {
   const { readOnly, disabledTools } = features;
@@ -307958,6 +308847,12 @@ function registerAllTools(server, clients, limits, features, site = "datadoghq.c
   if (enabled("dashboards"))
     registerDashboardsTool(server, clients.dashboards, limits, readOnly, credentials);
   if (enabled("logs")) registerLogsTool(server, clients.logs, limits, site);
+  if (enabled("logs_pipelines"))
+    registerLogsPipelinesTool(server, clients.logsPipelines, limits, readOnly, site);
+  if (enabled("logs_indexes"))
+    registerLogsIndexesTool(server, clients.logsIndexes, limits, readOnly, site);
+  if (enabled("logs_archives"))
+    registerLogsArchivesTool(server, clients.logsArchives, limits, readOnly, site);
   if (enabled("metrics"))
     registerMetricsTool(server, clients.metricsV1, clients.metricsV2, limits, site);
   if (enabled("traces")) registerTracesTool(server, clients.spans, clients.services, limits, site);