@agentcash/discovery 0.1.0 → 0.1.2

package/dist/index.cjs

@@ -24,9 +24,16 @@ __export(index_exports, {
   LEGACY_SUNSET_DATE: () => LEGACY_SUNSET_DATE,
   STRICT_ESCALATION_CODES: () => STRICT_ESCALATION_CODES,
   UPGRADE_WARNING_CODES: () => UPGRADE_WARNING_CODES,
+  auditContextHarness: () => auditContextHarness,
+  buildContextHarnessReport: () => buildContextHarnessReport,
   computeUpgradeSignal: () => computeUpgradeSignal,
+  defaultHarnessProbeCandidates: () => defaultHarnessProbeCandidates,
   discover: () => discover,
-  discoverDetailed: () => discoverDetailed
+  discoverDetailed: () => discoverDetailed,
+  discoverForMcp: () => discoverForMcp,
+  getHarnessClientProfile: () => getHarnessClientProfile,
+  inspectEndpointForMcp: () => inspectEndpointForMcp,
+  listHarnessClientProfiles: () => listHarnessClientProfiles
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -43,6 +50,9 @@ var STRICT_ESCALATION_CODES = [
   "INTEROP_MPP_USED"
 ];
 
+// src/mmm-enabled.ts
+var isMmmEnabled = () => "0.1.2".includes("-mmm");
+
 // src/core/constants.ts
 var OPENAPI_PATH_CANDIDATES = ["/openapi.json", "/.well-known/openapi.json"];
 var WELL_KNOWN_MPP_PATH = "/.well-known/mpp";
@@ -995,7 +1005,7 @@ function detectProtocols(response) {
   }
   const authHeader = response.headers.get("www-authenticate")?.toLowerCase() ?? "";
   if (authHeader.includes("x402")) protocols.add("x402");
-  if (authHeader.includes("mpp")) protocols.add("mpp");
+  if (isMmmEnabled() && authHeader.includes("mpp")) protocols.add("mpp");
   return [...protocols];
 }
 async function runProbeStage(options) {
@@ -1327,7 +1337,7 @@ async function runDiscovery({
         includeRaw
       })
     );
-    if (includeInteropMpp) {
+    if (includeInteropMpp && isMmmEnabled()) {
       stages.push(
         () => runInteropMppStage({
           origin,
@@ -1429,6 +1439,636 @@ async function runDiscovery({
   };
 }
 
+// src/adapters/mcp.ts
+var DEFAULT_GUIDANCE_AUTO_INCLUDE_MAX_TOKENS = 1e3;
+var OPENAPI_METHODS = [
+  "GET",
+  "POST",
+  "PUT",
+  "DELETE",
+  "PATCH",
+  "HEAD",
+  "OPTIONS",
+  "TRACE"
+];
+function isRecord4(value) {
+  return value != null && typeof value === "object" && !Array.isArray(value);
+}
+function toFiniteNumber(value) {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string" && value.trim().length > 0) {
+    const parsed = Number(value);
+    if (Number.isFinite(parsed)) return parsed;
+  }
+  return void 0;
+}
+function formatPriceHintFromResource(resource) {
+  const pricing = resource.pricing;
+  if (pricing) {
+    if (pricing.pricingMode === "fixed" && pricing.price) {
+      return pricing.price.startsWith("$") ? pricing.price : `$${pricing.price}`;
+    }
+    if (pricing.pricingMode === "range" && pricing.minPrice && pricing.maxPrice) {
+      const min = pricing.minPrice.startsWith("$") ? pricing.minPrice : `$${pricing.minPrice}`;
+      const max = pricing.maxPrice.startsWith("$") ? pricing.maxPrice : `$${pricing.maxPrice}`;
+      return `${min}-${max}`;
+    }
+  }
+  if (!resource.priceHint) return void 0;
+  const hint = resource.priceHint.trim();
+  if (hint.length === 0) return void 0;
+  if (hint.startsWith("$")) return hint;
+  if (hint.includes("-")) {
+    const [min, max] = hint.split("-", 2).map((part) => part.trim());
+    if (min && max) return `$${min}-$${max}`;
+  }
+  return `$${hint}`;
+}
+function deriveMcpAuthMode(resource) {
+  if (!resource) return void 0;
+  const hint = resource.authHint;
+  if (hint === "paid" || hint === "siwx" || hint === "apiKey" || hint === "unprotected") {
+    return hint;
+  }
+  return void 0;
+}
+function inferFailureCause(warnings) {
+  const openapiWarnings = warnings.filter((w) => w.stage === "openapi");
+  const parseWarning = openapiWarnings.find(
+    (w) => w.code === "PARSE_FAILED" || w.code === "OPENAPI_TOP_LEVEL_INVALID" || w.code === "OPENAPI_OPERATION_INVALID" || w.code === "OPENAPI_PRICING_INVALID"
+  );
+  if (parseWarning) {
+    return { cause: "parse", message: parseWarning.message };
+  }
+  const fetchWarning = openapiWarnings.find((w) => w.code === "FETCH_FAILED");
+  if (fetchWarning) {
+    const msg = fetchWarning.message.toLowerCase();
+    if (msg.includes("timeout") || msg.includes("timed out") || msg.includes("abort")) {
+      return { cause: "timeout", message: fetchWarning.message };
+    }
+    return { cause: "network", message: fetchWarning.message };
+  }
+  return { cause: "not_found" };
+}
+function getOpenApiInfo(document) {
+  if (!isRecord4(document) || !isRecord4(document.info)) return void 0;
+  if (typeof document.info.title !== "string") return void 0;
+  return {
+    title: document.info.title,
+    ...typeof document.info.version === "string" ? { version: document.info.version } : {},
+    ...typeof document.info.description === "string" ? { description: document.info.description } : {}
+  };
+}
+function getGuidanceUrl(result) {
+  const fromTrace = result.trace.find((entry) => entry.links?.llmsTxtUrl)?.links?.llmsTxtUrl;
+  if (fromTrace) return fromTrace;
+  const fromResource = result.resources.find((resource) => resource.links?.llmsTxtUrl)?.links?.llmsTxtUrl;
+  if (fromResource) return fromResource;
+  return void 0;
+}
+async function resolveGuidance(options) {
+  let guidanceText = typeof options.result.rawSources?.llmsTxt === "string" ? options.result.rawSources.llmsTxt : void 0;
+  if (!guidanceText) {
+    const guidanceUrl = getGuidanceUrl(options.result) ?? `${options.result.origin}/llms.txt`;
+    const fetcher = options.fetcher ?? fetch;
+    try {
+      const response = await fetcher(guidanceUrl, {
+        method: "GET",
+        headers: { Accept: "text/plain", ...options.headers },
+        signal: options.signal
+      });
+      if (response.ok) guidanceText = await response.text();
+    } catch {
+    }
+  }
+  if (!guidanceText) {
+    return { guidanceAvailable: false };
+  }
+  const guidanceTokens = estimateTokenCount(guidanceText);
+  const threshold = options.guidanceAutoIncludeMaxTokens ?? DEFAULT_GUIDANCE_AUTO_INCLUDE_MAX_TOKENS;
+  const shouldInclude = options.includeGuidance === true || options.includeGuidance == null && guidanceTokens <= threshold;
+  return {
+    guidanceAvailable: true,
+    guidanceTokens,
+    ...shouldInclude ? { guidance: guidanceText } : {}
+  };
+}
+function extractPathsDocument(document) {
+  if (!isRecord4(document)) return void 0;
+  if (!isRecord4(document.paths)) return void 0;
+  return document.paths;
+}
+function findMatchingOpenApiPath(paths, targetPath) {
+  const exact = paths[targetPath];
+  if (isRecord4(exact)) return { matchedPath: targetPath, pathItem: exact };
+  for (const [specPath, entry] of Object.entries(paths)) {
+    if (!isRecord4(entry)) continue;
+    const pattern = specPath.replace(/\{[^}]+\}/g, "[^/]+");
+    const regex = new RegExp(`^${pattern}$`);
+    if (regex.test(targetPath)) {
+      return { matchedPath: specPath, pathItem: entry };
+    }
+  }
+  return null;
+}
+function resolveRef(document, ref, seen) {
+  if (!ref.startsWith("#/")) return void 0;
+  if (seen.has(ref)) return { $circular: ref };
+  seen.add(ref);
+  const parts = ref.slice(2).split("/");
+  let current = document;
+  for (const part of parts) {
+    if (!isRecord4(current)) return void 0;
+    current = current[part];
+    if (current === void 0) return void 0;
+  }
+  if (isRecord4(current)) return resolveRefs(document, current, seen);
+  return current;
+}
+function resolveRefs(document, obj, seen, depth = 0) {
+  if (depth > 4) return obj;
+  const resolved = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (key === "$ref" && typeof value === "string") {
+      const deref = resolveRef(document, value, seen);
+      if (isRecord4(deref)) {
+        Object.assign(resolved, deref);
+      } else {
+        resolved[key] = value;
+      }
+      continue;
+    }
+    if (isRecord4(value)) {
+      resolved[key] = resolveRefs(document, value, seen, depth + 1);
+      continue;
+    }
+    if (Array.isArray(value)) {
+      resolved[key] = value.map(
+        (item) => isRecord4(item) ? resolveRefs(document, item, seen, depth + 1) : item
+      );
+      continue;
+    }
+    resolved[key] = value;
+  }
+  return resolved;
+}
+function extractRequestBodySchema(operationSchema) {
+  const requestBody = operationSchema.requestBody;
+  if (!isRecord4(requestBody)) return void 0;
+  const content = requestBody.content;
+  if (!isRecord4(content)) return void 0;
+  const jsonMediaType = content["application/json"];
+  if (isRecord4(jsonMediaType) && isRecord4(jsonMediaType.schema)) {
+    return jsonMediaType.schema;
+  }
+  for (const mediaType of Object.values(content)) {
+    if (isRecord4(mediaType) && isRecord4(mediaType.schema)) {
+      return mediaType.schema;
+    }
+  }
+  return void 0;
+}
+function extractParameters(operationSchema) {
+  const params = operationSchema.parameters;
+  if (!Array.isArray(params)) return [];
+  return params.filter((value) => isRecord4(value));
+}
+function extractInputSchema(operationSchema) {
+  const requestBody = extractRequestBodySchema(operationSchema);
+  const parameters = extractParameters(operationSchema);
+  if (!requestBody && parameters.length === 0) return void 0;
+  if (requestBody && parameters.length === 0) return requestBody;
+  return {
+    ...requestBody ? { requestBody } : {},
+    ...parameters.length > 0 ? { parameters } : {}
+  };
+}
+function parseOperationPrice(operation) {
+  const paymentInfo = operation["x-payment-info"];
+  if (!isRecord4(paymentInfo)) return void 0;
+  const fixed = toFiniteNumber(paymentInfo.price);
+  if (fixed != null) return `$${String(fixed)}`;
+  const min = toFiniteNumber(paymentInfo.minPrice);
+  const max = toFiniteNumber(paymentInfo.maxPrice);
+  if (min != null && max != null) return `$${String(min)}-$${String(max)}`;
+  return void 0;
+}
+function parseOperationProtocols(operation) {
+  const paymentInfo = operation["x-payment-info"];
+  if (!isRecord4(paymentInfo) || !Array.isArray(paymentInfo.protocols)) return void 0;
+  const protocols = paymentInfo.protocols.filter(
+    (protocol) => typeof protocol === "string" && protocol.length > 0
+  );
+  return protocols.length > 0 ? protocols : void 0;
+}
+function parseOperationAuthMode(operation) {
+  const authExtension = operation["x-agentcash-auth"];
+  if (isRecord4(authExtension)) {
+    const mode = authExtension.mode;
+    if (mode === "paid" || mode === "siwx" || mode === "apiKey" || mode === "unprotected") {
+      return mode;
+    }
+  }
+  if (isRecord4(operation["x-payment-info"])) return "paid";
+  return void 0;
+}
+function createResourceMap(result) {
+  const map = /* @__PURE__ */ new Map();
+  for (const resource of result.resources) {
+    map.set(resource.resourceKey, resource);
+  }
+  return map;
+}
+function toMcpEndpointSummary(resource) {
+  const method = parseMethod(resource.method);
+  if (!method) return void 0;
+  const price = formatPriceHintFromResource(resource);
+  const authMode = deriveMcpAuthMode(resource);
+  return {
+    path: resource.path,
+    method,
+    summary: resource.summary ?? `${method} ${resource.path}`,
+    ...price ? { price } : {},
+    ...resource.protocolHints?.length ? { protocols: [...resource.protocolHints] } : {},
+    ...authMode ? { authMode } : {}
+  };
+}
+async function discoverForMcp(options) {
+  const result = await runDiscovery({
+    detailed: true,
+    options: {
+      target: options.target,
+      compatMode: options.compatMode ?? "off",
+      rawView: "full",
+      fetcher: options.fetcher,
+      headers: options.headers,
+      signal: options.signal
+    }
+  });
+  if (result.resources.length === 0) {
+    const failure = inferFailureCause(result.warnings);
+    return {
+      found: false,
+      origin: result.origin,
+      cause: failure.cause,
+      ...failure.message ? { message: failure.message } : {},
+      warnings: result.warnings
+    };
+  }
+  const source = result.selectedStage ?? "openapi";
+  const endpoints = result.resources.map(toMcpEndpointSummary).filter((endpoint) => endpoint != null).sort((a, b) => {
+    if (a.path !== b.path) return a.path.localeCompare(b.path);
+    return a.method.localeCompare(b.method);
+  });
+  const guidance = await resolveGuidance({
+    result,
+    includeGuidance: options.includeGuidance,
+    guidanceAutoIncludeMaxTokens: options.guidanceAutoIncludeMaxTokens,
+    fetcher: options.fetcher,
+    headers: options.headers,
+    signal: options.signal
+  });
+  return {
+    found: true,
+    origin: result.origin,
+    source,
+    ...getOpenApiInfo(result.rawSources?.openapi) ? { info: getOpenApiInfo(result.rawSources?.openapi) } : {},
+    ...guidance,
+    endpoints,
+    warnings: result.warnings
+  };
+}
+async function inspectEndpointForMcp(options) {
+  const endpoint = new URL(options.endpointUrl);
+  const origin = normalizeOrigin(endpoint.origin);
+  const path = normalizePath(endpoint.pathname || "/");
+  const result = await runDiscovery({
+    detailed: true,
+    options: {
+      target: options.target,
+      compatMode: options.compatMode ?? "off",
+      rawView: "full",
+      fetcher: options.fetcher,
+      headers: options.headers,
+      signal: options.signal
+    }
+  });
+  const document = result.rawSources?.openapi;
+  const paths = extractPathsDocument(document);
+  const resourceMap = createResourceMap(result);
+  const advisories = {};
+  const specMethods = [];
+  if (paths) {
+    const matched = findMatchingOpenApiPath(paths, path);
+    if (matched) {
+      for (const candidate of OPENAPI_METHODS) {
+        const operation = matched.pathItem[candidate.toLowerCase()];
+        if (!isRecord4(operation) || !isRecord4(document)) continue;
+        specMethods.push(candidate);
+        const resolvedOperation = resolveRefs(document, operation, /* @__PURE__ */ new Set());
+        const resource = resourceMap.get(toResourceKey(origin, candidate, matched.matchedPath));
+        const formattedPrice = resource ? formatPriceHintFromResource(resource) : void 0;
+        const operationSummary = typeof resolvedOperation.summary === "string" ? resolvedOperation.summary : typeof resolvedOperation.description === "string" ? resolvedOperation.description : void 0;
+        const operationPrice = parseOperationPrice(resolvedOperation);
+        const operationProtocols = parseOperationProtocols(resolvedOperation);
+        const operationAuthMode = parseOperationAuthMode(resolvedOperation);
+        const inputSchema = extractInputSchema(resolvedOperation);
+        advisories[candidate] = {
+          method: candidate,
+          ...resource?.summary || operationSummary ? {
+            summary: resource?.summary ?? operationSummary
+          } : {},
+          ...formattedPrice || operationPrice ? {
+            estimatedPrice: formattedPrice ?? operationPrice
+          } : {},
+          ...resource?.protocolHints?.length || operationProtocols ? {
+            protocols: resource?.protocolHints ?? operationProtocols
+          } : {},
+          ...deriveMcpAuthMode(resource) || operationAuthMode ? {
+            authMode: deriveMcpAuthMode(resource) ?? operationAuthMode
+          } : {},
+          ...inputSchema ? { inputSchema } : {},
+          operationSchema: resolvedOperation
+        };
+      }
+    }
+  }
+  if (specMethods.length === 0) {
+    for (const method of OPENAPI_METHODS) {
+      const resource = resourceMap.get(toResourceKey(origin, method, path));
+      if (!resource) continue;
+      specMethods.push(method);
+      const formattedPrice = formatPriceHintFromResource(resource);
+      advisories[method] = {
+        method,
+        ...resource.summary ? { summary: resource.summary } : {},
+        ...formattedPrice ? { estimatedPrice: formattedPrice } : {},
+        ...resource.protocolHints?.length ? { protocols: [...resource.protocolHints] } : {},
+        ...deriveMcpAuthMode(resource) ? { authMode: deriveMcpAuthMode(resource) } : {}
+      };
+    }
+  }
+  if (specMethods.length === 0) {
+    const failure = inferFailureCause(result.warnings);
+    return {
+      found: false,
+      origin,
+      path,
+      cause: failure.cause,
+      ...failure.message ? { message: failure.message } : {},
+      warnings: result.warnings
+    };
+  }
+  return {
+    found: true,
+    origin,
+    path,
+    specMethods,
+    advisories,
+    warnings: result.warnings
+  };
+}
+
+// src/harness.ts
+var INTENT_TRIGGERS = ["x402", "mpp", "pay for", "micropayment", "agentic commerce"];
+var CLIENT_PROFILES = {
+  "claude-code": {
+    id: "claude-code",
+    label: "Claude Code MCP Harness",
+    surface: "mcp",
+    defaultContextWindowTokens: 2e5,
+    zeroHopBudgetPercent: 0.1,
+    notes: "Targets environments where MCP context can use roughly 10% of total context."
+  },
+  "skill-cli": {
+    id: "skill-cli",
+    label: "Skill + CLI Harness",
+    surface: "skill-cli",
+    defaultContextWindowTokens: 2e5,
+    zeroHopBudgetPercent: 0.02,
+    notes: "Targets constrained skill contexts with title/description-heavy routing."
+  },
+  "generic-mcp": {
+    id: "generic-mcp",
+    label: "Generic MCP Harness",
+    surface: "mcp",
+    defaultContextWindowTokens: 128e3,
+    zeroHopBudgetPercent: 0.05,
+    notes: "Conservative MCP profile when specific client budgets are unknown."
+  },
+  generic: {
+    id: "generic",
+    label: "Generic Agent Harness",
+    surface: "generic",
+    defaultContextWindowTokens: 128e3,
+    zeroHopBudgetPercent: 0.03,
+    notes: "Fallback profile for unknown clients."
+  }
+};
+function isFirstPartyDomain(hostname) {
+  const normalized = hostname.toLowerCase();
+  return normalized.endsWith(".dev") && normalized.startsWith("stable");
+}
+function safeHostname(origin) {
+  try {
+    return new URL(origin).hostname;
+  } catch {
+    return origin.replace(/^https?:\/\//, "").split("/")[0] ?? origin;
+  }
+}
+function previewText(text) {
+  if (!text) return null;
+  const compact = text.replace(/\s+/g, " ").trim();
+  if (!compact) return null;
+  return compact.length > 220 ? `${compact.slice(0, 217)}...` : compact;
+}
+function toAuthModeCount(resources) {
+  const counts = {
+    paid: 0,
+    siwx: 0,
+    apiKey: 0,
+    unprotected: 0,
+    unknown: 0
+  };
+  for (const resource of resources) {
+    const mode = resource.authHint;
+    if (mode === "paid" || mode === "siwx" || mode === "apiKey" || mode === "unprotected") {
+      counts[mode] += 1;
+    } else {
+      counts.unknown += 1;
+    }
+  }
+  return counts;
+}
+function toSourceCount(resources) {
+  return resources.reduce(
+    (acc, resource) => {
+      acc[resource.source] = (acc[resource.source] ?? 0) + 1;
+      return acc;
+    },
+    {}
+  );
+}
+function toL2Entries(resources) {
+  return [...resources].sort((a, b) => {
+    if (a.path !== b.path) return a.path.localeCompare(b.path);
+    if (a.method !== b.method) return a.method.localeCompare(b.method);
+    return a.resourceKey.localeCompare(b.resourceKey);
+  }).map((resource) => ({
+    resourceKey: resource.resourceKey,
+    method: resource.method,
+    path: resource.path,
+    source: resource.source,
+    authMode: resource.authHint ?? null
+  }));
+}
+function getLlmsTxtInfo(result) {
+  const llmsTxtUrl = result.trace.find((entry) => entry.links?.llmsTxtUrl)?.links?.llmsTxtUrl ?? result.resources.find((resource) => resource.links?.llmsTxtUrl)?.links?.llmsTxtUrl ?? null;
+  const llmsTxt = result.rawSources?.llmsTxt;
+  if (llmsTxt) {
+    return {
+      llmsTxtUrl,
+      llmsTxtTokenEstimate: estimateTokenCount(llmsTxt),
+      guidancePreview: previewText(llmsTxt),
+      guidanceStatus: "present"
+    };
+  }
+  if (llmsTxtUrl) {
+    const failed = result.warnings.some((warning2) => warning2.code === "LLMSTXT_FETCH_FAILED");
+    return {
+      llmsTxtUrl,
+      llmsTxtTokenEstimate: 0,
+      guidancePreview: null,
+      guidanceStatus: failed ? "advertised_but_unfetched" : "missing"
+    };
+  }
+  return {
+    llmsTxtUrl: null,
+    llmsTxtTokenEstimate: 0,
+    guidancePreview: null,
+    guidanceStatus: "not_advertised"
+  };
+}
+function getHarnessClientProfile(client = "claude-code") {
+  return CLIENT_PROFILES[client] ?? CLIENT_PROFILES.generic;
+}
+function listHarnessClientProfiles() {
+  return Object.values(CLIENT_PROFILES);
+}
+function buildContextHarnessReport(options) {
+  const client = getHarnessClientProfile(options.client);
+  const contextWindowTokens = options.contextWindowTokens ?? client.defaultContextWindowTokens;
+  const zeroHopBudgetTokens = Math.floor(contextWindowTokens * client.zeroHopBudgetPercent);
+  const hostname = safeHostname(options.result.origin);
+  const domainClass = isFirstPartyDomain(hostname) ? "first-party" : "ugc";
+  const l0Summary = "Route payment-capable intents to agentcash and use install/discover commands for progressive disclosure.";
+  const l1Summary = "Expose installed domain routing hints and trigger fan-out into L2/L3 commands when user intent matches domain capabilities.";
+  const l0EstimatedTokens = estimateTokenCount(
+    `${INTENT_TRIGGERS.join(", ")} npx agentcash install npx agentcash install-ext`
+  );
+  const l1EstimatedTokens = estimateTokenCount(
+    `${hostname} ${l1Summary} npx agentcash discover ${hostname} npx agentcash discover ${hostname} --verbose`
+  );
+  const llmsInfo = getLlmsTxtInfo(options.result);
+  return {
+    target: options.target,
+    origin: options.result.origin,
+    client,
+    budget: {
+      contextWindowTokens,
+      zeroHopBudgetTokens,
+      estimatedZeroHopTokens: l0EstimatedTokens + l1EstimatedTokens,
+      withinBudget: l0EstimatedTokens + l1EstimatedTokens <= zeroHopBudgetTokens
+    },
+    levels: {
+      l0: {
+        layer: "L0",
+        intentTriggers: INTENT_TRIGGERS,
+        installCommand: "npx agentcash install",
+        deliverySurfaces: ["MCP", "Skill+CLI"],
+        summary: l0Summary,
+        estimatedTokens: l0EstimatedTokens
+      },
+      l1: {
+        layer: "L1",
+        domain: hostname,
+        domainClass,
+        selectedDiscoveryStage: options.result.selectedStage ?? null,
+        summary: l1Summary,
+        fanoutCommands: [
+          `npx agentcash discover ${hostname}`,
+          `npx agentcash discover ${hostname} --verbose`
+        ],
+        estimatedTokens: l1EstimatedTokens
+      },
+      l2: {
+        layer: "L2",
+        command: `npx agentcash discover ${hostname}`,
+        tokenLight: true,
+        resourceCount: options.result.resources.length,
+        resources: toL2Entries(options.result.resources)
+      },
+      l3: {
+        layer: "L3",
+        command: `npx agentcash discover ${hostname} --verbose`,
+        detailLevel: "endpoint-schema-and-metadata",
+        countsByAuthMode: toAuthModeCount(options.result.resources),
+        countsBySource: toSourceCount(options.result.resources),
+        pricedResourceCount: options.result.resources.filter(
+          (resource) => resource.authHint === "paid"
+        ).length
+      },
+      l4: {
+        layer: "L4",
+        guidanceSource: llmsInfo.llmsTxtUrl ? "llms.txt" : "none",
+        llmsTxtUrl: llmsInfo.llmsTxtUrl,
+        llmsTxtTokenEstimate: llmsInfo.llmsTxtTokenEstimate,
+        guidancePreview: llmsInfo.guidancePreview,
+        guidanceStatus: llmsInfo.guidanceStatus
+      },
+      l5: {
+        layer: "L5",
+        status: "out_of_scope",
+        note: "Cross-domain composition is intentionally out of scope for discovery v1."
+      }
+    },
+    diagnostics: {
+      warningCount: options.result.warnings.length,
+      errorWarningCount: options.result.warnings.filter((warning2) => warning2.severity === "error").length,
+      selectedStage: options.result.selectedStage ?? null,
+      upgradeSuggested: options.result.upgradeSuggested,
+      upgradeReasons: options.result.upgradeReasons
+    }
+  };
+}
+async function auditContextHarness(options) {
+  const result = await runDiscovery({
+    detailed: true,
+    options: {
+      ...options,
+      rawView: "full"
+    }
+  });
+  return buildContextHarnessReport({
+    target: options.target,
+    result,
+    client: options.client,
+    contextWindowTokens: options.contextWindowTokens
+  });
+}
+function defaultHarnessProbeCandidates(report) {
+  const methodsByPath = /* @__PURE__ */ new Map();
+  for (const resource of report.levels.l2.resources) {
+    const methods = methodsByPath.get(resource.path) ?? /* @__PURE__ */ new Set();
+    methods.add(resource.method);
+    methodsByPath.set(resource.path, methods);
+  }
+  return [...methodsByPath.entries()].map(([path, methods]) => ({
+    path,
+    methods: [...methods]
+  }));
+}
+
 // src/index.ts
 async function discover(options) {
   return await runDiscovery({ detailed: false, options });
@@ -1442,7 +2082,14 @@ async function discoverDetailed(options) {
   LEGACY_SUNSET_DATE,
   STRICT_ESCALATION_CODES,
   UPGRADE_WARNING_CODES,
+  auditContextHarness,
+  buildContextHarnessReport,
   computeUpgradeSignal,
+  defaultHarnessProbeCandidates,
   discover,
-  discoverDetailed
+  discoverDetailed,
+  discoverForMcp,
+  getHarnessClientProfile,
+  inspectEndpointForMcp,
+  listHarnessClientProfiles
 });