datadog-mcp 5.4.0 → 5.5.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)) {
@@ -303905,6 +303909,98 @@ var InputSchema2 = {
   ),
   maxEvents: external_exports.number().min(1).max(5e3).optional().describe("Maximum events to fetch for top action (default: 5000, max: 5000)")
 };
+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 {
@@ -304012,6 +304108,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 +304144,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);
@@ -304212,7 +304341,21 @@ function registerMonitorsTool(server, api, eventsApi, limits, readOnly = false,
     "monitors",
     `Manage Datadog monitors. Actions: list, get, search, create, update, delete, mute, unmute, top.
 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}
@@ -305584,6 +305727,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 +305758,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 +305776,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 +305817,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 +305862,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 +308112,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 +308608,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);