@cdxgen/cdxgen 13.0.1 → 13.2.0

package/lib/inventory/aiCollector.js

@@ -1,5 +1,5 @@
 import { readFileSync, statSync } from "node:fs";
-import { basename, dirname, extname, relative } from "node:path";
+import { basename, dirname, extname, join, relative } from "node:path";
 
 import { getAllFiles } from "../core/fs.js";
 import {
@@ -31,6 +31,8 @@ import {
   toHuggingFacePurl,
 } from "../parsers/huggingfaceUtils.js";
 import { parseOllamaModelfile } from "../parsers/ollama.js";
+import { readOnnxHeader } from "../parsers/onnx.js";
+import { readSafetensorsHeader } from "../parsers/safetensors.js";
 import {
   detectAiModelVariants,
   normalizeDetectedVariants,
@@ -52,6 +54,40 @@ const PROMPT_CONFIG_PATTERNS = [
 ];
 const MODEFILE_PATTERNS = ["Modelfile", "**/Modelfile", "**/Modelfile.*"];
 const GGUF_PATTERNS = ["**/*.gguf"];
+const SAFETENSORS_PATTERNS = ["**/*.safetensors"];
+const ONNX_PATTERNS = ["**/*.onnx"];
+// PyTorch pickle-based checkpoints. Loading these executes arbitrary code, so
+// they are inventoried and flagged rather than parsed. The `.pth` extension is
+// intentionally excluded: in the wild it is overwhelmingly the Python
+// path-configuration file (site-packages shims), not a PyTorch checkpoint.
+const PICKLE_MODEL_PATTERNS = ["**/*.{bin,pt,ckpt}"];
+// Directories whose contents are never real model artifacts. Filtering these
+// keeps the expensive `**/*.bin` walk from surfacing dependency payloads.
+const MODEL_ARTIFACT_IGNORE_DIRS = [
+  "site-packages",
+  "node_modules",
+  "vendor",
+  "dist-packages",
+  ".venv",
+  "venv",
+];
+// A real checkpoint is not a few bytes. Anything smaller is a shim or stub.
+const MIN_PICKLE_MODEL_BYTES = 4096;
+
+/**
+ * Whether a discovered artifact path sits inside a dependency payload
+ * directory. Weights vendored under a dependency tree belong to that
+ * dependency, not to the project being scanned.
+ *
+ * @param {string} filePath Discovered file path
+ * @returns {boolean} true when the path should be skipped
+ */
+const isVendoredArtifactPath = (filePath) => {
+  const normalized = String(filePath).replaceAll("\\", "/");
+  return MODEL_ARTIFACT_IGNORE_DIRS.some((segment) =>
+    normalized.includes(`/${segment}/`),
+  );
+};
 const GGUF_MIN_ALIGNMENT = 4;
 const GGUF_MAX_ALIGNMENT = 1024 * 1024;
 const IGNORE_SOURCE_FILE_PATTERN =
@@ -72,10 +108,35 @@ const HOST_PROVIDER_PATTERNS = [
   ["replicate", /(?:^|\.)replicate\.com$/iu],
   ["perplexity", /(?:^|\.)perplexity\.ai$/iu],
   ["vertex-ai", /(?:^|\.)aiplatform\.googleapis\.com$/iu],
+  ["xai", /(?:^|\.)x\.ai$/iu],
+  [
+    "aws-bedrock",
+    /(?:^|\.)bedrock(?:-runtime)?(?:\.[a-z0-9-]+)?\.amazonaws\.com$/iu,
+  ],
+  ["openrouter", /(?:^|\.)openrouter\.ai$/iu],
+  ["cerebras", /(?:^|\.)cerebras\.ai$/iu],
+  ["sambanova", /(?:^|\.)sambanova\.ai$/iu],
+  ["moonshot", /(?:^|\.)moonshot\.(?:cn|ai)$/iu],
+  ["zhipu", /(?:^|\.)bigmodel\.cn$/iu],
+  ["dashscope", /(?:^|\.)dashscope(?:-intl)?\.aliyuncs\.com$/iu],
+  ["nvidia-nim", /(?:^|\.)api\.nvidia\.com$/iu],
+  ["baseten", /(?:^|\.)baseten\.co$/iu],
+  ["novita", /(?:^|\.)novita\.ai$/iu],
+  ["deepinfra", /(?:^|\.)deepinfra\.com$/iu],
   ["ollama", /(?:^|\.)ollama\.com$/iu],
-  ["ollama", /(?:^|\.)localhost$/iu],
-  ["ollama", /(?:^|\.)127\.0\.0\.1$/iu],
 ];
+// Local inference servers are distinguished by their conventional loopback
+// port rather than by hostname, since they all bind to localhost. When the
+// port is unknown, the endpoint is labeled `local-inference` and marked for
+// review instead of being guessed as any single tool.
+const LOCAL_INFERENCE_PORTS = new Map([
+  ["1234", "lm-studio"],
+  ["8000", "vllm"],
+  ["8080", "llamafile"],
+  ["1337", "jan"],
+  ["4891", "gpt4all"],
+  ["11434", "ollama"],
+]);
 const AI_PACKAGE_REGISTRY = [
   { pattern: /^openai$/u, provider: "openai", serviceName: "OpenAI API" },
   {
@@ -126,7 +187,7 @@ const AI_PACKAGE_REGISTRY = [
   { pattern: /^@mlc-ai\//u, runtime: "mlc" },
   { pattern: /^groq-sdk$|^groq$/u, provider: "groq", serviceName: "Groq API" },
   {
-    pattern: /^cohere-ai$/u,
+    pattern: /^cohere-ai$|^cohere$/u,
     provider: "cohere",
     serviceName: "Cohere API",
   },
@@ -179,6 +240,85 @@ const AI_PACKAGE_REGISTRY = [
     provider: "perplexity",
     serviceName: "Perplexity API",
   },
+  // Agent frameworks and SDKs from the 2025-2026 wave. These identify the
+  // orchestration layer a project builds on, which is often more meaningful for
+  // an AI-BOM than the underlying provider SDK alone. Patterns accept both the
+  // registry package name (hyphenated) and the imported module name
+  // (underscored) because Python import statements normalize hyphens to
+  // underscores.
+  {
+    pattern:
+      /^claude[-_]agent[-_]sdk$|^@anthropic-ai\/claude-agent-sdk$|^claude[-_]code[-_]sdk$/u,
+    framework: "claude-agent-sdk",
+    provider: "anthropic",
+    serviceName: "Anthropic API",
+  },
+  { pattern: /^google[-_]adk$|^@google\/adk$/u, framework: "google-adk" },
+  {
+    pattern: /^pydantic[-_]ai(?:[-_]slim)?$|^pydantic[-_]graph$/u,
+    framework: "pydantic-ai",
+  },
+  {
+    pattern: /^strands[-_]agents(?:[-_]tools|[-_]builder)?$/u,
+    framework: "strands-agents",
+  },
+  { pattern: /^agno$|^phidata$/u, framework: "agno" },
+  {
+    pattern:
+      /^agent[-_]framework(?:[-_]core|[-_]azure[-_]ai|[-_]copilotstudio)?$/u,
+    framework: "microsoft-agent-framework",
+  },
+  { pattern: /^semantic[-_]kernel$/u, framework: "semantic-kernel" },
+  { pattern: /^deepagents$/u, framework: "deepagents" },
+  {
+    pattern: /^smolagents$/u,
+    framework: "smolagents",
+    provider: "huggingface",
+  },
+  { pattern: /^dspy(?:[-_]ai)?$/u, framework: "dspy" },
+  { pattern: /^haystack[-_]ai$|^farm[-_]haystack$/u, framework: "haystack" },
+  { pattern: /^instructor$/u, framework: "instructor" },
+  { pattern: /^browser[-_]use$/u, framework: "browser-use" },
+  {
+    pattern: /^openai[-_]agents$/u,
+    framework: "openai-agents",
+    provider: "openai",
+    serviceName: "OpenAI API",
+  },
+  { pattern: /^crewai(?:[-_]tools)?$/u, framework: "crewai" },
+  // Note: OpenAI Swarm is intentionally not matched by a bare `swarm` name.
+  // On npm/PyPI `swarm` refers to unrelated projects (Ethereum Swarm, Docker
+  // Swarm tooling); OpenAI Swarm is installed from Git, not under that name.
+  // Provider SDKs and OpenAI-compatible gateway clients for the wider set of
+  // inference providers now in common use.
+  {
+    pattern: /^@ai-sdk\/xai$|^langchain[-_]xai$|^xai[-_]sdk$/u,
+    provider: "xai",
+    serviceName: "xAI Grok API",
+  },
+  {
+    pattern:
+      /^@aws-sdk\/client-bedrock-runtime$|^langchain[-_]aws$|^@langchain\/aws$/u,
+    provider: "aws-bedrock",
+    serviceName: "AWS Bedrock",
+  },
+  {
+    pattern: /^openrouter$|^@openrouter\/ai-sdk-provider$/u,
+    provider: "openrouter",
+    serviceName: "OpenRouter API",
+  },
+  {
+    pattern:
+      /^@cerebras\/cerebras[_-]cloud[_-]sdk$|^cerebras[-_]cloud[-_]sdk$/u,
+    provider: "cerebras",
+    serviceName: "Cerebras API",
+  },
+  {
+    pattern: /^dashscope$/u,
+    provider: "dashscope",
+    serviceName: "Alibaba DashScope API",
+  },
+  { pattern: /^zhipuai$/u, provider: "zhipu", serviceName: "Zhipu GLM API" },
 ];
 const serializeAiService = (service) => ({
   "bom-ref": service["bom-ref"],
@@ -252,7 +392,7 @@ const extractImportNames = (raw) => {
     imports.push({ index: match.index, names: [match[1]] });
   }
   for (const match of raw.matchAll(
-    /from\s+([A-Za-z0-9_.-]+)\s+import\b|import\s+([A-Za-z0-9_.,\s-]+)/gu,
+    /from\s+([A-Za-z0-9_.-]+)\s+import\b|import[ \t]+([A-Za-z0-9_.,\- \t]+)/gu,
   )) {
     if (linePrefixForIndex(raw, match.index) !== "") {
       continue;
@@ -326,11 +466,19 @@ const isLocalAiHostname = (hostname) => {
 const hostProviderFromValue = (urlValue) => {
   try {
     const parsed = new URL(urlValue);
-    return (
-      HOST_PROVIDER_PATTERNS.find(([, pattern]) =>
-        pattern.test(parsed.hostname),
-      )?.[0] || undefined
-    );
+    const hostMatch = HOST_PROVIDER_PATTERNS.find(([, pattern]) =>
+      pattern.test(parsed.hostname),
+    )?.[0];
+    if (hostMatch) {
+      return hostMatch;
+    }
+    // Local inference servers all bind to loopback, so disambiguate by the
+    // conventional port. An unknown local port is labeled generically rather
+    // than guessed as Ollama.
+    if (isLocalAiHostname(parsed.hostname)) {
+      return LOCAL_INFERENCE_PORTS.get(parsed.port) || "local-inference";
+    }
+    return undefined;
   } catch {
     return undefined;
   }
@@ -426,6 +574,82 @@ const quantizationValueFromFilename = (fileName) => {
   return legacyQuantizationValueFromFilename(fileName);
 };
 
+// Quantization methods that are distinct from the container format. These often
+// appear in a model or file name and are useful for hardware-fit review.
+const QUANTIZATION_METHOD_PATTERNS = [
+  ["gptq", /\bgptq\b/iu],
+  ["awq", /\bawq\b/iu],
+  ["exl2", /\bexl2\b/iu],
+  ["exl3", /\bexl3\b/iu],
+  ["aqlm", /\baqlm\b/iu],
+  // Marlin is a GPTQ/AWQ kernel that appears as a suffix (gptq-marlin) or a
+  // quant_method value, so require that shape rather than the bare word, which
+  // is also an ordinary name.
+  ["marlin", /(?:gptq|awq)[-_]?marlin|[-_]marlin\b|^marlin$/iu],
+  ["bitsandbytes", /\bbnb\b|bitsandbytes/iu],
+];
+
+/**
+ * Detect a non-GGUF quantization method from a model name, file name, or an
+ * explicit `quantization_config.quant_method` value.
+ *
+ * @param {string} candidate Model name, file name, or quant method string
+ * @returns {string|undefined} Normalized quantization method label
+ */
+const quantizationMethodFromText = (candidate) => {
+  const normalized = String(candidate || "");
+  if (!normalized) {
+    return undefined;
+  }
+  for (const [method, pattern] of QUANTIZATION_METHOD_PATTERNS) {
+    if (pattern.test(normalized)) {
+      return method;
+    }
+  }
+  return undefined;
+};
+
+// Matches the Hugging Face sharded-weights suffix, e.g.
+// `model-00001-of-00003.safetensors`. Grouping by the de-sharded stem lets a
+// multi-file checkpoint be modeled as one component instead of one per shard.
+const SAFETENSORS_SHARD_PATTERN = /-\d{5}-of-\d{5}$/u;
+
+/**
+ * Compute the de-sharded model stem for a safetensors file name.
+ *
+ * @param {string} fileName safetensors base name (without extension)
+ * @returns {{ stem: string, isShard: boolean }} de-sharded stem and shard flag
+ */
+const deshardedStem = (fileName) => {
+  const isShard = SAFETENSORS_SHARD_PATTERN.test(fileName);
+  return {
+    stem: fileName.replace(SAFETENSORS_SHARD_PATTERN, ""),
+    isShard,
+  };
+};
+
+/**
+ * Read the model identity a sibling `config.json` declares, when present, so a
+ * safetensors artifact attaches to the repository model rather than a filename.
+ *
+ * @param {string} directoryPath Directory containing the safetensors file
+ * @returns {string|undefined} Model identity from `_name_or_path`
+ */
+const modelIdentityFromSiblingConfig = (directoryPath) => {
+  try {
+    const config = JSON.parse(
+      readFileSync(join(directoryPath, "config.json"), "utf-8"),
+    );
+    const nameOrPath = config?._name_or_path;
+    if (typeof nameOrPath === "string" && nameOrPath.trim()) {
+      return nameOrPath.trim();
+    }
+  } catch {
+    // no readable sibling config
+  }
+  return undefined;
+};
+
 const createExternalReference = (type, url, comment) => {
   const sanitizedUrl = sanitizeBomUrl(url);
   if (!sanitizedUrl) {
@@ -1237,6 +1461,20 @@ const syncComponentProperties = (component, data = {}) => {
       data.quantization,
     );
   }
+  if (data.quantizationMethod) {
+    addUniqueProperty(
+      component.properties,
+      "cdx:ai:quantizationMethod",
+      data.quantizationMethod,
+    );
+  }
+  if (data.unsafeDeserialization) {
+    addUniqueProperty(
+      component.properties,
+      "cdx:ai:unsafeDeserialization",
+      "true",
+    );
+  }
   for (const variant of data.variants || []) {
     addUniqueProperty(component.properties, "cdx:ai:variant", variant);
   }
@@ -1540,9 +1778,11 @@ const createModelComponent = (componentsByKey, seed, occurrenceLocation) => {
     parameterCount: seed.parameterCount,
     provider: seed.provider,
     quantization: seed.quantization,
+    quantizationMethod: seed.quantizationMethod,
     reviewNeeded: seed.reviewNeeded,
     runtime: seed.runtime,
     source: seed.source,
+    unsafeDeserialization: seed.unsafeDeserialization,
   });
   if (occurrenceLocation) {
     appendOccurrence(component.evidence, occurrenceLocation);
@@ -1891,6 +2131,260 @@ export function collectJsAiInventory(discoveryPath, options = {}) {
     );
   }
 
+  const safetensorsGroups = new Map();
+  for (const filePath of getMatchingFiles(
+    discoveryPath,
+    SAFETENSORS_PATTERNS,
+    options,
+  )) {
+    if (isVendoredArtifactPath(filePath)) {
+      continue;
+    }
+    const header = readSafetensorsHeader(filePath);
+    if (!header) {
+      continue;
+    }
+    const fileComponent = createAiFileComponent(
+      componentsByKey,
+      discoveryPath,
+      filePath,
+      "model-artifact-file",
+      ["safetensors"],
+    );
+    addUniqueProperty(
+      fileComponent.properties,
+      "cdx:safetensors:tensorCount",
+      header.tensorCount || undefined,
+    );
+    if (header.dtypes.length) {
+      addUniqueProperty(
+        fileComponent.properties,
+        "cdx:safetensors:dtypes",
+        header.dtypes.join(","),
+      );
+    }
+    const directoryPath = dirname(filePath);
+    const { stem, isShard } = deshardedStem(basename(filePath, ".safetensors"));
+    // Group shards of the same checkpoint (and co-located single files) so a
+    // multi-file model is one component. The sibling config identity, when
+    // present, keeps the group aligned with the model the HF parser found.
+    const groupKey = `${directoryPath}::${stem}`;
+    let group = safetensorsGroups.get(groupKey);
+    if (!group) {
+      group = {
+        directoryPath,
+        stem,
+        isShard,
+        // The first matching file on the sorted discovery list. Occurrence
+        // evidence must point at a path that exists, so a sharded group cites
+        // its first shard rather than a synthesized `<stem>.safetensors`.
+        firstFilePath: filePath,
+        fileRefs: [],
+        totalParameters: 0,
+        dtypes: new Set(),
+        quantMethod: undefined,
+      };
+      safetensorsGroups.set(groupKey, group);
+    }
+    group.isShard = group.isShard || isShard;
+    group.fileRefs.push(fileComponent["bom-ref"]);
+    group.totalParameters += header.totalParameters || 0;
+    for (const dtype of header.dtypes) {
+      group.dtypes.add(dtype);
+    }
+    group.quantMethod =
+      group.quantMethod ||
+      quantizationMethodFromText(header.metadata?.quant_method) ||
+      quantizationMethodFromText(basename(filePath));
+  }
+  // A directory can hold several distinct checkpoints (for example
+  // `model.safetensors` alongside `adapter_model.safetensors`). They share one
+  // sibling config.json, so resolve the config identity only for the group that
+  // carries the primary weights and let the others keep their own stem.
+  const groupsByDirectory = new Map();
+  for (const group of safetensorsGroups.values()) {
+    const peers = groupsByDirectory.get(group.directoryPath) || [];
+    peers.push(group);
+    groupsByDirectory.set(group.directoryPath, peers);
+  }
+  for (const group of safetensorsGroups.values()) {
+    const peers = groupsByDirectory.get(group.directoryPath) || [];
+    const isPrimaryGroup =
+      peers.length === 1 ||
+      group.stem === "model" ||
+      group.stem === "pytorch_model" ||
+      group.isShard;
+    const siblingIdentity = isPrimaryGroup
+      ? modelIdentityFromSiblingConfig(group.directoryPath)
+      : undefined;
+    const modelId = siblingIdentity || group.stem;
+    const component = createModelComponent(
+      componentsByKey,
+      {
+        artifactFormat: "safetensors",
+        confidence: siblingIdentity ? "high" : "medium",
+        modelFamily: modelFamilyFromName(modelId),
+        modelId,
+        parameterCount: group.totalParameters || undefined,
+        provider: siblingIdentity?.includes("/") ? "huggingface" : "local",
+        quantizationMethod: group.quantMethod,
+        reviewNeeded: true,
+        source: "local-artifact",
+        tags: ["safetensors", "local-model"],
+        variants: group.isShard ? ["sharded"] : undefined,
+      },
+      relativeOccurrenceLocation(discoveryPath, group.firstFilePath),
+    );
+    if (group.dtypes.size) {
+      addUniqueProperty(
+        component.properties,
+        "cdx:safetensors:dtypes",
+        Array.from(group.dtypes).sort().join(","),
+      );
+    }
+    // Two groups can still resolve to the same model component (for example a
+    // repository whose config identity matches its stem), so merge the artifact
+    // edges instead of replacing them.
+    const existingRefs = dependencyMap.get(component["bom-ref"]) || new Set();
+    for (const fileRef of group.fileRefs) {
+      existingRefs.add(fileRef);
+    }
+    dependencyMap.set(component["bom-ref"], existingRefs);
+  }
+
+  for (const filePath of getMatchingFiles(
+    discoveryPath,
+    ONNX_PATTERNS,
+    options,
+  )) {
+    if (isVendoredArtifactPath(filePath)) {
+      continue;
+    }
+    const fileComponent = createAiFileComponent(
+      componentsByKey,
+      discoveryPath,
+      filePath,
+      "model-artifact-file",
+      ["onnx"],
+    );
+    const modelId = basename(filePath, ".onnx");
+    const component = createModelComponent(
+      componentsByKey,
+      {
+        artifactFormat: "onnx",
+        confidence: "high",
+        modelFamily: modelFamilyFromName(modelId),
+        modelId,
+        provider: "local",
+        reviewNeeded: true,
+        source: "local-artifact",
+        tags: ["onnx", "local-model"],
+      },
+      relativeOccurrenceLocation(discoveryPath, filePath),
+    );
+    // The protobuf header is read by offset without loading the graph, so
+    // producer and opset provenance is cheap even for large models.
+    const onnxHeader = readOnnxHeader(filePath);
+    if (onnxHeader) {
+      if (onnxHeader.irVersion) {
+        addUniqueProperty(
+          component.properties,
+          "cdx:onnx:irVersion",
+          String(onnxHeader.irVersion),
+        );
+      }
+      // Producer names are tool identifiers such as "pytorch"; they name the
+      // exporter rather than any user or environment detail.
+      if (onnxHeader.producerName) {
+        addUniqueProperty(
+          component.properties,
+          "cdx:onnx:producer",
+          onnxHeader.producerName,
+        );
+      }
+      if (onnxHeader.producerVersion) {
+        addUniqueProperty(
+          component.properties,
+          "cdx:onnx:producerVersion",
+          onnxHeader.producerVersion,
+        );
+      }
+      if (onnxHeader.opsets.length) {
+        addUniqueProperty(
+          component.properties,
+          "cdx:onnx:opsets",
+          onnxHeader.opsets
+            .map((opset) => `${opset.domain || "ai.onnx"}:${opset.version}`)
+            .join(","),
+        );
+      }
+    }
+    dependencyMap.set(
+      fileComponent["bom-ref"],
+      new Set([component["bom-ref"]]),
+    );
+  }
+
+  for (const filePath of getMatchingFiles(
+    discoveryPath,
+    PICKLE_MODEL_PATTERNS,
+    options,
+  )) {
+    // Only treat these as model artifacts when the name looks model-like and
+    // the file is large enough to be a real checkpoint. Dependency payload
+    // directories are skipped entirely.
+    if (isVendoredArtifactPath(filePath)) {
+      continue;
+    }
+    const lowerName = basename(filePath).toLowerCase();
+    const looksLikeModel =
+      /(model|weights|pytorch|checkpoint|ckpt|adapter|lora|diffusion|embed)/u.test(
+        lowerName,
+      );
+    if (!looksLikeModel) {
+      continue;
+    }
+    let artifactBytes = 0;
+    try {
+      artifactBytes = statSync(filePath).size;
+    } catch {
+      continue;
+    }
+    if (artifactBytes < MIN_PICKLE_MODEL_BYTES) {
+      continue;
+    }
+    const fileComponent = createAiFileComponent(
+      componentsByKey,
+      discoveryPath,
+      filePath,
+      "model-artifact-file",
+      ["pytorch-pickle"],
+    );
+    const modelId = basename(filePath).replace(/\.[^.]+$/u, "");
+    const component = createModelComponent(
+      componentsByKey,
+      {
+        artifactFormat: "pytorch-pickle",
+        confidence: "medium",
+        modelFamily: modelFamilyFromName(modelId),
+        modelId,
+        provider: "local",
+        quantizationMethod: quantizationMethodFromText(lowerName),
+        reviewNeeded: true,
+        source: "local-artifact",
+        tags: ["pytorch", "pickle", "local-model"],
+        // Loading a pickle checkpoint can execute arbitrary code; surface this
+        // so security audit rules can flag untrusted model artifacts.
+        unsafeDeserialization: true,
+      },
+      relativeOccurrenceLocation(discoveryPath, filePath),
+    );
+    dependencyMap.set(
+      fileComponent["bom-ref"],
+      new Set([component["bom-ref"]]),
+    );
+  }
+
   return buildAiInventoryResult(componentsByKey, servicesByKey, dependencyMap);
 }
 

package/lib/inventory/aiInventory.js

@@ -10,7 +10,9 @@ import {
 import { communityAiConfigParser } from "./communityAiConfigParser.js";
 import { mergeServices, trimComponents } from "./depsUtils.js";
 import { classifyMcpReference } from "./mcp.js";
+import { mcpbBundleParser } from "./mcpbBundle.js";
 import { mcpConfigParser } from "./mcpConfigParser.js";
+import { mcpServerManifestParser } from "./mcpServerManifest.js";
 
 /** Project types treated as AI-related inventory for collection and parsing. */
 export const AI_INVENTORY_PROJECT_TYPES = ["mcp", "ai-skill", "ai"];
@@ -64,6 +66,16 @@ const AI_INVENTORY_PARSERS = [
     parser: mcpConfigParser,
     types: ["mcp"],
   },
+  {
+    id: mcpServerManifestParser.id,
+    parser: mcpServerManifestParser,
+    types: ["mcp"],
+  },
+  {
+    id: mcpbBundleParser.id,
+    parser: mcpbBundleParser,
+    types: ["mcp"],
+  },
   {
     id: communityAiConfigParser.id,
     parser: communityAiConfigParser,