@probemesh/sdk 0.1.0

package/dist/chunk-3H7UGVI6.js

@@ -0,0 +1,1117 @@
+import {
+  redactX402Secrets
+} from "./chunk-NYTV263W.js";
+import {
+  ProbeMeshError
+} from "./chunk-2ASMVLG4.js";
+
+// src/paymentOptions.ts
+function resolveProviderPaymentOption(input) {
+  const options = getProviderPaymentOptions(input);
+  const candidates = options.filter((option) => optionSupportsCapability(option, input.capability)).map((option, index) => ({
+    option,
+    index,
+    cost: pricingToCost(resolvePaymentOptionPricing(option, input.capability) ?? resolvePricing(input.pricing, input.capability)),
+    receiptTypes: option.receiptTypes ?? []
+  }));
+  const filtered = candidates.filter(
+    ({ option, receiptTypes }) => optionMatchesPaymentPreferences(option, receiptTypes, input.paymentPreferences)
+  );
+  if (filtered.length === 0) {
+    return {
+      options,
+      reason: createNoPaymentOptionReason(input, candidates.length)
+    };
+  }
+  const selected = choosePaymentOption(
+    filtered,
+    input.paymentPreferences,
+    input.paymentStrategy
+  );
+  return {
+    options,
+    selection: {
+      providerId: input.providerId,
+      optionId: selected.option.id,
+      protocolMode: selected.option.protocolMode,
+      cost: selected.cost,
+      receiptTypes: [...selected.receiptTypes],
+      score: selected.score,
+      scoreReasons: [...selected.scoreReasons],
+      metadata: cloneSerializable(selected.option.metadata)
+    }
+  };
+}
+function getProviderPaymentOptions(input) {
+  if (input.paymentOptions && input.paymentOptions.length > 0) {
+    return cloneSerializable(input.paymentOptions);
+  }
+  return [
+    {
+      id: "default",
+      protocolMode: input.providerMode ?? "local",
+      capabilities: [...input.capabilities],
+      ...input.pricing !== void 0 ? { pricing: cloneSerializable(input.pricing) } : {},
+      receiptTypes: [...input.defaultReceiptTypes ?? []]
+    }
+  ];
+}
+function validateProviderPaymentOptions(paymentOptions, path, capabilities, errors) {
+  if (paymentOptions === void 0) {
+    return;
+  }
+  if (!Array.isArray(paymentOptions) || paymentOptions.length === 0) {
+    errors.push({
+      path,
+      message: "paymentOptions must be a non-empty array when provided."
+    });
+    return;
+  }
+  const seen = /* @__PURE__ */ new Set();
+  paymentOptions.forEach((option, index) => {
+    const optionPath = `${path}.${index}`;
+    if (!isRecord(option)) {
+      errors.push({
+        path: optionPath,
+        message: "payment option must be an object."
+      });
+      return;
+    }
+    validateNonEmptyString(option.id, `${optionPath}.id`, errors);
+    validateNonEmptyString(option.protocolMode, `${optionPath}.protocolMode`, errors);
+    if (typeof option.id === "string") {
+      if (seen.has(option.id)) {
+        errors.push({
+          path: `${optionPath}.id`,
+          message: `duplicate payment option "${option.id}".`
+        });
+      }
+      seen.add(option.id);
+    }
+    if (option.capabilities !== void 0) {
+      validateStringArray(option.capabilities, `${optionPath}.capabilities`, errors);
+      if (Array.isArray(option.capabilities)) {
+        for (const capability of option.capabilities) {
+          if (typeof capability === "string" && capability.length > 0 && !capabilities.includes(capability)) {
+            errors.push({
+              path: `${optionPath}.capabilities`,
+              message: `payment option capability "${capability}" is not declared by the provider.`
+            });
+          }
+        }
+      }
+    }
+    if (option.pricing !== void 0) {
+      validatePricingDeclaration(option.pricing, `${optionPath}.pricing`, errors);
+    }
+    if (option.receiptTypes !== void 0) {
+      if (!Array.isArray(option.receiptTypes) || option.receiptTypes.some((receiptType) => !isReceiptType(receiptType))) {
+        errors.push({
+          path: `${optionPath}.receiptTypes`,
+          message: "payment option receiptTypes must contain known receipt types."
+        });
+      }
+    }
+    if (option.metadata !== void 0 && !isRecord(option.metadata)) {
+      errors.push({
+        path: `${optionPath}.metadata`,
+        message: "payment option metadata must be an object when provided."
+      });
+    }
+  });
+}
+function validatePaymentPreferences(paymentPreferences, capability) {
+  if (paymentPreferences === void 0) {
+    return;
+  }
+  if (!isRecord(paymentPreferences)) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "paymentPreferences must be an object when provided.",
+      capability
+    });
+  }
+  validatePreferenceStringArray(
+    paymentPreferences.allowedProtocols,
+    "allowedProtocols",
+    capability
+  );
+  validatePreferenceStringArray(
+    paymentPreferences.preferredProtocols,
+    "preferredProtocols",
+    capability
+  );
+  validatePreferenceStringArray(
+    paymentPreferences.blockedProtocols,
+    "blockedProtocols",
+    capability
+  );
+  validatePreferenceStringArray(
+    paymentPreferences.allowedPaymentOptions,
+    "allowedPaymentOptions",
+    capability
+  );
+  validatePreferenceStringArray(
+    paymentPreferences.preferredPaymentOptions,
+    "preferredPaymentOptions",
+    capability
+  );
+  validatePreferenceStringArray(
+    paymentPreferences.blockedPaymentOptions,
+    "blockedPaymentOptions",
+    capability
+  );
+  if (paymentPreferences.requiredReceiptTypes !== void 0 && (!Array.isArray(paymentPreferences.requiredReceiptTypes) || paymentPreferences.requiredReceiptTypes.some((receiptType) => !isReceiptType(receiptType)))) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "paymentPreferences.requiredReceiptTypes must contain known receipt types.",
+      capability
+    });
+  }
+}
+function validatePaymentStrategy(paymentStrategy, capability) {
+  if (paymentStrategy === void 0) {
+    return;
+  }
+  if (!isRecord(paymentStrategy)) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "paymentStrategy must be an object when provided.",
+      capability
+    });
+  }
+  if (!isPaymentStrategyMode(paymentStrategy.mode)) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: 'paymentStrategy.mode must be one of "provider_order", "lowest_cost", "preferred_protocol", or "receipt_coverage".',
+      capability
+    });
+  }
+  if (paymentStrategy.preferredReceiptTypes !== void 0 && (!Array.isArray(paymentStrategy.preferredReceiptTypes) || paymentStrategy.preferredReceiptTypes.some(
+    (receiptType) => !isReceiptType(receiptType)
+  ))) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "paymentStrategy.preferredReceiptTypes must contain known receipt types.",
+      capability
+    });
+  }
+}
+function mergePaymentPreferences(first, second) {
+  if (!first && !second) {
+    return void 0;
+  }
+  return compactPaymentPreferences({
+    allowedProtocols: intersectArrays(first?.allowedProtocols, second?.allowedProtocols),
+    preferredProtocols: second?.preferredProtocols ?? first?.preferredProtocols,
+    blockedProtocols: unionArrays(first?.blockedProtocols, second?.blockedProtocols),
+    allowedPaymentOptions: intersectArrays(
+      first?.allowedPaymentOptions,
+      second?.allowedPaymentOptions
+    ),
+    preferredPaymentOptions: second?.preferredPaymentOptions ?? first?.preferredPaymentOptions,
+    blockedPaymentOptions: unionArrays(
+      first?.blockedPaymentOptions,
+      second?.blockedPaymentOptions
+    ),
+    requiredReceiptTypes: unionArrays(
+      first?.requiredReceiptTypes,
+      second?.requiredReceiptTypes
+    )
+  });
+}
+function paymentSelectionToCost(selection) {
+  return selection?.cost;
+}
+function optionSupportsCapability(option, capability) {
+  return !option.capabilities || option.capabilities.includes(capability);
+}
+function optionMatchesPaymentPreferences(option, receiptTypes, preferences) {
+  if (!preferences) {
+    return true;
+  }
+  if (preferences.allowedProtocols && !preferences.allowedProtocols.includes(option.protocolMode)) {
+    return false;
+  }
+  if (preferences.blockedProtocols?.includes(option.protocolMode)) {
+    return false;
+  }
+  if (preferences.allowedPaymentOptions && !preferences.allowedPaymentOptions.includes(option.id)) {
+    return false;
+  }
+  if (preferences.blockedPaymentOptions?.includes(option.id)) {
+    return false;
+  }
+  const receiptSet = new Set(receiptTypes);
+  return (preferences.requiredReceiptTypes ?? []).every(
+    (receiptType) => receiptSet.has(receiptType)
+  );
+}
+function choosePaymentOption(candidates, preferences, strategy) {
+  const mode = strategy?.mode ?? "provider_order";
+  const ranked = [...candidates].sort(
+    (left, right) => comparePaymentOptions(left, right, preferences, strategy)
+  );
+  return ranked.map((candidate, rank) => ({
+    ...candidate,
+    score: rank,
+    scoreReasons: createScoreReasons(candidate, preferences, strategy, mode)
+  }))[0];
+}
+function preferenceIndex(preferences, value) {
+  const index = preferences.indexOf(value);
+  return index === -1 ? Number.MAX_SAFE_INTEGER : index;
+}
+function comparePaymentOptions(left, right, preferences, strategy) {
+  switch (strategy?.mode ?? "provider_order") {
+    case "lowest_cost":
+      return compareCost(left, right) || left.index - right.index;
+    case "preferred_protocol":
+      return comparePreferredProtocol(left, right, preferences) || compareCost(left, right) || left.index - right.index;
+    case "receipt_coverage":
+      return compareReceiptCoverage(left, right, preferences, strategy) || comparePreferredProtocol(left, right, preferences) || compareCost(left, right) || left.index - right.index;
+    case "provider_order":
+      return compareProviderOrder(left, right, preferences);
+  }
+}
+function compareProviderOrder(left, right, preferences) {
+  const optionPreference = preferences?.preferredPaymentOptions ?? [];
+  const protocolPreference = preferences?.preferredProtocols ?? [];
+  const optionPreferenceDelta = preferenceIndex(optionPreference, left.option.id) - preferenceIndex(optionPreference, right.option.id);
+  if (optionPreferenceDelta !== 0) {
+    return optionPreferenceDelta;
+  }
+  const protocolPreferenceDelta = preferenceIndex(protocolPreference, left.option.protocolMode) - preferenceIndex(protocolPreference, right.option.protocolMode);
+  if (protocolPreferenceDelta !== 0) {
+    return protocolPreferenceDelta;
+  }
+  return left.index - right.index;
+}
+function comparePreferredProtocol(left, right, preferences) {
+  const protocolPreference = preferences?.preferredProtocols ?? [];
+  return preferenceIndex(protocolPreference, left.option.protocolMode) - preferenceIndex(protocolPreference, right.option.protocolMode);
+}
+function compareCost(left, right) {
+  const leftCost = costSortValue(left.cost);
+  const rightCost = costSortValue(right.cost);
+  if (leftCost === rightCost) {
+    return 0;
+  }
+  return leftCost < rightCost ? -1 : 1;
+}
+function compareReceiptCoverage(left, right, preferences, strategy) {
+  return receiptCoverage(right, preferences, strategy) - receiptCoverage(left, preferences, strategy);
+}
+function receiptCoverage(candidate, preferences, strategy) {
+  const desiredReceiptTypes = strategy?.preferredReceiptTypes ?? preferences?.requiredReceiptTypes ?? [];
+  const receiptSet = new Set(candidate.receiptTypes);
+  if (desiredReceiptTypes.length > 0) {
+    return desiredReceiptTypes.filter((receiptType) => receiptSet.has(receiptType)).length;
+  }
+  return receiptSet.size;
+}
+function costSortValue(cost) {
+  return cost?.amountUsd ?? Number.POSITIVE_INFINITY;
+}
+function createScoreReasons(candidate, preferences, strategy, mode) {
+  const reasons = [`strategy:${mode}`];
+  if (mode === "provider_order") {
+    const preferredOptionIndex = preferenceIndex(
+      preferences?.preferredPaymentOptions ?? [],
+      candidate.option.id
+    );
+    const preferredProtocolIndex = preferenceIndex(
+      preferences?.preferredProtocols ?? [],
+      candidate.option.protocolMode
+    );
+    if (preferredOptionIndex !== Number.MAX_SAFE_INTEGER) {
+      reasons.push(`preferred_option:${candidate.option.id}`);
+    } else if (preferredProtocolIndex !== Number.MAX_SAFE_INTEGER) {
+      reasons.push(`preferred_protocol:${candidate.option.protocolMode}`);
+    } else {
+      reasons.push(`provider_order:${candidate.index}`);
+    }
+  }
+  if (mode === "lowest_cost" || mode === "preferred_protocol" || mode === "receipt_coverage") {
+    reasons.push(
+      candidate.cost ? `cost:${candidate.cost.amountUsd}` : "cost:unknown"
+    );
+  }
+  if (mode === "preferred_protocol") {
+    reasons.push(
+      isPreferredProtocol(candidate, preferences) ? `preferred_protocol:${candidate.option.protocolMode}` : `protocol:${candidate.option.protocolMode}`
+    );
+  }
+  if (mode === "receipt_coverage") {
+    const desiredReceiptTypes = strategy?.preferredReceiptTypes ?? preferences?.requiredReceiptTypes ?? [];
+    reasons.push(
+      desiredReceiptTypes.length > 0 ? `receipt_coverage:${receiptCoverage(candidate, preferences, strategy)}/${desiredReceiptTypes.length}` : `receipt_coverage:${candidate.receiptTypes.length}`
+    );
+    if (isPreferredProtocol(candidate, preferences)) {
+      reasons.push(`preferred_protocol:${candidate.option.protocolMode}`);
+    }
+  }
+  return reasons;
+}
+function isPreferredProtocol(candidate, preferences) {
+  return preferences?.preferredProtocols?.includes(candidate.option.protocolMode) ?? false;
+}
+function createNoPaymentOptionReason(input, capabilityCandidateCount) {
+  if (capabilityCandidateCount === 0) {
+    return `Provider "${input.providerId}" has no payment option for capability "${input.capability}".`;
+  }
+  return `Provider "${input.providerId}" has no payment option matching paymentPreferences for capability "${input.capability}".`;
+}
+function resolvePaymentOptionPricing(option, capability) {
+  return resolvePricing(option.pricing, capability);
+}
+function resolvePricing(pricing, capability) {
+  if (!pricing) {
+    return void 0;
+  }
+  if (isPricing(pricing)) {
+    return pricing;
+  }
+  const capabilityPricing = pricing[capability];
+  return isPricing(capabilityPricing) ? capabilityPricing : void 0;
+}
+function pricingToCost(pricing) {
+  if (!pricing) {
+    return void 0;
+  }
+  return {
+    amountUsd: pricing.amountUsd,
+    currency: pricing.currency ?? "USD",
+    unit: pricing.unit
+  };
+}
+function validatePreferenceStringArray(value, field, capability) {
+  if (value !== void 0 && (!Array.isArray(value) || value.some((entry) => typeof entry !== "string" || entry.length === 0))) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: `paymentPreferences.${field} must be an array of non-empty strings when provided.`,
+      capability
+    });
+  }
+}
+function validatePricingDeclaration(pricing, path, errors) {
+  if (!isRecord(pricing)) {
+    errors.push({
+      path,
+      message: "payment option pricing must be an object."
+    });
+    return;
+  }
+  if (isPricing(pricing)) {
+    validatePricing(pricing, path, errors);
+    return;
+  }
+  for (const [capability, capabilityPricing] of Object.entries(pricing)) {
+    validatePricing(capabilityPricing, `${path}.${capability}`, errors);
+  }
+}
+function validatePricing(pricing, path, errors) {
+  if (!isRecord(pricing)) {
+    errors.push({
+      path,
+      message: "payment option pricing entry must be an object."
+    });
+    return;
+  }
+  validateNonEmptyString(pricing.unit, `${path}.unit`, errors);
+  if (typeof pricing.amountUsd !== "number" || !Number.isFinite(pricing.amountUsd) || pricing.amountUsd < 0) {
+    errors.push({
+      path: `${path}.amountUsd`,
+      message: "amountUsd must be a non-negative number."
+    });
+  }
+  if (pricing.currency !== void 0 && typeof pricing.currency !== "string") {
+    errors.push({
+      path: `${path}.currency`,
+      message: "currency must be a string when provided."
+    });
+  }
+}
+function validateStringArray(value, path, errors) {
+  if (!Array.isArray(value) || value.some((entry) => typeof entry !== "string" || entry.length === 0)) {
+    errors.push({
+      path,
+      message: `${path} must be an array of non-empty strings.`
+    });
+  }
+}
+function validateNonEmptyString(value, path, errors) {
+  if (typeof value !== "string" || value.length === 0) {
+    errors.push({
+      path,
+      message: `${path} must be a non-empty string.`
+    });
+  }
+}
+function isPricing(value) {
+  return isRecord(value) && typeof value.unit === "string" && value.unit.length > 0 && typeof value.amountUsd === "number" && Number.isFinite(value.amountUsd) && value.amountUsd >= 0 && (value.currency === void 0 || typeof value.currency === "string");
+}
+function isReceiptType(value) {
+  return value === "payment_proof" || value === "settlement_confirmation" || value === "provider_delivery" || value === "provider_response_evidence" || value === "authorization_decision";
+}
+function isPaymentStrategyMode(value) {
+  return value === "provider_order" || value === "lowest_cost" || value === "preferred_protocol" || value === "receipt_coverage";
+}
+function compactPaymentPreferences(preferences) {
+  const entries = Object.entries(preferences).filter(
+    ([, value]) => value !== void 0 && (!Array.isArray(value) || value.length > 0)
+  );
+  return entries.length > 0 ? Object.fromEntries(entries) : void 0;
+}
+function intersectArrays(first, second) {
+  if (first === void 0) {
+    return second === void 0 ? void 0 : [...second];
+  }
+  if (second === void 0) {
+    return [...first];
+  }
+  const secondValues = new Set(second);
+  return first.filter((value) => secondValues.has(value));
+}
+function unionArrays(first, second) {
+  const values = [...first ?? [], ...second ?? []];
+  return values.length > 0 ? [...new Set(values)] : void 0;
+}
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function cloneSerializable(value) {
+  if (value === void 0) {
+    return value;
+  }
+  return JSON.parse(JSON.stringify(value));
+}
+
+// src/providerKit/manifest.ts
+var JSON_SCHEMA_HINT_KEYS = /* @__PURE__ */ new Set([
+  "$schema",
+  "$id",
+  "type",
+  "properties",
+  "required",
+  "items",
+  "enum",
+  "description",
+  "additionalProperties",
+  "oneOf",
+  "anyOf",
+  "allOf"
+]);
+function validateProviderManifest(manifest) {
+  const errors = [];
+  if (!isRecord2(manifest)) {
+    return {
+      valid: false,
+      errors: [
+        {
+          path: "$",
+          message: "Provider manifest must be an object."
+        }
+      ]
+    };
+  }
+  validateNonEmptyString2(manifest.id, "id", errors);
+  validateNonEmptyString2(manifest.displayName, "displayName", errors);
+  validateCapabilityList(manifest.capabilities, errors);
+  validateNonEmptyString2(manifest.protocolMode, "protocolMode", errors);
+  validateProviderPaymentOptions(
+    manifest.paymentOptions,
+    "paymentOptions",
+    Array.isArray(manifest.capabilities) ? manifest.capabilities : [],
+    errors
+  );
+  validatePricingDeclaration2(
+    manifest.pricing,
+    "pricing",
+    manifest.capabilities,
+    errors
+  );
+  validateSchemaDeclaration(
+    manifest.inputSchema,
+    "inputSchema",
+    manifest.capabilities,
+    errors
+  );
+  validateSchemaDeclaration(
+    manifest.outputSchema,
+    "outputSchema",
+    manifest.capabilities,
+    errors
+  );
+  validateReceipts(manifest.receipts, errors);
+  if (manifest.limits !== void 0) {
+    validateLimits(manifest.limits, errors);
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+function assertProviderManifest(manifest) {
+  const result = validateProviderManifest(manifest);
+  if (result.valid) {
+    return;
+  }
+  throw new ProbeMeshError({
+    code: "invalid_request",
+    message: `Invalid provider manifest: ${formatValidationErrors(result.errors)}`
+  });
+}
+function isSharedJsonSchemaLike(value) {
+  if (!isRecord2(value)) {
+    return false;
+  }
+  return Object.keys(value).some((key) => JSON_SCHEMA_HINT_KEYS.has(key));
+}
+function isSharedPricing(value) {
+  return isRecord2(value) && typeof value.unit === "string" && value.unit.length > 0 && typeof value.amountUsd === "number";
+}
+function validateCapabilityList(capabilities, errors) {
+  if (!Array.isArray(capabilities) || capabilities.length === 0) {
+    errors.push({
+      path: "capabilities",
+      message: "capabilities must be a non-empty array."
+    });
+    return;
+  }
+  const seen = /* @__PURE__ */ new Set();
+  capabilities.forEach((capability, index) => {
+    if (typeof capability !== "string" || capability.length === 0) {
+      errors.push({
+        path: `capabilities.${index}`,
+        message: "capability ids must be non-empty strings."
+      });
+      return;
+    }
+    if (seen.has(capability)) {
+      errors.push({
+        path: `capabilities.${index}`,
+        message: `duplicate capability "${capability}".`
+      });
+    }
+    seen.add(capability);
+  });
+}
+function validatePricingDeclaration2(pricing, path, capabilities, errors) {
+  if (!isRecord2(pricing)) {
+    errors.push({
+      path,
+      message: "pricing must be an object."
+    });
+    return;
+  }
+  if (isSharedPricing(pricing)) {
+    validatePricing2(pricing, path, errors);
+    return;
+  }
+  if (!Array.isArray(capabilities)) {
+    return;
+  }
+  for (const capability of capabilities) {
+    if (typeof capability !== "string" || capability.length === 0) {
+      continue;
+    }
+    validatePricing2(pricing[capability], `${path}.${capability}`, errors);
+  }
+}
+function validatePricing2(pricing, path, errors) {
+  if (!isRecord2(pricing)) {
+    errors.push({
+      path,
+      message: "pricing entry must be an object."
+    });
+    return;
+  }
+  validateNonEmptyString2(pricing.unit, `${path}.unit`, errors);
+  if (typeof pricing.amountUsd !== "number" || !Number.isFinite(pricing.amountUsd) || pricing.amountUsd < 0) {
+    errors.push({
+      path: `${path}.amountUsd`,
+      message: "amountUsd must be a non-negative number."
+    });
+  }
+  if (pricing.currency !== void 0 && typeof pricing.currency !== "string") {
+    errors.push({
+      path: `${path}.currency`,
+      message: "currency must be a string when provided."
+    });
+  }
+}
+function validateSchemaDeclaration(schema, path, capabilities, errors) {
+  if (!isRecord2(schema)) {
+    errors.push({
+      path,
+      message: `${path} must be an object.`
+    });
+    return;
+  }
+  if (isSharedJsonSchemaLike(schema)) {
+    validateSchemaLike(schema, path, errors);
+    return;
+  }
+  if (!Array.isArray(capabilities)) {
+    return;
+  }
+  for (const capability of capabilities) {
+    if (typeof capability !== "string" || capability.length === 0) {
+      continue;
+    }
+    validateSchemaLike(schema[capability], `${path}.${capability}`, errors);
+  }
+}
+function validateSchemaLike(schema, path, errors) {
+  if (!isRecord2(schema)) {
+    errors.push({
+      path,
+      message: "schema entry must be an object."
+    });
+    return;
+  }
+  if (schema.type !== void 0 && typeof schema.type !== "string") {
+    errors.push({
+      path: `${path}.type`,
+      message: "schema type must be a string when provided."
+    });
+  }
+  if (schema.properties !== void 0 && !isRecord2(schema.properties)) {
+    errors.push({
+      path: `${path}.properties`,
+      message: "schema properties must be an object when provided."
+    });
+  }
+  if (schema.required !== void 0 && (!Array.isArray(schema.required) || schema.required.some((field) => typeof field !== "string"))) {
+    errors.push({
+      path: `${path}.required`,
+      message: "schema required must be an array of strings when provided."
+    });
+  }
+}
+function validateReceipts(receipts, errors) {
+  if (!isRecord2(receipts)) {
+    errors.push({
+      path: "receipts",
+      message: "receipts must be an object."
+    });
+    return;
+  }
+  validateBoolean(receipts.payment, "receipts.payment", errors);
+  validateBoolean(receipts.delivery, "receipts.delivery", errors);
+  validateBoolean(
+    receipts.responseEvidence,
+    "receipts.responseEvidence",
+    errors
+  );
+}
+function validateLimits(limits, errors) {
+  if (!isRecord2(limits)) {
+    errors.push({
+      path: "limits",
+      message: "limits must be an object when provided."
+    });
+    return;
+  }
+  const typedLimits = limits;
+  if (typedLimits.maxRequestsPerMinute !== void 0 && (!Number.isFinite(typedLimits.maxRequestsPerMinute) || typedLimits.maxRequestsPerMinute <= 0)) {
+    errors.push({
+      path: "limits.maxRequestsPerMinute",
+      message: "maxRequestsPerMinute must be a positive number when provided."
+    });
+  }
+}
+function validateNonEmptyString2(value, path, errors) {
+  if (typeof value !== "string" || value.length === 0) {
+    errors.push({
+      path,
+      message: `${path} must be a non-empty string.`
+    });
+  }
+}
+function validateBoolean(value, path, errors) {
+  if (typeof value !== "boolean") {
+    errors.push({
+      path,
+      message: `${path} must be a boolean.`
+    });
+  }
+}
+function isRecord2(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function formatValidationErrors(errors) {
+  return errors.map((error) => `${error.path}: ${error.message}`).join("; ");
+}
+
+// src/providerCatalogArtifact.ts
+var PROVIDER_CATALOG_ARTIFACT_SCHEMA_VERSION = "probemesh.provider-catalog.v1";
+function createProviderCatalogArtifact(options) {
+  assertProviderCatalogArtifactOptions(options);
+  const artifact = {
+    schemaVersion: PROVIDER_CATALOG_ARTIFACT_SCHEMA_VERSION,
+    artifactId: options.artifactId ?? `${options.manifest.id}:${options.acceptanceReport.summary.callId ?? "unknown"}:catalog`,
+    generatedAt: options.generatedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    status: options.acceptanceReport.gate.accepted ? "ready" : "rejected",
+    provider: cloneSerializable2(options.manifest),
+    acceptance: {
+      title: options.acceptanceReport.title,
+      status: options.acceptanceReport.status,
+      gate: cloneSerializable2(options.acceptanceReport.gate),
+      failedChecks: [
+        ...options.acceptanceReport.summary.failedCheckNames
+      ],
+      receipts: cloneSerializable2(options.acceptanceReport.receipts),
+      safety: cloneSerializable2(options.acceptanceReport.safety),
+      retrySafety: cloneSerializable2(options.acceptanceReport.retrySafety),
+      route: cloneSerializable2(options.acceptanceReport.route),
+      timelineEventTypes: [
+        ...options.acceptanceReport.timelineEventTypes
+      ],
+      telemetryEventTypes: [
+        ...options.acceptanceReport.telemetryEventTypes
+      ],
+      errorCode: options.acceptanceReport.summary.errorCode
+    }
+  };
+  const sanitizedArtifact = sanitizeCatalogOutput(
+    artifact,
+    options.forbiddenOutputValues ?? []
+  );
+  assertProviderCatalogArtifact(sanitizedArtifact);
+  return sanitizedArtifact;
+}
+function formatProviderCatalogArtifact(artifact, options = {}) {
+  assertProviderCatalogArtifact(artifact);
+  if ((options.format ?? "json") === "markdown") {
+    return formatCatalogArtifactMarkdown(artifact);
+  }
+  return JSON.stringify(artifact, null, 2);
+}
+function validateProviderCatalogArtifact(artifact) {
+  const errors = [];
+  if (!isRecord3(artifact)) {
+    return {
+      valid: false,
+      errors: [
+        {
+          path: "$",
+          message: "Provider catalog artifact must be an object."
+        }
+      ]
+    };
+  }
+  if (artifact.schemaVersion !== PROVIDER_CATALOG_ARTIFACT_SCHEMA_VERSION) {
+    errors.push({
+      path: "schemaVersion",
+      message: `schemaVersion must be "${PROVIDER_CATALOG_ARTIFACT_SCHEMA_VERSION}".`
+    });
+  }
+  validateNonEmptyString3(artifact.artifactId, "artifactId", errors);
+  validateIsoTimestamp(artifact.generatedAt, "generatedAt", errors);
+  if (artifact.status !== "ready" && artifact.status !== "rejected") {
+    errors.push({
+      path: "status",
+      message: 'status must be "ready" or "rejected".'
+    });
+  }
+  const manifestValidation = validateProviderManifest(artifact.provider);
+  for (const manifestError of manifestValidation.errors) {
+    errors.push({
+      path: `provider.${manifestError.path}`,
+      message: manifestError.message
+    });
+  }
+  validateAcceptanceArtifact(artifact.acceptance, errors);
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+function assertProviderCatalogArtifact(artifact) {
+  const result = validateProviderCatalogArtifact(artifact);
+  if (result.valid) {
+    return;
+  }
+  throw new ProbeMeshError({
+    code: "invalid_request",
+    message: `Invalid provider catalog artifact: ${formatValidationErrors2(result.errors)}`
+  });
+}
+function assertProviderCatalogArtifactOptions(options) {
+  if (!options || typeof options !== "object" || Array.isArray(options)) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "Provider catalog artifact options must be an object."
+    });
+  }
+  const manifestValidation = validateProviderManifest(options.manifest);
+  if (!manifestValidation.valid) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: `Invalid provider catalog artifact manifest: ${formatValidationErrors2(
+        manifestValidation.errors
+      )}`
+    });
+  }
+  if (!options.acceptanceReport || typeof options.acceptanceReport !== "object" || Array.isArray(options.acceptanceReport)) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "Provider catalog artifact requires an acceptance report."
+    });
+  }
+  if (options.generatedAt !== void 0 && (typeof options.generatedAt !== "string" || Number.isNaN(Date.parse(options.generatedAt)))) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "Provider catalog artifact generatedAt must be an ISO timestamp."
+    });
+  }
+  if (options.artifactId !== void 0 && (typeof options.artifactId !== "string" || options.artifactId.length === 0)) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "Provider catalog artifact artifactId 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 catalog artifact forbiddenOutputValues must be an array of strings."
+    });
+  }
+}
+function formatCatalogArtifactMarkdown(artifact) {
+  const lines = [
+    `# ${artifact.provider.displayName} Provider Catalog Artifact`,
+    "",
+    `Status: ${artifact.status}`,
+    `Schema: ${artifact.schemaVersion}`,
+    `Artifact ID: ${artifact.artifactId}`,
+    `Generated: ${artifact.generatedAt}`,
+    "",
+    "## Provider",
+    `- ID: ${artifact.provider.id}`,
+    `- Display name: ${artifact.provider.displayName}`,
+    `- Protocol: ${artifact.provider.protocolMode}`,
+    `- Capabilities: ${formatInlineList(artifact.provider.capabilities)}`,
+    "",
+    "## Acceptance",
+    `- Gate: ${artifact.acceptance.gate.status}`,
+    `- Result: ${artifact.acceptance.status}`,
+    `- Failed checks: ${formatInlineList(artifact.acceptance.failedChecks)}`,
+    `- Gate reasons: ${formatInlineList(artifact.acceptance.gate.reasons)}`,
+    "",
+    "## Receipts",
+    `- Total: ${artifact.acceptance.receipts.total}`,
+    `- Types: ${formatInlineList(artifact.acceptance.receipts.types)}`,
+    `- Providers: ${formatInlineList(artifact.acceptance.receipts.providers)}`,
+    `- Payment proof: ${String(artifact.acceptance.receipts.hasPaymentProof)}`,
+    `- Settlement confirmation: ${String(
+      artifact.acceptance.receipts.hasSettlementConfirmation
+    )}`,
+    `- Provider delivery: ${String(
+      artifact.acceptance.receipts.hasProviderDelivery
+    )}`,
+    "",
+    "## Safety",
+    `- Payment: ${artifact.acceptance.safety?.paymentStatus ?? "unknown"}`,
+    `- Settlement: ${artifact.acceptance.safety?.settlementStatus ?? "unknown"}`,
+    `- Delivery: ${artifact.acceptance.safety?.deliveryStatus ?? "unknown"}`,
+    `- Money may have moved: ${String(
+      artifact.acceptance.safety?.moneyMayHaveMoved ?? false
+    )}`,
+    "",
+    "## Retry Safety",
+    `- Retryable: ${String(artifact.acceptance.retrySafety?.retryable ?? false)}`,
+    `- Safe to auto retry: ${String(
+      artifact.acceptance.retrySafety?.safeToAutoRetry ?? false
+    )}`,
+    `- Reason: ${artifact.acceptance.retrySafety?.reason ?? "unknown"}`,
+    "",
+    "## Route And Timeline",
+    `- Selected provider: ${artifact.acceptance.route?.selectedProviderId ?? "none"}`,
+    `- Stop reason: ${artifact.acceptance.route?.stopReason ?? "none"}`,
+    `- Timeline events: ${formatInlineList(artifact.acceptance.timelineEventTypes)}`,
+    `- Telemetry events: ${formatInlineList(artifact.acceptance.telemetryEventTypes)}`
+  ];
+  return `${lines.join("\n")}
+`;
+}
+function formatInlineList(values) {
+  return values && values.length > 0 ? values.join(", ") : "none";
+}
+function sanitizeCatalogOutput(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 cloneSerializable2(value) {
+  if (value === void 0) {
+    return value;
+  }
+  return JSON.parse(JSON.stringify(value));
+}
+function validateAcceptanceArtifact(acceptance, errors) {
+  if (!isRecord3(acceptance)) {
+    errors.push({
+      path: "acceptance",
+      message: "acceptance must be an object."
+    });
+    return;
+  }
+  validateNonEmptyString3(acceptance.title, "acceptance.title", errors);
+  if (acceptance.status !== "passed" && acceptance.status !== "failed") {
+    errors.push({
+      path: "acceptance.status",
+      message: 'acceptance.status must be "passed" or "failed".'
+    });
+  }
+  if (!isRecord3(acceptance.gate)) {
+    errors.push({
+      path: "acceptance.gate",
+      message: "acceptance.gate must be an object."
+    });
+  } else {
+    if (typeof acceptance.gate.accepted !== "boolean") {
+      errors.push({
+        path: "acceptance.gate.accepted",
+        message: "acceptance.gate.accepted must be a boolean."
+      });
+    }
+    if (acceptance.gate.status !== "accepted" && acceptance.gate.status !== "rejected") {
+      errors.push({
+        path: "acceptance.gate.status",
+        message: 'acceptance.gate.status must be "accepted" or "rejected".'
+      });
+    }
+  }
+  validateStringArray2(
+    acceptance.failedChecks,
+    "acceptance.failedChecks",
+    errors
+  );
+  validateReceiptSummary(acceptance.receipts, errors);
+  validateStringArray2(
+    acceptance.timelineEventTypes,
+    "acceptance.timelineEventTypes",
+    errors
+  );
+  validateStringArray2(
+    acceptance.telemetryEventTypes,
+    "acceptance.telemetryEventTypes",
+    errors
+  );
+}
+function validateReceiptSummary(receipts, errors) {
+  if (!isRecord3(receipts)) {
+    errors.push({
+      path: "acceptance.receipts",
+      message: "acceptance.receipts must be an object."
+    });
+    return;
+  }
+  if (typeof receipts.total !== "number" || !Number.isFinite(receipts.total)) {
+    errors.push({
+      path: "acceptance.receipts.total",
+      message: "acceptance.receipts.total must be a number."
+    });
+  }
+  validateStringArray2(receipts.types, "acceptance.receipts.types", errors);
+  validateStringArray2(
+    receipts.providers,
+    "acceptance.receipts.providers",
+    errors
+  );
+  for (const key of [
+    "hasPaymentProof",
+    "hasSettlementConfirmation",
+    "hasProviderDelivery"
+  ]) {
+    if (typeof receipts[key] !== "boolean") {
+      errors.push({
+        path: `acceptance.receipts.${key}`,
+        message: `acceptance.receipts.${key} must be a boolean.`
+      });
+    }
+  }
+}
+function validateStringArray2(value, path, errors) {
+  if (!Array.isArray(value) || value.some((entry) => typeof entry !== "string")) {
+    errors.push({
+      path,
+      message: `${path} must be an array of strings.`
+    });
+  }
+}
+function validateNonEmptyString3(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 string.`
+    });
+  }
+}
+function formatValidationErrors2(errors) {
+  return errors.map((error) => `${error.path}: ${error.message}`).join("; ");
+}
+function isRecord3(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+
+export {
+  resolveProviderPaymentOption,
+  getProviderPaymentOptions,
+  validateProviderPaymentOptions,
+  validatePaymentPreferences,
+  validatePaymentStrategy,
+  mergePaymentPreferences,
+  paymentSelectionToCost,
+  validateProviderManifest,
+  assertProviderManifest,
+  isSharedJsonSchemaLike,
+  PROVIDER_CATALOG_ARTIFACT_SCHEMA_VERSION,
+  createProviderCatalogArtifact,
+  formatProviderCatalogArtifact,
+  validateProviderCatalogArtifact,
+  assertProviderCatalogArtifact
+};
+//# sourceMappingURL=chunk-3H7UGVI6.js.map