@probemesh/sdk 0.1.0

package/dist/chunk-TDOBAMYM.js

@@ -0,0 +1,607 @@
+import {
+  validateProviderConformanceArtifact
+} from "./chunk-UU2ZG7P7.js";
+import {
+  validateProviderCatalogArtifact
+} from "./chunk-3H7UGVI6.js";
+import {
+  redactX402Secrets
+} from "./chunk-NYTV263W.js";
+import {
+  ProbeMeshError
+} from "./chunk-2ASMVLG4.js";
+
+// src/providerOnboardingDossier.ts
+import { createHash } from "crypto";
+var PROVIDER_ONBOARDING_DOSSIER_SCHEMA_VERSION = "probemesh.provider-onboarding-dossier.v1";
+function createProviderOnboardingDossier(options) {
+  assertProviderOnboardingDossierOptions(options);
+  const status = options.catalogArtifact.status === "ready" && options.conformanceArtifact.status === "verified" ? "ready" : "failed";
+  const readiness = summarizeReadiness(
+    options.catalogArtifact,
+    options.conformanceArtifact,
+    status
+  );
+  const baseContent = sanitizeDossierOutput(
+    {
+      schemaVersion: PROVIDER_ONBOARDING_DOSSIER_SCHEMA_VERSION,
+      dossierId: options.dossierId ?? `${options.catalogArtifact.provider.id}:${options.catalogArtifact.artifactId}:${options.conformanceArtifact.artifactId}:dossier`,
+      generatedAt: options.generatedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+      status,
+      hashAlgorithm: "sha256",
+      provider: summarizeProvider(options.catalogArtifact),
+      readiness,
+      evidence: summarizeEvidence(
+        options.catalogArtifact,
+        options.conformanceArtifact
+      ),
+      artifacts: {
+        catalog: cloneSerializable(options.catalogArtifact),
+        conformance: cloneSerializable(options.conformanceArtifact)
+      }
+    },
+    options.forbiddenOutputValues ?? []
+  );
+  const hashesWithoutDossier = {
+    catalogArtifact: hashStableJson(baseContent.artifacts.catalog),
+    conformanceArtifact: hashStableJson(baseContent.artifacts.conformance),
+    readiness: hashStableJson(baseContent.readiness),
+    dossier: ""
+  };
+  const dossier = {
+    ...baseContent,
+    hashes: {
+      ...hashesWithoutDossier,
+      dossier: hashDossierContent({
+        ...baseContent,
+        hashes: hashesWithoutDossier
+      })
+    }
+  };
+  assertProviderOnboardingDossier(dossier);
+  return dossier;
+}
+function validateProviderOnboardingDossier(dossier) {
+  const errors = [];
+  if (!isRecord(dossier)) {
+    return {
+      valid: false,
+      errors: [
+        {
+          path: "$",
+          message: "Provider onboarding dossier must be an object."
+        }
+      ]
+    };
+  }
+  if (dossier.schemaVersion !== PROVIDER_ONBOARDING_DOSSIER_SCHEMA_VERSION) {
+    errors.push({
+      path: "schemaVersion",
+      message: `schemaVersion must be "${PROVIDER_ONBOARDING_DOSSIER_SCHEMA_VERSION}".`
+    });
+  }
+  validateNonEmptyString(dossier.dossierId, "dossierId", errors);
+  validateIsoTimestamp(dossier.generatedAt, "generatedAt", errors);
+  if (dossier.status !== "ready" && dossier.status !== "failed") {
+    errors.push({
+      path: "status",
+      message: 'status must be "ready" or "failed".'
+    });
+  }
+  if (dossier.hashAlgorithm !== "sha256") {
+    errors.push({
+      path: "hashAlgorithm",
+      message: 'hashAlgorithm must be "sha256".'
+    });
+  }
+  validateProviderSummary(dossier.provider, errors);
+  validateReadiness(dossier.readiness, errors);
+  validateEvidence(dossier.evidence, errors);
+  validateNestedArtifacts(dossier.artifacts, errors);
+  validateHashes(dossier, errors);
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+function assertProviderOnboardingDossier(dossier) {
+  const result = validateProviderOnboardingDossier(dossier);
+  if (result.valid) {
+    return;
+  }
+  throw new ProbeMeshError({
+    code: "invalid_request",
+    message: `Invalid provider onboarding dossier: ${formatValidationErrors(
+      result.errors
+    )}`
+  });
+}
+function formatProviderOnboardingDossier(dossier, options = {}) {
+  assertProviderOnboardingDossier(dossier);
+  if ((options.format ?? "json") === "markdown") {
+    return formatDossierMarkdown(dossier, options.title);
+  }
+  return JSON.stringify(dossier, null, 2);
+}
+function assertProviderOnboardingDossierOptions(options) {
+  if (!options || typeof options !== "object" || Array.isArray(options)) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "Provider onboarding dossier options must be an object."
+    });
+  }
+  const catalogValidation = validateProviderCatalogArtifact(
+    options.catalogArtifact
+  );
+  if (!catalogValidation.valid) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: `Invalid provider onboarding catalog artifact: ${formatValidationErrors(
+        catalogValidation.errors
+      )}`
+    });
+  }
+  const conformanceValidation = validateProviderConformanceArtifact(
+    options.conformanceArtifact
+  );
+  if (!conformanceValidation.valid) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: `Invalid provider onboarding conformance artifact: ${formatValidationErrors(
+        conformanceValidation.errors
+      )}`
+    });
+  }
+  if (options.catalogArtifact.provider.id !== options.conformanceArtifact.provider.id) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "Provider onboarding dossier requires catalog and conformance artifacts for the same provider id."
+    });
+  }
+  if (options.generatedAt !== void 0 && (typeof options.generatedAt !== "string" || Number.isNaN(Date.parse(options.generatedAt)))) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "Provider onboarding dossier generatedAt must be an ISO timestamp."
+    });
+  }
+  if (options.dossierId !== void 0 && (typeof options.dossierId !== "string" || options.dossierId.length === 0)) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "Provider onboarding dossier dossierId must be a non-empty string."
+    });
+  }
+  if (options.forbiddenOutputValues !== void 0 && (!Array.isArray(options.forbiddenOutputValues) || options.forbiddenOutputValues.some((value) => typeof value !== "string"))) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "Provider onboarding dossier forbiddenOutputValues must be an array of strings."
+    });
+  }
+}
+function summarizeProvider(catalogArtifact) {
+  return {
+    id: catalogArtifact.provider.id,
+    displayName: catalogArtifact.provider.displayName,
+    capabilities: [...catalogArtifact.provider.capabilities],
+    protocolMode: catalogArtifact.provider.protocolMode,
+    pricing: cloneSerializable(catalogArtifact.provider.pricing),
+    paymentOptions: cloneSerializable(catalogArtifact.provider.paymentOptions)
+  };
+}
+function summarizeReadiness(catalogArtifact, conformanceArtifact, status) {
+  const reasons = [];
+  const failedChecks = [];
+  if (catalogArtifact.status === "ready") {
+    reasons.push("Catalog artifact is ready.");
+  } else {
+    reasons.push("Catalog artifact is rejected.");
+    failedChecks.push("catalog_not_ready");
+  }
+  if (conformanceArtifact.status === "verified") {
+    reasons.push("Conformance artifact is verified.");
+  } else {
+    reasons.push("Conformance artifact failed.");
+    failedChecks.push("conformance_not_verified");
+  }
+  for (const check of catalogArtifact.acceptance.failedChecks) {
+    failedChecks.push(`catalog:${check}`);
+  }
+  for (const check of conformanceArtifact.conformance.failedChecks) {
+    failedChecks.push(`conformance:${check}`);
+  }
+  return {
+    ready: status === "ready",
+    status,
+    reasons,
+    failedChecks: uniqueStrings(failedChecks)
+  };
+}
+function summarizeEvidence(catalogArtifact, conformanceArtifact) {
+  return {
+    catalog: {
+      artifactId: catalogArtifact.artifactId,
+      status: catalogArtifact.status,
+      acceptanceStatus: catalogArtifact.acceptance.status,
+      gateStatus: catalogArtifact.acceptance.gate.status,
+      accepted: catalogArtifact.acceptance.gate.accepted,
+      failedChecks: [...catalogArtifact.acceptance.failedChecks]
+    },
+    conformance: {
+      artifactId: conformanceArtifact.artifactId,
+      status: conformanceArtifact.status,
+      conformanceStatus: conformanceArtifact.conformance.status,
+      failedChecks: [...conformanceArtifact.conformance.failedChecks]
+    },
+    receipts: combineReceiptSummaries(
+      catalogArtifact.acceptance.receipts,
+      conformanceArtifact.conformance.receipts
+    ),
+    safety: {
+      acceptance: cloneSerializable(catalogArtifact.acceptance.safety),
+      conformance: cloneSerializable(conformanceArtifact.conformance.safety)
+    },
+    retrySafety: {
+      acceptance: cloneSerializable(catalogArtifact.acceptance.retrySafety),
+      conformance: cloneSerializable(conformanceArtifact.conformance.retrySafety)
+    },
+    route: {
+      acceptance: cloneSerializable(catalogArtifact.acceptance.route),
+      conformance: cloneSerializable(conformanceArtifact.conformance.route)
+    },
+    timelineEventTypes: uniqueStrings([
+      ...catalogArtifact.acceptance.timelineEventTypes,
+      ...conformanceArtifact.conformance.timelineEventTypes
+    ]),
+    telemetryEventTypes: uniqueStrings([
+      ...catalogArtifact.acceptance.telemetryEventTypes,
+      ...conformanceArtifact.conformance.telemetryEventTypes
+    ])
+  };
+}
+function combineReceiptSummaries(left, right) {
+  const byType = {};
+  for (const [type, count] of Object.entries(left.byType)) {
+    byType[type] = (byType[type] ?? 0) + Number(count);
+  }
+  for (const [type, count] of Object.entries(right.byType)) {
+    byType[type] = (byType[type] ?? 0) + Number(count);
+  }
+  return {
+    total: left.total + right.total,
+    types: uniqueStrings([...left.types, ...right.types]),
+    providers: uniqueStrings([...left.providers, ...right.providers]),
+    byType,
+    hasPaymentProof: left.hasPaymentProof || right.hasPaymentProof,
+    hasSettlementConfirmation: left.hasSettlementConfirmation || right.hasSettlementConfirmation,
+    hasProviderDelivery: left.hasProviderDelivery || right.hasProviderDelivery
+  };
+}
+function formatDossierMarkdown(dossier, title) {
+  const lines = [
+    `# ${title ?? `${dossier.provider.displayName} Onboarding Dossier`}`,
+    "",
+    `Status: ${dossier.status}`,
+    `Schema: ${dossier.schemaVersion}`,
+    `Dossier ID: ${dossier.dossierId}`,
+    `Generated: ${dossier.generatedAt}`,
+    `Provider: ${dossier.provider.id}`,
+    `Capabilities: ${formatInlineList(dossier.provider.capabilities)}`,
+    "",
+    "## Readiness",
+    `- Ready: ${String(dossier.readiness.ready)}`,
+    `- Reasons: ${formatInlineList(dossier.readiness.reasons)}`,
+    `- Failed checks: ${formatInlineList(dossier.readiness.failedChecks)}`,
+    "",
+    "## Evidence",
+    `- Catalog artifact: ${dossier.evidence.catalog.artifactId} (${dossier.evidence.catalog.status})`,
+    `- Conformance artifact: ${dossier.evidence.conformance.artifactId} (${dossier.evidence.conformance.status})`,
+    `- Receipts: ${formatInlineList(dossier.evidence.receipts.types)}`,
+    `- Timeline: ${formatInlineList(dossier.evidence.timelineEventTypes)}`,
+    "",
+    "## Safety",
+    `- Acceptance payment: ${dossier.evidence.safety.acceptance?.paymentStatus ?? "unknown"}`,
+    `- Conformance payment: ${dossier.evidence.safety.conformance?.paymentStatus ?? "unknown"}`,
+    `- Acceptance delivery: ${dossier.evidence.safety.acceptance?.deliveryStatus ?? "unknown"}`,
+    `- Conformance delivery: ${dossier.evidence.safety.conformance?.deliveryStatus ?? "unknown"}`,
+    "",
+    "## Hashes",
+    `- Catalog artifact: ${dossier.hashes.catalogArtifact}`,
+    `- Conformance artifact: ${dossier.hashes.conformanceArtifact}`,
+    `- Readiness: ${dossier.hashes.readiness}`,
+    `- Dossier: ${dossier.hashes.dossier}`
+  ];
+  return `${lines.join("\n")}
+`;
+}
+function validateProviderSummary(provider, errors) {
+  if (!isRecord(provider)) {
+    errors.push({
+      path: "provider",
+      message: "provider must be an object."
+    });
+    return;
+  }
+  validateNonEmptyString(provider.id, "provider.id", errors);
+  validateNonEmptyString(provider.displayName, "provider.displayName", errors);
+  validateNonEmptyString(provider.protocolMode, "provider.protocolMode", errors);
+  if (!Array.isArray(provider.capabilities) || provider.capabilities.some((capability) => typeof capability !== "string")) {
+    errors.push({
+      path: "provider.capabilities",
+      message: "provider.capabilities must be an array of strings."
+    });
+  }
+}
+function validateReadiness(readiness, errors) {
+  if (!isRecord(readiness)) {
+    errors.push({
+      path: "readiness",
+      message: "readiness must be an object."
+    });
+    return;
+  }
+  if (typeof readiness.ready !== "boolean") {
+    errors.push({
+      path: "readiness.ready",
+      message: "readiness.ready must be a boolean."
+    });
+  }
+  if (readiness.status !== "ready" && readiness.status !== "failed") {
+    errors.push({
+      path: "readiness.status",
+      message: 'readiness.status must be "ready" or "failed".'
+    });
+  }
+  if (!Array.isArray(readiness.reasons) || readiness.reasons.some((reason) => typeof reason !== "string")) {
+    errors.push({
+      path: "readiness.reasons",
+      message: "readiness.reasons must be an array of strings."
+    });
+  }
+  if (!Array.isArray(readiness.failedChecks) || readiness.failedChecks.some((check) => typeof check !== "string")) {
+    errors.push({
+      path: "readiness.failedChecks",
+      message: "readiness.failedChecks must be an array of strings."
+    });
+  }
+}
+function validateEvidence(evidence, errors) {
+  if (!isRecord(evidence)) {
+    errors.push({
+      path: "evidence",
+      message: "evidence must be an object."
+    });
+    return;
+  }
+  if (!isRecord(evidence.catalog)) {
+    errors.push({
+      path: "evidence.catalog",
+      message: "evidence.catalog must be an object."
+    });
+  } else {
+    validateNonEmptyString(
+      evidence.catalog.artifactId,
+      "evidence.catalog.artifactId",
+      errors
+    );
+    if (evidence.catalog.status !== "ready" && evidence.catalog.status !== "rejected") {
+      errors.push({
+        path: "evidence.catalog.status",
+        message: 'evidence.catalog.status must be "ready" or "rejected".'
+      });
+    }
+    if (typeof evidence.catalog.accepted !== "boolean") {
+      errors.push({
+        path: "evidence.catalog.accepted",
+        message: "evidence.catalog.accepted must be a boolean."
+      });
+    }
+  }
+  if (!isRecord(evidence.conformance)) {
+    errors.push({
+      path: "evidence.conformance",
+      message: "evidence.conformance must be an object."
+    });
+  } else {
+    validateNonEmptyString(
+      evidence.conformance.artifactId,
+      "evidence.conformance.artifactId",
+      errors
+    );
+    if (evidence.conformance.status !== "verified" && evidence.conformance.status !== "failed") {
+      errors.push({
+        path: "evidence.conformance.status",
+        message: 'evidence.conformance.status must be "verified" or "failed".'
+      });
+    }
+  }
+  if (!isRecord(evidence.receipts)) {
+    errors.push({
+      path: "evidence.receipts",
+      message: "evidence.receipts must be an object."
+    });
+  }
+  if (!Array.isArray(evidence.timelineEventTypes) || evidence.timelineEventTypes.some((type) => typeof type !== "string")) {
+    errors.push({
+      path: "evidence.timelineEventTypes",
+      message: "evidence.timelineEventTypes must be an array of strings."
+    });
+  }
+  if (!Array.isArray(evidence.telemetryEventTypes) || evidence.telemetryEventTypes.some((type) => typeof type !== "string")) {
+    errors.push({
+      path: "evidence.telemetryEventTypes",
+      message: "evidence.telemetryEventTypes must be an array of strings."
+    });
+  }
+}
+function validateNestedArtifacts(artifacts, errors) {
+  if (!isRecord(artifacts)) {
+    errors.push({
+      path: "artifacts",
+      message: "artifacts must be an object."
+    });
+    return;
+  }
+  const catalogValidation = validateProviderCatalogArtifact(artifacts.catalog);
+  for (const error of catalogValidation.errors) {
+    errors.push({
+      path: `artifacts.catalog.${error.path}`,
+      message: error.message
+    });
+  }
+  const conformanceValidation = validateProviderConformanceArtifact(
+    artifacts.conformance
+  );
+  for (const error of conformanceValidation.errors) {
+    errors.push({
+      path: `artifacts.conformance.${error.path}`,
+      message: error.message
+    });
+  }
+  if (isRecord(artifacts.catalog) && isRecord(artifacts.conformance) && isRecord(artifacts.catalog.provider) && isRecord(artifacts.conformance.provider) && artifacts.catalog.provider.id !== artifacts.conformance.provider.id) {
+    errors.push({
+      path: "artifacts",
+      message: "catalog and conformance artifacts must reference the same provider id."
+    });
+  }
+}
+function validateHashes(dossier, errors) {
+  if (!isRecord(dossier.hashes)) {
+    errors.push({
+      path: "hashes",
+      message: "hashes must be an object."
+    });
+    return;
+  }
+  for (const field of [
+    "catalogArtifact",
+    "conformanceArtifact",
+    "readiness",
+    "dossier"
+  ]) {
+    const value = dossier.hashes[field];
+    if (typeof value !== "string" || !/^[a-f0-9]{64}$/.test(value)) {
+      errors.push({
+        path: `hashes.${field}`,
+        message: `${field} hash must be a sha256 hex string.`
+      });
+    }
+  }
+  if (!isRecord(dossier.artifacts) || !isRecord(dossier.readiness) || errors.some((error) => error.path.startsWith("hashes."))) {
+    return;
+  }
+  const expectedHashes = {
+    catalogArtifact: hashStableJson(dossier.artifacts.catalog),
+    conformanceArtifact: hashStableJson(dossier.artifacts.conformance),
+    readiness: hashStableJson(dossier.readiness),
+    dossier: ""
+  };
+  const expectedDossierHash = hashDossierContent({
+    ...dossier,
+    hashes: expectedHashes
+  });
+  for (const [field, expected] of Object.entries({
+    ...expectedHashes,
+    dossier: expectedDossierHash
+  })) {
+    if (dossier.hashes[field] !== expected) {
+      errors.push({
+        path: `hashes.${field}`,
+        message: `${field} hash does not match dossier content.`
+      });
+    }
+  }
+}
+function sanitizeDossierOutput(value, forbiddenOutputValues) {
+  const forbiddenValues = forbiddenOutputValues.filter((entry) => entry.length > 0);
+  return redactX402Secrets(
+    replaceForbiddenValues(value, forbiddenValues, /* @__PURE__ */ new WeakSet())
+  );
+}
+function replaceForbiddenValues(value, forbiddenValues, seen) {
+  if (typeof value === "string") {
+    return forbiddenValues.reduce(
+      (current, forbidden) => current.split(forbidden).join("[REDACTED]"),
+      value
+    );
+  }
+  if (value === null || typeof value !== "object" || value instanceof Date) {
+    return value;
+  }
+  if (seen.has(value)) {
+    return "[Circular]";
+  }
+  seen.add(value);
+  if (Array.isArray(value)) {
+    const entries2 = value.map(
+      (entry) => replaceForbiddenValues(entry, forbiddenValues, seen)
+    );
+    seen.delete(value);
+    return entries2;
+  }
+  const entries = Object.fromEntries(
+    Object.entries(value).map(([key, entry]) => [
+      key,
+      replaceForbiddenValues(entry, forbiddenValues, seen)
+    ])
+  );
+  seen.delete(value);
+  return entries;
+}
+function cloneSerializable(value) {
+  if (value === void 0) {
+    return value;
+  }
+  return JSON.parse(JSON.stringify(value));
+}
+function hashStableJson(value) {
+  return createHash("sha256").update(stableStringify(value)).digest("hex");
+}
+function hashDossierContent(dossier) {
+  return hashStableJson(dossier);
+}
+function stableStringify(value) {
+  if (value === null || typeof value !== "object") {
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map((entry) => stableStringify(entry)).join(",")}]`;
+  }
+  const entries = Object.entries(value).filter(([, entry]) => entry !== void 0).sort(([left], [right]) => left.localeCompare(right));
+  return `{${entries.map(([key, entry]) => `${JSON.stringify(key)}:${stableStringify(entry)}`).join(",")}}`;
+}
+function uniqueStrings(values) {
+  return [...new Set(values)].sort((left, right) => left.localeCompare(right));
+}
+function formatInlineList(values) {
+  return values.length > 0 ? values.join(", ") : "none";
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function validateNonEmptyString(value, path, errors) {
+  if (typeof value !== "string" || value.length === 0) {
+    errors.push({
+      path,
+      message: `${path} must be a non-empty string.`
+    });
+  }
+}
+function validateIsoTimestamp(value, path, errors) {
+  if (typeof value !== "string" || Number.isNaN(Date.parse(value))) {
+    errors.push({
+      path,
+      message: `${path} must be an ISO timestamp.`
+    });
+  }
+}
+function formatValidationErrors(errors) {
+  return errors.map((error) => `${error.path}: ${error.message}`).join("; ");
+}
+
+export {
+  PROVIDER_ONBOARDING_DOSSIER_SCHEMA_VERSION,
+  createProviderOnboardingDossier,
+  validateProviderOnboardingDossier,
+  assertProviderOnboardingDossier,
+  formatProviderOnboardingDossier
+};
+//# sourceMappingURL=chunk-TDOBAMYM.js.map