@probemesh/sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,2560 @@
+import {
+  PROBEMESH_AUDIT_TRAIL_BUNDLE_SCHEMA_VERSION,
+  assertProbeMeshAuditTrailBundle,
+  createProbeMeshAuditTrailBundle,
+  createProbeMeshAuditTrailCollector,
+  formatProbeMeshAuditTrailBundle,
+  runProbeMeshAuditTrailExportCli,
+  summarizeProbeMeshAuditTrailBundle,
+  validateProbeMeshAuditTrailBundle
+} from "./chunk-HNBDX7IU.js";
+import {
+  runProviderCatalogPolicyCli
+} from "./chunk-FRFBK4SY.js";
+import {
+  getProbeMeshIntegrationTemplate,
+  listProbeMeshIntegrationTemplates,
+  renderProbeMeshIntegrationTemplate,
+  runProbeMeshInitCli
+} from "./chunk-HJK52QJF.js";
+import {
+  assertJsonSchemaLikeValue,
+  createProviderConformanceReport,
+  formatProviderConformanceReport,
+  runProviderConformance,
+  runProviderConformanceCli,
+  validateJsonSchemaLikeValue
+} from "./chunk-WKN7QOCA.js";
+import {
+  createHostedCatalogPolicyFromOnboardingDossiers,
+  createProviderCatalogFromOnboardingDossiers,
+  createProviderOnboardingDossierImportReport,
+  evaluateProviderOnboardingDossiers,
+  formatProviderOnboardingDossierImportReport,
+  parseProviderOnboardingDossierJson,
+  runProviderDossierCheckCli
+} from "./chunk-PXG54XOG.js";
+import {
+  runProviderOnboardingDossierCli
+} from "./chunk-2KWGHJYP.js";
+import {
+  PROVIDER_ONBOARDING_DOSSIER_SCHEMA_VERSION,
+  assertProviderOnboardingDossier,
+  createProviderOnboardingDossier,
+  formatProviderOnboardingDossier,
+  validateProviderOnboardingDossier
+} from "./chunk-TDOBAMYM.js";
+import {
+  PROVIDER_CONFORMANCE_ARTIFACT_SCHEMA_VERSION,
+  assertProviderConformanceArtifact,
+  createProviderConformanceArtifact,
+  formatProviderConformanceArtifact,
+  validateProviderConformanceArtifact
+} from "./chunk-UU2ZG7P7.js";
+import {
+  createX402ProviderAcceptanceReport,
+  evaluateX402ProviderAcceptanceGate,
+  formatX402ProviderAcceptanceReport,
+  runX402ProviderAcceptance,
+  runX402ProviderAcceptanceCli,
+  summarizeX402AcceptanceResult
+} from "./chunk-257Y7LN2.js";
+import {
+  createHostedRouter,
+  createProbeMesh,
+  startHostedRouter
+} from "./chunk-TV42EZSI.js";
+import {
+  PROBEMESH_CALL_AUDIT_ARTIFACT_SCHEMA_VERSION,
+  assertProbeMeshCallAuditArtifact,
+  createProbeMeshCallAuditArtifact,
+  formatProbeMeshCallAuditArtifact,
+  validateProbeMeshCallAuditArtifact
+} from "./chunk-5Q3PDYIA.js";
+import {
+  PROVIDER_CATALOG_POLICY_BUNDLE_SCHEMA_VERSION,
+  assertProviderCatalogPolicyBundle,
+  createProviderCatalogPolicyBundle,
+  formatProviderCatalogPolicyBundle,
+  validateProviderCatalogPolicyBundle,
+  verifyProviderCatalogPolicyBundleRuntime
+} from "./chunk-CXZOO3U4.js";
+import {
+  PROVIDER_CATALOG_SCHEMA_VERSION,
+  assertProviderCatalog,
+  createProviderCatalog,
+  createProviderCatalogPolicyReport,
+  evaluateProviderCatalogPolicy,
+  findProviderCatalogMatches,
+  formatProviderCatalogPolicyReport,
+  parseProviderCatalogArtifactJson,
+  summarizeProviderCatalog,
+  validateProviderCatalog
+} from "./chunk-ZJOLPBJJ.js";
+import {
+  PROVIDER_CATALOG_ARTIFACT_SCHEMA_VERSION,
+  assertProviderCatalogArtifact,
+  assertProviderManifest,
+  createProviderCatalogArtifact,
+  formatProviderCatalogArtifact,
+  getProviderPaymentOptions,
+  mergePaymentPreferences,
+  resolveProviderPaymentOption,
+  validatePaymentStrategy,
+  validateProviderCatalogArtifact,
+  validateProviderManifest
+} from "./chunk-3H7UGVI6.js";
+import {
+  redactX402Secrets
+} from "./chunk-NYTV263W.js";
+import {
+  ProbeMeshError,
+  isProbeMeshError
+} from "./chunk-2ASMVLG4.js";
+
+// src/adapters/priceLookup.ts
+var DEFAULT_PRICES_USD = {
+  BTC: 64000.25,
+  ETH: 3200.12,
+  SOL: 145.33
+};
+function createPriceLookupAdapter(options = {}) {
+  const id = options.id ?? "demo-price-provider";
+  const displayName = options.displayName ?? "Demo Price Provider";
+  const prices = options.prices ?? DEFAULT_PRICES_USD;
+  return {
+    id,
+    displayName,
+    mode: "local",
+    capabilities: ["price-lookup"],
+    pricing: {
+      unit: "call",
+      amountUsd: 0.01,
+      currency: "USD"
+    },
+    call(request, context) {
+      const input = parsePriceLookupInput(request.input, request.capability, id);
+      const symbol = input.symbol.toUpperCase();
+      const currency = (input.currency ?? "USD").toUpperCase();
+      if (currency !== "USD") {
+        throw new ProbeMeshError({
+          code: "invalid_provider_response",
+          message: `Demo price adapter only supports USD prices, received "${currency}".`,
+          capability: request.capability,
+          provider: id,
+          callId: context.callId
+        });
+      }
+      const price = prices[symbol];
+      if (price === void 0) {
+        throw new ProbeMeshError({
+          code: "provider_unavailable",
+          message: `Demo price adapter has no mock price for "${symbol}".`,
+          capability: request.capability,
+          provider: id,
+          callId: context.callId
+        });
+      }
+      return {
+        data: {
+          symbol,
+          currency,
+          price,
+          asOf: context.startedAt.toISOString(),
+          source: id
+        },
+        cost: {
+          amountUsd: 0.01,
+          currency: "USD",
+          unit: "call"
+        },
+        receiptRefs: [
+          {
+            type: "provider_delivery",
+            provider: id,
+            status: "recorded",
+            ref: `${context.callId}:provider_delivery`,
+            timestamp: context.startedAt.toISOString()
+          }
+        ]
+      };
+    }
+  };
+}
+function parsePriceLookupInput(input, capability, provider) {
+  if (!input || typeof input !== "object") {
+    throw new ProbeMeshError({
+      code: "invalid_provider_response",
+      message: "price-lookup input must be an object.",
+      capability,
+      provider
+    });
+  }
+  const candidate = input;
+  if (!candidate.symbol || typeof candidate.symbol !== "string") {
+    throw new ProbeMeshError({
+      code: "invalid_provider_response",
+      message: "price-lookup input requires a string symbol.",
+      capability,
+      provider
+    });
+  }
+  if (candidate.currency !== void 0 && typeof candidate.currency !== "string") {
+    throw new ProbeMeshError({
+      code: "invalid_provider_response",
+      message: "price-lookup currency must be a string when provided.",
+      capability,
+      provider
+    });
+  }
+  return {
+    symbol: candidate.symbol,
+    currency: candidate.currency
+  };
+}
+
+// src/demo/mockPaymentProtocol.ts
+function createMockPaymentProtocol(options = {}) {
+  const mode = options.mode ?? "mock-payment";
+  let prepareAttempts = 0;
+  return {
+    mode,
+    prepare({ manifest, request, context }) {
+      prepareAttempts += 1;
+      if (options.failPrepare || options.failPrepareOnce && prepareAttempts === 1) {
+        throw new ProbeMeshError({
+          code: "payment_failed",
+          message: `Mock payment authorization failed for provider "${manifest.id}".`,
+          capability: request.capability,
+          provider: manifest.id,
+          callId: context.callId
+        });
+      }
+      const paymentAttemptId = options.paymentAttemptId ?? `${context.callId}:mock_payment_attempt`;
+      return {
+        mode: manifest.protocolMode,
+        headers: {
+          "x-mock-payment-intent": context.callId
+        },
+        metadata: {
+          authorized: true,
+          paymentAttemptId
+        },
+        receiptRefs: [
+          {
+            type: "payment_proof",
+            provider: manifest.id,
+            status: "recorded",
+            ref: `${context.callId}:mock_payment_authorized`,
+            timestamp: context.startedAt.toISOString()
+          }
+        ],
+        safety: {
+          paymentAttemptId,
+          paymentStatus: "authorized",
+          moneyMayHaveMoved: true
+        }
+      };
+    },
+    settle({ manifest, request, context }) {
+      if (options.failSettle) {
+        throw new ProbeMeshError({
+          code: "payment_failed",
+          message: `Mock payment settlement failed for provider "${manifest.id}".`,
+          capability: request.capability,
+          provider: manifest.id,
+          callId: context.callId
+        });
+      }
+      return {
+        mode: manifest.protocolMode,
+        metadata: {
+          settled: true
+        },
+        receiptRefs: options.omitDeliveryReceipt ? [] : [
+          {
+            type: "provider_delivery",
+            provider: manifest.id,
+            status: "recorded",
+            ref: `${context.callId}:mock_delivery_recorded`,
+            timestamp: context.startedAt.toISOString()
+          }
+        ],
+        safety: {
+          settlementStatus: "settled",
+          deliveryStatus: options.omitDeliveryReceipt ? "missing" : "delivered",
+          moneyMayHaveMoved: true
+        }
+      };
+    }
+  };
+}
+
+// src/providerKit/adapter.ts
+function createAdapterFromManifest(manifest, handlers, options = {}) {
+  assertProviderManifest(manifest);
+  assertHandlers(manifest, handlers);
+  assertProtocolAdapters(options.protocolAdapters, manifest);
+  return {
+    id: manifest.id,
+    displayName: manifest.displayName,
+    mode: manifest.protocolMode,
+    capabilities: [...manifest.capabilities],
+    pricing: manifest.pricing,
+    ...manifest.paymentOptions !== void 0 ? { paymentOptions: [...manifest.paymentOptions] } : {},
+    async call(request, context) {
+      const handler = handlers[request.capability];
+      if (!handler) {
+        throw new ProbeMeshError({
+          code: "provider_unavailable",
+          message: `Provider manifest "${manifest.id}" does not expose handler for capability "${request.capability}".`,
+          capability: request.capability,
+          provider: manifest.id,
+          callId: context.callId
+        });
+      }
+      const protocolMode = context.paymentSelection?.protocolMode ?? manifest.protocolMode;
+      const protocolAdapter = findProtocolAdapter(
+        manifest,
+        options.protocolAdapters,
+        protocolMode
+      );
+      const preparation = protocolAdapter?.prepare ? await prepareProtocol(protocolAdapter, manifest, request, context, protocolMode) : void 0;
+      const preparationReceiptRefs = preparation?.receiptRefs ?? [];
+      const preparationSafety = protocolAdapter ? mergeSafety(preparationReceiptRefs, preparation?.safety) : void 0;
+      const protocolExecution = protocolAdapter ? {
+        mode: protocolMode,
+        preparation,
+        receiptRefs: [...preparationReceiptRefs],
+        safety: preparationSafety
+      } : void 0;
+      const handlerContext = protocolExecution ? {
+        ...context,
+        protocol: protocolExecution
+      } : context;
+      const result = await callHandler({
+        handler,
+        manifest,
+        request,
+        handlerContext,
+        preparation,
+        preparationSafety,
+        preparationReceiptRefs
+      });
+      const settlement = protocolAdapter?.settle ? await settleProtocol({
+        protocolAdapter,
+        manifest,
+        request,
+        handlerContext,
+        result,
+        preparation,
+        preparationSafety,
+        preparationReceiptRefs,
+        protocolMode
+      }) : void 0;
+      const protocolReceiptRefs = [
+        ...preparationReceiptRefs,
+        ...settlement?.receiptRefs ?? []
+      ];
+      const mergedReceiptRefs = [
+        ...result.receiptRefs ?? [],
+        ...protocolReceiptRefs
+      ];
+      const safety = protocolAdapter ? mergeSafety(
+        mergedReceiptRefs,
+        preparation?.safety,
+        result.safety,
+        settlement?.safety
+      ) : result.safety;
+      if (protocolExecution) {
+        protocolExecution.settlement = settlement;
+        protocolExecution.receiptRefs = protocolReceiptRefs;
+        protocolExecution.safety = safety;
+      }
+      if (!result || typeof result !== "object" || Array.isArray(result) || result.receiptRefs !== void 0 && !Array.isArray(result.receiptRefs)) {
+        return result;
+      }
+      return {
+        ...result,
+        receiptRefs: mergedReceiptRefs,
+        safety
+      };
+    }
+  };
+}
+async function prepareProtocol(protocolAdapter, manifest, request, context, protocolMode = manifest.protocolMode) {
+  try {
+    return await protocolAdapter.prepare?.({
+      manifest: manifestForProtocol(manifest, protocolMode),
+      request,
+      context
+    });
+  } catch (error) {
+    if (isProbeMeshError(error) && error.code !== "payment_failed") {
+      throw error;
+    }
+    throw new ProbeMeshError({
+      code: "payment_failed",
+      message: `Protocol "${protocolAdapter.mode}" failed while preparing payment for provider "${manifest.id}".`,
+      capability: request.capability,
+      provider: manifest.id,
+      callId: context.callId,
+      safety: mergeSafety([], {
+        paymentStatus: "failed",
+        settlementStatus: "not_attempted",
+        deliveryStatus: "not_attempted",
+        moneyMayHaveMoved: false
+      }),
+      cause: error
+    });
+  }
+}
+async function callHandler({
+  handler,
+  manifest,
+  request,
+  handlerContext,
+  preparation,
+  preparationSafety,
+  preparationReceiptRefs
+}) {
+  try {
+    return await handler(request, handlerContext);
+  } catch (error) {
+    const errorReceiptRefs = isProbeMeshError(error) ? error.receiptRefs ?? [] : [];
+    const receiptRefs = [...preparationReceiptRefs, ...errorReceiptRefs];
+    const safety = mergeSafety(
+      receiptRefs,
+      preparation?.safety,
+      preparationSafety,
+      isProbeMeshError(error) ? error.safety : void 0,
+      {
+        deliveryStatus: "failed"
+      }
+    );
+    if (!paymentWasAttempted(safety, receiptRefs)) {
+      if (isProbeMeshError(error) && (receiptRefs.length > 0 || preparationSafety)) {
+        throw new ProbeMeshError({
+          code: error.code,
+          message: error.message,
+          capability: error.capability,
+          provider: error.provider,
+          callId: error.callId,
+          receiptRefs,
+          safety,
+          cause: error
+        });
+      }
+      throw error;
+    }
+    throw new ProbeMeshError({
+      code: isProbeMeshError(error) && error.code === "timeout_after_payment" ? "timeout_after_payment" : "charged_but_no_result",
+      message: error instanceof Error ? error.message : `Provider "${manifest.id}" failed after payment was prepared.`,
+      capability: request.capability,
+      provider: manifest.id,
+      callId: handlerContext.callId,
+      receiptRefs,
+      safety,
+      cause: error
+    });
+  }
+}
+async function settleProtocol({
+  protocolAdapter,
+  manifest,
+  request,
+  handlerContext,
+  result,
+  preparation,
+  preparationSafety,
+  preparationReceiptRefs,
+  protocolMode
+}) {
+  try {
+    return await protocolAdapter.settle?.({
+      manifest: manifestForProtocol(manifest, protocolMode ?? manifest.protocolMode),
+      request,
+      context: handlerContext,
+      result,
+      preparation
+    });
+  } catch (error) {
+    const resultReceiptRefs = Array.isArray(result.receiptRefs) ? result.receiptRefs : [];
+    const receiptRefs = [...resultReceiptRefs, ...preparationReceiptRefs];
+    const hasDeliveryEvidence = receiptRefs.some(
+      (receiptRef) => receiptRef.type === "provider_delivery"
+    );
+    const safety = mergeSafety(
+      receiptRefs,
+      preparation?.safety,
+      preparationSafety,
+      result.safety,
+      {
+        settlementStatus: "failed",
+        deliveryStatus: hasDeliveryEvidence ? "delivered" : "missing"
+      }
+    );
+    throw new ProbeMeshError({
+      code: "payment_failed",
+      message: `Protocol "${protocolAdapter.mode}" failed while settling payment for provider "${manifest.id}".`,
+      capability: request.capability,
+      provider: manifest.id,
+      callId: handlerContext.callId,
+      receiptRefs,
+      safety,
+      cause: error
+    });
+  }
+}
+function mergeSafety(receiptRefs, ...partials) {
+  const safety = {
+    paymentStatus: "not_attempted",
+    settlementStatus: "not_attempted",
+    deliveryStatus: "not_attempted",
+    moneyMayHaveMoved: false
+  };
+  applyReceiptDerivedSafety(safety, receiptRefs);
+  for (const partial of partials) {
+    if (!partial) {
+      continue;
+    }
+    Object.assign(safety, partial);
+  }
+  if (safety.paymentStatus === "authorized" || safety.settlementStatus === "settled") {
+    safety.moneyMayHaveMoved = true;
+  }
+  return safety;
+}
+function applyReceiptDerivedSafety(safety, receiptRefs) {
+  if (receiptRefs.some((receiptRef) => receiptRef.type === "payment_proof")) {
+    safety.paymentStatus = "authorized";
+    safety.moneyMayHaveMoved = true;
+  }
+  if (receiptRefs.some(
+    (receiptRef) => receiptRef.type === "settlement_confirmation"
+  )) {
+    safety.settlementStatus = "settled";
+  }
+  if (receiptRefs.some((receiptRef) => receiptRef.type === "provider_delivery")) {
+    safety.deliveryStatus = "delivered";
+  }
+}
+function paymentWasAttempted(safety, receiptRefs) {
+  return safety.paymentStatus !== "not_attempted" || safety.moneyMayHaveMoved || receiptRefs.some((receiptRef) => receiptRef.type === "payment_proof");
+}
+function findProtocolAdapter(manifest, protocolAdapters, protocolMode = manifest.protocolMode) {
+  return protocolAdapters?.find(
+    (protocolAdapter) => protocolAdapter.mode === protocolMode
+  );
+}
+function manifestForProtocol(manifest, protocolMode) {
+  return protocolMode === manifest.protocolMode ? manifest : {
+    ...manifest,
+    protocolMode
+  };
+}
+function assertProtocolAdapters(protocolAdapters, manifest) {
+  if (protocolAdapters === void 0) {
+    return;
+  }
+  if (!Array.isArray(protocolAdapters) || protocolAdapters.some(
+    (protocolAdapter) => !protocolAdapter || typeof protocolAdapter !== "object" || typeof protocolAdapter.mode !== "string" || protocolAdapter.mode.length === 0
+  )) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: `Provider manifest "${manifest.id}" requires protocolAdapters to be an array of protocol adapter objects.`,
+      provider: manifest.id
+    });
+  }
+}
+function assertHandlers(manifest, handlers) {
+  if (!handlers || typeof handlers !== "object" || Array.isArray(handlers)) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: `Provider manifest "${manifest.id}" requires a handlers object.`,
+      provider: manifest.id
+    });
+  }
+  const missingCapabilities = manifest.capabilities.filter(
+    (capability) => typeof handlers[capability] !== "function"
+  );
+  if (missingCapabilities.length > 0) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: `Provider manifest "${manifest.id}" is missing handlers for capabilities: ${missingCapabilities.join(
+        ", "
+      )}.`,
+      provider: manifest.id
+    });
+  }
+}
+
+// src/demo/paidPriceLookupProvider.ts
+var DEFAULT_PAID_PRICES_USD = {
+  BTC: 64000.25,
+  ETH: 3200.12,
+  SOL: 145.33
+};
+function createPaidPriceLookupProvider(options = {}) {
+  const id = options.id ?? "paid-price-provider";
+  const displayName = options.displayName ?? "Paid Price Provider";
+  const amountUsd = options.amountUsd ?? 0.01;
+  const prices = options.prices ?? DEFAULT_PAID_PRICES_USD;
+  const failureMode = options.failureMode ?? "none";
+  const mockPaymentOptions = {
+    ...options.mockPayment,
+    omitDeliveryReceipt: options.mockPayment?.omitDeliveryReceipt || failureMode === "missing_delivery_receipt"
+  };
+  const manifest = createPaidPriceLookupManifest({
+    id,
+    displayName,
+    amountUsd
+  });
+  return createAdapterFromManifest(
+    manifest,
+    {
+      "price-lookup": (request, context) => {
+        const input = parsePriceLookupInput2(request.input, id, context.callId);
+        const symbol = input.symbol.toUpperCase();
+        const currency = (input.currency ?? "USD").toUpperCase();
+        if (failureMode === "timeout_after_payment") {
+          throw new ProbeMeshError({
+            code: "timeout_after_payment",
+            message: `Paid price lookup demo timed out after payment authorization for provider "${id}".`,
+            capability: request.capability,
+            provider: id,
+            callId: context.callId
+          });
+        }
+        if (currency !== "USD") {
+          throw new ProbeMeshError({
+            code: "invalid_provider_response",
+            message: `Paid price lookup demo only supports USD prices, received "${currency}".`,
+            capability: request.capability,
+            provider: id,
+            callId: context.callId
+          });
+        }
+        const price = prices[symbol];
+        if (price === void 0) {
+          throw new ProbeMeshError({
+            code: "provider_unavailable",
+            message: `Paid price lookup demo has no mock price for "${symbol}".`,
+            capability: request.capability,
+            provider: id,
+            callId: context.callId
+          });
+        }
+        return {
+          data: {
+            symbol,
+            currency,
+            price,
+            asOf: context.startedAt.toISOString(),
+            source: id,
+            protocolMode: context.protocol?.mode,
+            paymentAuthorized: context.protocol?.preparation?.metadata?.authorized === true
+          }
+        };
+      }
+    },
+    {
+      protocolAdapters: [createMockPaymentProtocol(mockPaymentOptions)]
+    }
+  );
+}
+function createPaidPriceLookupManifest(options) {
+  return {
+    id: options.id,
+    displayName: options.displayName,
+    capabilities: ["price-lookup"],
+    protocolMode: "mock-payment",
+    pricing: {
+      unit: "call",
+      amountUsd: options.amountUsd,
+      currency: "USD"
+    },
+    inputSchema: {
+      type: "object",
+      properties: {
+        symbol: {
+          type: "string"
+        },
+        currency: {
+          type: "string"
+        }
+      },
+      required: ["symbol"]
+    },
+    outputSchema: {
+      type: "object",
+      properties: {
+        symbol: {
+          type: "string"
+        },
+        currency: {
+          type: "string"
+        },
+        price: {
+          type: "number"
+        },
+        paymentAuthorized: {
+          type: "boolean"
+        }
+      },
+      required: ["symbol", "currency", "price", "paymentAuthorized"]
+    },
+    receipts: {
+      payment: true,
+      delivery: true,
+      responseEvidence: false
+    },
+    limits: {
+      maxRequestsPerMinute: 60
+    }
+  };
+}
+function parsePriceLookupInput2(input, provider, callId) {
+  if (!input || typeof input !== "object") {
+    throw new ProbeMeshError({
+      code: "invalid_provider_response",
+      message: "price-lookup input must be an object.",
+      capability: "price-lookup",
+      provider,
+      callId
+    });
+  }
+  const candidate = input;
+  if (typeof candidate.symbol !== "string" || candidate.symbol.length === 0) {
+    throw new ProbeMeshError({
+      code: "invalid_provider_response",
+      message: "price-lookup input requires a string symbol.",
+      capability: "price-lookup",
+      provider,
+      callId
+    });
+  }
+  if (candidate.currency !== void 0 && typeof candidate.currency !== "string") {
+    throw new ProbeMeshError({
+      code: "invalid_provider_response",
+      message: "price-lookup currency must be a string when provided.",
+      capability: "price-lookup",
+      provider,
+      callId
+    });
+  }
+  return {
+    symbol: candidate.symbol,
+    currency: candidate.currency
+  };
+}
+
+// src/protocols/apiKeyProtocol.ts
+var DEFAULT_MODE = "api-key";
+var DEFAULT_HEADER_NAME = "x-api-key";
+var DEFAULT_AUTHORIZATION_HEADER = "authorization";
+var DEFAULT_AUTHORIZATION_SCHEME = "Bearer";
+function createApiKeyProtocol(options = {}) {
+  assertApiKeyProtocolOptions(options);
+  const mode = options.mode ?? DEFAULT_MODE;
+  return {
+    mode,
+    async prepare({ manifest, request, context }) {
+      if (options.providerId && options.providerId !== manifest.id) {
+        throw new ProbeMeshError({
+          code: "invalid_request",
+          message: `API key protocol is configured for provider "${options.providerId}", but manifest "${manifest.id}" was used.`,
+          capability: request.capability,
+          provider: manifest.id,
+          callId: context.callId,
+          safety: noPaymentSafety()
+        });
+      }
+      const apiKey = await resolveApiKey(options);
+      if (!apiKey) {
+        throw new ProbeMeshError({
+          code: "unauthorized",
+          message: `API key is required for provider "${manifest.id}".`,
+          capability: request.capability,
+          provider: manifest.id,
+          callId: context.callId,
+          safety: noPaymentSafety()
+        });
+      }
+      const placement = options.placement ?? "header";
+      const headerName = headerNameForPlacement(options, placement);
+      const headers = {
+        [headerName]: headerValueForPlacement(options, placement, apiKey)
+      };
+      const preparation = {
+        mode: manifest.protocolMode,
+        metadata: {
+          authorized: true,
+          credentialPresent: true,
+          placement,
+          headerName,
+          providerId: manifest.id
+        },
+        receiptRefs: [
+          {
+            type: "authorization_decision",
+            provider: manifest.id,
+            status: "recorded",
+            ref: `${context.callId}:api_key_authorized`,
+            timestamp: context.startedAt.toISOString()
+          }
+        ],
+        safety: noPaymentPreparationSafety()
+      };
+      Object.defineProperty(preparation, "headers", {
+        value: Object.freeze(headers),
+        enumerable: false,
+        configurable: false,
+        writable: false
+      });
+      return preparation;
+    }
+  };
+}
+function assertApiKeyProtocolOptions(options) {
+  if (options.providerId !== void 0 && (typeof options.providerId !== "string" || options.providerId.length === 0)) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "API key protocol providerId must be a non-empty string when provided."
+    });
+  }
+  if (options.apiKey !== void 0 && (typeof options.apiKey !== "string" || options.apiKey.length === 0)) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "API key protocol apiKey must be a non-empty string when provided."
+    });
+  }
+  if (options.resolveApiKey !== void 0 && typeof options.resolveApiKey !== "function") {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "API key protocol resolveApiKey must be a function when provided."
+    });
+  }
+  if (options.placement !== void 0 && options.placement !== "header" && options.placement !== "authorization") {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: 'API key protocol placement must be "header" or "authorization".'
+    });
+  }
+  if (options.headerName !== void 0 && (typeof options.headerName !== "string" || options.headerName.length === 0)) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "API key protocol headerName must be a non-empty string when provided."
+    });
+  }
+  if (options.authorizationScheme !== void 0 && (typeof options.authorizationScheme !== "string" || options.authorizationScheme.length === 0)) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "API key protocol authorizationScheme must be a non-empty string when provided."
+    });
+  }
+}
+async function resolveApiKey(options) {
+  return options.apiKey ?? await options.resolveApiKey?.();
+}
+function headerNameForPlacement(options, placement) {
+  if (placement === "authorization") {
+    return options.headerName ?? DEFAULT_AUTHORIZATION_HEADER;
+  }
+  return options.headerName ?? DEFAULT_HEADER_NAME;
+}
+function headerValueForPlacement(options, placement, apiKey) {
+  if (placement === "authorization") {
+    return `${options.authorizationScheme ?? DEFAULT_AUTHORIZATION_SCHEME} ${apiKey}`;
+  }
+  return apiKey;
+}
+function noPaymentSafety() {
+  return {
+    paymentStatus: "not_attempted",
+    settlementStatus: "not_attempted",
+    deliveryStatus: "not_attempted",
+    moneyMayHaveMoved: false
+  };
+}
+function noPaymentPreparationSafety() {
+  return {
+    paymentStatus: "not_attempted",
+    settlementStatus: "not_attempted",
+    moneyMayHaveMoved: false
+  };
+}
+
+// src/protocols/x402Evm.ts
+import { x402Client } from "@x402/core/client";
+import {
+  registerExactEvmScheme
+} from "@x402/evm/exact/client";
+import {
+  getDefaultAsset,
+  toClientEvmSigner
+} from "@x402/evm";
+import { createPublicClient, http } from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+var DEFAULT_NETWORK = "eip155:84532";
+var DEFAULT_AMOUNT = "10000";
+var DEFAULT_FACILITATOR_URL = "https://x402.org/facilitator";
+var REQUIRED_TESTNET_ENV = [
+  "PROBEMESH_X402_EVM_PRIVATE_KEY",
+  "PROBEMESH_X402_PAY_TO",
+  "PROBEMESH_X402_ASSET"
+];
+var OPTIONAL_TESTNET_ENV = [
+  "PROBEMESH_X402_FACILITATOR_URL",
+  "PROBEMESH_X402_RPC_URL",
+  "PROBEMESH_X402_NETWORK",
+  "PROBEMESH_X402_AMOUNT",
+  "PROBEMESH_X402_ASSET_NAME",
+  "PROBEMESH_X402_ASSET_VERSION"
+];
+function resolveX402EvmTestnetConfig(options = {}) {
+  assertTestnetConfigOptions(options);
+  const env = options.env ?? process.env;
+  const defaultNetwork = options.defaultNetwork ?? DEFAULT_NETWORK;
+  const defaultAmount = options.defaultAmount ?? DEFAULT_AMOUNT;
+  const defaultFacilitatorUrl = options.defaultFacilitatorUrl ?? DEFAULT_FACILITATOR_URL;
+  const missingEnv = REQUIRED_TESTNET_ENV.filter((name) => !env[name]);
+  if (missingEnv.length > 0) {
+    return {
+      ok: false,
+      skip: {
+        reason: "Missing opt-in live x402 EVM environment variables.",
+        missingEnv,
+        requiredEnv: [...REQUIRED_TESTNET_ENV],
+        optionalEnv: [...OPTIONAL_TESTNET_ENV],
+        defaults: {
+          network: defaultNetwork,
+          amount: defaultAmount,
+          facilitatorUrl: defaultFacilitatorUrl
+        }
+      }
+    };
+  }
+  const network = requireEvmNetwork(
+    env.PROBEMESH_X402_NETWORK ?? defaultNetwork,
+    "PROBEMESH_X402_NETWORK"
+  );
+  const amount = requirePositiveIntegerString(
+    env.PROBEMESH_X402_AMOUNT ?? defaultAmount,
+    "PROBEMESH_X402_AMOUNT"
+  );
+  const facilitatorUrl = requireHttpUrl(
+    env.PROBEMESH_X402_FACILITATOR_URL ?? defaultFacilitatorUrl,
+    "PROBEMESH_X402_FACILITATOR_URL"
+  );
+  const rpcUrl = env.PROBEMESH_X402_RPC_URL ? requireHttpUrl(env.PROBEMESH_X402_RPC_URL, "PROBEMESH_X402_RPC_URL") : void 0;
+  const privateKey = requirePrivateKey(
+    env.PROBEMESH_X402_EVM_PRIVATE_KEY,
+    "PROBEMESH_X402_EVM_PRIVATE_KEY"
+  );
+  const asset = requireEvmAddress(
+    env.PROBEMESH_X402_ASSET,
+    "PROBEMESH_X402_ASSET"
+  );
+  const payTo = requireEvmAddress(
+    env.PROBEMESH_X402_PAY_TO,
+    "PROBEMESH_X402_PAY_TO"
+  );
+  const assetMetadata = resolveTestnetAssetMetadata({
+    network,
+    asset,
+    env
+  });
+  const config = {
+    privateKey,
+    network,
+    rpcUrl,
+    facilitatorUrl,
+    amount,
+    asset,
+    payTo,
+    assetMetadata
+  };
+  return {
+    ok: true,
+    config,
+    summary: {
+      network,
+      rpcConfigured: typeof rpcUrl === "string",
+      facilitatorUrl,
+      amount,
+      asset,
+      payTo,
+      assetMetadata,
+      privateKeyConfigured: true
+    }
+  };
+}
+function createX402EvmSigner(options = {}) {
+  assertX402EvmSignerOptions(options);
+  const signer = resolveClientEvmSigner(options);
+  const networks = resolveNetworks(options);
+  const client = new x402Client();
+  registerExactEvmScheme(client, {
+    signer,
+    networks,
+    schemeOptions: options.schemeOptions
+  });
+  return async (input) => {
+    try {
+      const paymentPayload = await client.createPaymentPayload(
+        input.paymentRequired
+      );
+      return {
+        paymentPayload,
+        payer: signer.address,
+        metadata: {
+          signer: "evm",
+          scheme: "exact",
+          address: signer.address,
+          networks,
+          rpcConfigured: typeof options.rpcUrl === "string"
+        }
+      };
+    } catch (error) {
+      throw new ProbeMeshError({
+        code: "payment_failed",
+        message: `x402 EVM signer failed to create a payment payload for provider "${input.providerId}".`,
+        capability: input.capability,
+        provider: input.providerId,
+        callId: input.callId,
+        safety: {
+          paymentStatus: "failed",
+          settlementStatus: "not_attempted",
+          deliveryStatus: "not_attempted",
+          moneyMayHaveMoved: false
+        },
+        cause: error
+      });
+    }
+  };
+}
+function createX402HttpFacilitator(options = {}) {
+  assertX402HttpFacilitatorOptions(options);
+  const baseUrl = (options.url ?? DEFAULT_FACILITATOR_URL).replace(/\/+$/, "");
+  const timeoutMs = options.timeoutMs;
+  return {
+    async verify(input) {
+      const response = await postFacilitatorJson({
+        baseUrl,
+        path: "verify",
+        timeoutMs,
+        createAuthHeaders: options.createAuthHeaders,
+        body: {
+          x402Version: input.paymentPayload.x402Version,
+          paymentPayload: input.paymentPayload,
+          paymentRequirements: input.paymentRequirements
+        },
+        providerId: input.providerId,
+        capability: input.capability,
+        callId: input.callId,
+        unsafeAfterPayment: false
+      });
+      return response;
+    },
+    async settle(input) {
+      const response = await postFacilitatorJson({
+        baseUrl,
+        path: "settle",
+        timeoutMs,
+        createAuthHeaders: options.createAuthHeaders,
+        body: {
+          x402Version: input.paymentPayload.x402Version,
+          paymentPayload: input.paymentPayload,
+          paymentRequirements: input.paymentRequirements
+        },
+        providerId: input.providerId,
+        capability: input.capability,
+        callId: input.callId,
+        unsafeAfterPayment: true
+      });
+      return response;
+    }
+  };
+}
+function resolveClientEvmSigner(options) {
+  const signer = options.signer ?? (options.privateKey ? privateKeyToAccount(options.privateKey) : void 0);
+  if (!signer) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "x402 EVM signer requires either privateKey or signer."
+    });
+  }
+  if (options.rpcUrl) {
+    const publicClient = createPublicClient({
+      transport: http(options.rpcUrl)
+    });
+    return toClientEvmSigner(signer, publicClient);
+  }
+  return signer;
+}
+function resolveNetworks(options) {
+  if (options.networks !== void 0) {
+    return options.networks;
+  }
+  return [options.network ?? DEFAULT_NETWORK];
+}
+function assertX402EvmSignerOptions(options) {
+  if (!options || typeof options !== "object" || Array.isArray(options)) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "x402 EVM signer options must be an object."
+    });
+  }
+  if (options.privateKey !== void 0 && (typeof options.privateKey !== "string" || !options.privateKey.startsWith("0x") || options.privateKey.length !== 66)) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "x402 EVM signer privateKey must be a 32-byte 0x-prefixed hex string."
+    });
+  }
+  if (options.signer !== void 0) {
+    assertClientSigner(options.signer);
+  }
+  if (options.privateKey !== void 0 && options.signer !== void 0) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "x402 EVM signer accepts either privateKey or signer, not both."
+    });
+  }
+  if (options.network !== void 0 && !isValidEvmNetwork(options.network)) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "x402 EVM signer network must use CAIP-2 eip155:<chainId> format."
+    });
+  }
+  if (options.networks !== void 0 && (!Array.isArray(options.networks) || options.networks.length === 0 || options.networks.some((network) => !isValidEvmNetwork(network)))) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "x402 EVM signer networks must be a non-empty array of CAIP-2 eip155:<chainId> values."
+    });
+  }
+  if (options.network !== void 0 && options.networks !== void 0) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "x402 EVM signer accepts either network or networks, not both."
+    });
+  }
+  if (options.rpcUrl !== void 0 && (typeof options.rpcUrl !== "string" || options.rpcUrl.length === 0)) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "x402 EVM signer rpcUrl must be a non-empty string when provided."
+    });
+  }
+}
+function assertX402HttpFacilitatorOptions(options) {
+  if (!options || typeof options !== "object" || Array.isArray(options)) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "x402 HTTP facilitator options must be an object."
+    });
+  }
+  if (options.url !== void 0 && (typeof options.url !== "string" || options.url.length === 0)) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "x402 HTTP facilitator url must be a non-empty string when provided."
+    });
+  }
+  if (options.createAuthHeaders !== void 0 && typeof options.createAuthHeaders !== "function") {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "x402 HTTP facilitator createAuthHeaders must be a function when provided."
+    });
+  }
+  if (options.timeoutMs !== void 0 && (!Number.isFinite(options.timeoutMs) || options.timeoutMs <= 0)) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "x402 HTTP facilitator timeoutMs must be a positive number when provided."
+    });
+  }
+}
+async function postFacilitatorJson(options) {
+  const controller = new AbortController();
+  const timeout = options.timeoutMs !== void 0 ? setTimeout(() => controller.abort(), options.timeoutMs) : void 0;
+  try {
+    const authHeaders = await resolveFacilitatorAuthHeaders(
+      options.createAuthHeaders,
+      options.path
+    );
+    const response = await fetch(`${options.baseUrl}/${options.path}`, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        ...authHeaders
+      },
+      redirect: "follow",
+      body: JSON.stringify(toJsonSafe(options.body)),
+      signal: controller.signal
+    });
+    const responseText = await response.text();
+    const responseBody = parseFacilitatorJson(
+      responseText,
+      options.path,
+      options.providerId,
+      options.capability,
+      options.callId,
+      options.unsafeAfterPayment
+    );
+    if (!response.ok && !isFacilitatorLifecycleResult(responseBody)) {
+      throw facilitatorRequestError({
+        path: options.path,
+        providerId: options.providerId,
+        capability: options.capability,
+        callId: options.callId,
+        unsafeAfterPayment: options.unsafeAfterPayment,
+        message: `x402 HTTP facilitator ${options.path} request failed with HTTP ${response.status}.`
+      });
+    }
+    return responseBody;
+  } catch (error) {
+    if (error instanceof ProbeMeshError) {
+      throw error;
+    }
+    if (isAbortError(error)) {
+      throw facilitatorRequestError({
+        path: options.path,
+        providerId: options.providerId,
+        capability: options.capability,
+        callId: options.callId,
+        unsafeAfterPayment: options.unsafeAfterPayment,
+        message: `x402 HTTP facilitator ${options.path} request timed out after ${options.timeoutMs}ms.`
+      });
+    }
+    throw facilitatorRequestError({
+      path: options.path,
+      providerId: options.providerId,
+      capability: options.capability,
+      callId: options.callId,
+      unsafeAfterPayment: options.unsafeAfterPayment,
+      message: `x402 HTTP facilitator ${options.path} request failed.`
+    });
+  } finally {
+    if (timeout) {
+      clearTimeout(timeout);
+    }
+  }
+}
+async function resolveFacilitatorAuthHeaders(createAuthHeaders, path) {
+  if (!createAuthHeaders) {
+    return {};
+  }
+  const headers = await createAuthHeaders();
+  const selected = headers[path] ?? {};
+  if (!selected || typeof selected !== "object" || Array.isArray(selected) || Object.entries(selected).some(
+    ([key, value]) => typeof key !== "string" || key.length === 0 || typeof value !== "string"
+  )) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "x402 HTTP facilitator auth headers must be records of string values."
+    });
+  }
+  return selected;
+}
+function parseFacilitatorJson(responseText, path, providerId, capability, callId, unsafeAfterPayment) {
+  try {
+    return responseText ? JSON.parse(responseText) : {};
+  } catch {
+    throw facilitatorRequestError({
+      path,
+      providerId,
+      capability,
+      callId,
+      unsafeAfterPayment,
+      message: `x402 HTTP facilitator ${path} response was not valid JSON.`
+    });
+  }
+}
+function isFacilitatorLifecycleResult(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value) && ("isValid" in value || "success" in value);
+}
+function facilitatorRequestError(options) {
+  return new ProbeMeshError({
+    code: "payment_failed",
+    message: options.message,
+    capability: options.capability,
+    provider: options.providerId,
+    callId: options.callId,
+    safety: options.unsafeAfterPayment ? {
+      paymentStatus: "authorized",
+      settlementStatus: "failed",
+      deliveryStatus: "missing",
+      moneyMayHaveMoved: true
+    } : {
+      paymentStatus: "failed",
+      settlementStatus: "not_attempted",
+      deliveryStatus: "not_attempted",
+      moneyMayHaveMoved: false
+    }
+  });
+}
+function toJsonSafe(value) {
+  if (typeof value === "bigint") {
+    return value.toString();
+  }
+  if (Array.isArray(value)) {
+    return value.map((entry) => toJsonSafe(entry));
+  }
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, entry]) => [key, toJsonSafe(entry)])
+    );
+  }
+  return value;
+}
+function isAbortError(error) {
+  return !!error && typeof error === "object" && "name" in error && error.name === "AbortError";
+}
+function assertTestnetConfigOptions(options) {
+  if (!options || typeof options !== "object" || Array.isArray(options)) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "x402 EVM testnet config options must be an object."
+    });
+  }
+  if (options.env !== void 0 && (!options.env || typeof options.env !== "object" || Array.isArray(options.env))) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "x402 EVM testnet config env must be an object when provided."
+    });
+  }
+  if (options.defaultNetwork !== void 0 && !isValidEvmNetwork(options.defaultNetwork)) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "x402 EVM testnet defaultNetwork must use CAIP-2 eip155:<chainId> format."
+    });
+  }
+  if (options.defaultAmount !== void 0) {
+    requirePositiveIntegerString(
+      options.defaultAmount,
+      "x402 EVM testnet defaultAmount"
+    );
+  }
+  if (options.defaultFacilitatorUrl !== void 0) {
+    requireHttpUrl(
+      options.defaultFacilitatorUrl,
+      "x402 EVM testnet defaultFacilitatorUrl"
+    );
+  }
+}
+function assertClientSigner(signer) {
+  if (!signer || typeof signer !== "object" || Array.isArray(signer) || typeof signer.address !== "string" || !signer.address.startsWith("0x") || typeof signer.signTypedData !== "function") {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "x402 EVM signer signer must expose address and signTypedData(...)."
+    });
+  }
+}
+function isValidEvmNetwork(network) {
+  return typeof network === "string" && /^eip155:[1-9][0-9]*$/.test(network);
+}
+function requireEvmNetwork(value, field) {
+  if (!isValidEvmNetwork(value)) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: `${field} must use CAIP-2 eip155:<chainId> format.`
+    });
+  }
+  return value;
+}
+function requirePrivateKey(value, field) {
+  if (typeof value !== "string" || !value.startsWith("0x") || value.length !== 66 || !/^0x[0-9a-fA-F]{64}$/.test(value)) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: `${field} must be a 32-byte 0x-prefixed hex string.`
+    });
+  }
+  return value;
+}
+function requireEvmAddress(value, field) {
+  if (typeof value !== "string" || !/^0x[0-9a-fA-F]{40}$/.test(value)) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: `${field} must be a 20-byte 0x-prefixed EVM address.`
+    });
+  }
+  return value;
+}
+function requirePositiveIntegerString(value, field) {
+  if (typeof value !== "string" || !/^[1-9][0-9]*$/.test(value)) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: `${field} must be a positive integer string.`
+    });
+  }
+  return value;
+}
+function requireHttpUrl(value, field) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: `${field} must be a non-empty HTTP(S) URL.`
+    });
+  }
+  try {
+    const url = new URL(value);
+    if (url.protocol !== "http:" && url.protocol !== "https:") {
+      throw new Error("invalid protocol");
+    }
+  } catch {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: `${field} must be a valid HTTP(S) URL.`
+    });
+  }
+  return value;
+}
+function resolveTestnetAssetMetadata(options) {
+  const configuredName = options.env.PROBEMESH_X402_ASSET_NAME;
+  const configuredVersion = options.env.PROBEMESH_X402_ASSET_VERSION;
+  if (configuredName !== void 0 && configuredName.length === 0) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "PROBEMESH_X402_ASSET_NAME must be non-empty when provided."
+    });
+  }
+  if (configuredVersion !== void 0 && configuredVersion.length === 0) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "PROBEMESH_X402_ASSET_VERSION must be non-empty when provided."
+    });
+  }
+  if (configuredName && configuredVersion) {
+    return {
+      name: configuredName,
+      version: configuredVersion
+    };
+  }
+  try {
+    const defaultAsset = getDefaultAsset(options.network);
+    if (defaultAsset.address.toLowerCase() === options.asset.toLowerCase()) {
+      return {
+        name: configuredName ?? defaultAsset.name,
+        version: configuredVersion ?? defaultAsset.version
+      };
+    }
+  } catch {
+  }
+  return {
+    name: configuredName ?? "USDC",
+    version: configuredVersion ?? "2"
+  };
+}
+
+// src/protocols/x402Protocol.ts
+import {
+  decodePaymentRequiredHeader,
+  decodePaymentSignatureHeader,
+  encodePaymentRequiredHeader,
+  encodePaymentResponseHeader,
+  encodePaymentSignatureHeader
+} from "@x402/core/http";
+var DEFAULT_MODE2 = "x402";
+var DEFAULT_PAYER = "local-x402-agent";
+var DEFAULT_NETWORK2 = "eip155:84532";
+var DEFAULT_ASSET = "USDC";
+var DEFAULT_AMOUNT2 = "10000";
+var DEFAULT_PAY_TO = "probemesh-local-x402-provider";
+var DEFAULT_TIMEOUT_SECONDS = 60;
+var PAYMENT_REQUIRED_HEADER = "PAYMENT-REQUIRED";
+var PAYMENT_SIGNATURE_HEADER = "PAYMENT-SIGNATURE";
+var PAYMENT_RESPONSE_HEADER = "PAYMENT-RESPONSE";
+function createX402Protocol(options = {}) {
+  assertX402ProtocolOptions(options);
+  const mode = options.mode ?? X402_PROTOCOL_DEFAULT_MODE;
+  const signer = options.signer ?? createX402LocalSigner({
+    payer: options.payer,
+    paymentId: options.paymentId
+  });
+  const facilitator = options.facilitator ?? createX402LocalFacilitator();
+  return {
+    mode,
+    async prepare({ manifest, request, context }) {
+      assertProviderMatches(
+        options.providerId,
+        manifest.id,
+        request.capability,
+        context.callId
+      );
+      const paymentRequired = await resolvePaymentRequired({
+        options,
+        manifest,
+        request,
+        context
+      });
+      const paymentRequirements = paymentRequired.accepts[0];
+      const paymentId = options.paymentId ?? `${context.callId}:x402_payment`;
+      const payer = options.payer ?? DEFAULT_PAYER;
+      const signerResult = await signer({
+        paymentRequired,
+        paymentRequirements,
+        manifest,
+        request,
+        context,
+        providerId: manifest.id,
+        capability: request.capability,
+        callId: context.callId,
+        paymentId,
+        payer
+      });
+      assertSignerResult(signerResult, request.capability, manifest.id, context.callId);
+      assertPaymentPayload(
+        signerResult.paymentPayload,
+        paymentRequirements,
+        request.capability,
+        manifest.id,
+        context.callId
+      );
+      const verifyResult = await facilitator.verify({
+        paymentPayload: signerResult.paymentPayload,
+        paymentRequirements,
+        paymentRequired,
+        manifest,
+        request,
+        context,
+        providerId: manifest.id,
+        capability: request.capability,
+        callId: context.callId
+      });
+      assertVerifyResult(
+        verifyResult,
+        request.capability,
+        manifest.id,
+        context.callId
+      );
+      if (!verifyResult.isValid) {
+        throw new ProbeMeshError({
+          code: "payment_failed",
+          message: verifyResult.invalidMessage ?? `x402 facilitator rejected payment for provider "${manifest.id}".`,
+          capability: request.capability,
+          provider: manifest.id,
+          callId: context.callId,
+          safety: failedPaymentSafety()
+        });
+      }
+      const headers = {
+        [PAYMENT_REQUIRED_HEADER]: encodePaymentRequiredHeader(paymentRequired),
+        [PAYMENT_SIGNATURE_HEADER]: encodePaymentSignatureHeader(
+          signerResult.paymentPayload
+        )
+      };
+      const resolvedPayer = verifyResult.payer ?? signerResult.payer ?? getPayloadString(signerResult.paymentPayload, "payer") ?? payer;
+      const paymentAttemptId = `${paymentId}:attempt`;
+      const preparation = {
+        mode: manifest.protocolMode,
+        metadata: {
+          authorized: true,
+          verified: true,
+          x402Version: 2,
+          paymentId,
+          paymentAttemptId,
+          payer: resolvedPayer,
+          network: paymentRequirements.network,
+          asset: paymentRequirements.asset,
+          amount: paymentRequirements.amount,
+          paymentRequired,
+          selectedPaymentRequirements: paymentRequirements,
+          verifyResponse: verifyResult,
+          signerMetadata: signerResult.metadata,
+          paymentRequiredHeader: PAYMENT_REQUIRED_HEADER,
+          paymentSignatureHeader: PAYMENT_SIGNATURE_HEADER
+        },
+        receiptRefs: [
+          {
+            type: "payment_proof",
+            provider: manifest.id,
+            status: "recorded",
+            ref: `${context.callId}:x402_payment_proof`,
+            timestamp: context.startedAt.toISOString()
+          }
+        ],
+        safety: {
+          paymentAttemptId,
+          paymentStatus: "authorized",
+          settlementStatus: "not_attempted",
+          deliveryStatus: "not_attempted",
+          moneyMayHaveMoved: true
+        }
+      };
+      defineNonEnumerableHeaders(preparation, headers);
+      return preparation;
+    },
+    async settle({ manifest, request, context, result, preparation }) {
+      assertProviderMatches(
+        options.providerId,
+        manifest.id,
+        request.capability,
+        context.callId
+      );
+      const preparedPayment = decodePreparedPayment(
+        preparation,
+        request.capability,
+        manifest.id,
+        context.callId
+      );
+      const settleResult = await facilitator.settle({
+        ...preparedPayment,
+        result,
+        manifest,
+        request,
+        context,
+        providerId: manifest.id,
+        capability: request.capability,
+        callId: context.callId
+      });
+      assertSettleResult(
+        settleResult,
+        request.capability,
+        manifest.id,
+        context.callId
+      );
+      const paymentId = getPayloadString(preparedPayment.paymentPayload, "paymentId") ?? `${context.callId}:x402_payment`;
+      const paymentAttemptId = `${paymentId}:attempt`;
+      const hasDeliveryReceipt = Array.isArray(result.receiptRefs) && result.receiptRefs.some(
+        (receiptRef) => receiptRef.type === "provider_delivery"
+      );
+      if (!settleResult.success) {
+        throw new ProbeMeshError({
+          code: "payment_failed",
+          message: settleResult.errorMessage ?? `x402 facilitator failed settlement for provider "${manifest.id}".`,
+          capability: request.capability,
+          provider: manifest.id,
+          callId: context.callId,
+          safety: {
+            paymentAttemptId,
+            paymentStatus: "authorized",
+            settlementStatus: "failed",
+            deliveryStatus: hasDeliveryReceipt ? "delivered" : "missing",
+            moneyMayHaveMoved: true
+          }
+        });
+      }
+      const headers = {
+        [PAYMENT_RESPONSE_HEADER]: encodePaymentResponseHeader(settleResult)
+      };
+      const settlement = {
+        mode: manifest.protocolMode,
+        metadata: {
+          settled: true,
+          x402Version: 2,
+          paymentId,
+          paymentAttemptId,
+          settlementResponse: settleResult,
+          paymentResponseHeader: PAYMENT_RESPONSE_HEADER
+        },
+        receiptRefs: [
+          {
+            type: "settlement_confirmation",
+            provider: manifest.id,
+            status: "recorded",
+            ref: `${context.callId}:x402_settlement_confirmed`,
+            timestamp: context.startedAt.toISOString()
+          }
+        ],
+        safety: {
+          paymentAttemptId,
+          paymentStatus: "authorized",
+          settlementStatus: "settled",
+          deliveryStatus: hasDeliveryReceipt ? "delivered" : "missing",
+          moneyMayHaveMoved: true
+        }
+      };
+      defineNonEnumerableHeaders(settlement, headers);
+      return settlement;
+    }
+  };
+}
+function createX402LocalSigner(options = {}) {
+  assertLocalSignerOptions(options);
+  return (input) => {
+    if (options.failSign) {
+      throw new ProbeMeshError({
+        code: "payment_failed",
+        message: `x402 local signer failed for provider "${input.providerId}".`,
+        capability: input.capability,
+        provider: input.providerId,
+        callId: input.callId,
+        safety: noPaymentSafety2()
+      });
+    }
+    const payer = options.payer ?? input.payer;
+    const paymentId = options.paymentId ?? input.paymentId;
+    const issuedAt = input.context.startedAt.toISOString();
+    const paymentPayload = {
+      x402Version: 2,
+      resource: input.paymentRequired.resource,
+      accepted: input.paymentRequirements,
+      payload: {
+        ...options.payload ?? {},
+        kind: "probemesh-local-x402-signature",
+        payer,
+        provider: input.providerId,
+        callId: input.callId,
+        paymentId,
+        issuedAt,
+        signature: `local-x402:${input.providerId}:${input.callId}:${paymentId}`
+      },
+      extensions: input.paymentRequired.extensions
+    };
+    return {
+      payer,
+      paymentPayload,
+      metadata: {
+        signer: "local",
+        paymentId
+      }
+    };
+  };
+}
+function createX402LocalFacilitator(options = {}) {
+  assertLocalFacilitatorOptions(options);
+  return {
+    verify(input) {
+      const payer = options.payer ?? getPayloadString(input.paymentPayload, "payer") ?? DEFAULT_PAYER;
+      if (options.failVerify) {
+        return {
+          isValid: false,
+          invalidReason: options.invalidReason ?? "local_verify_failed",
+          invalidMessage: options.invalidMessage ?? `x402 local facilitator rejected payment for provider "${input.providerId}".`,
+          payer,
+          extra: {
+            provider: input.providerId,
+            callId: input.callId
+          }
+        };
+      }
+      if (input.paymentPayload.x402Version !== 2) {
+        return {
+          isValid: false,
+          invalidReason: "unsupported_x402_version",
+          invalidMessage: "x402 local facilitator only accepts V2 payloads.",
+          payer
+        };
+      }
+      if (!paymentRequirementsMatch(
+        input.paymentPayload.accepted,
+        input.paymentRequirements
+      )) {
+        return {
+          isValid: false,
+          invalidReason: "requirements_mismatch",
+          invalidMessage: "x402 payment payload does not match the selected payment requirements.",
+          payer
+        };
+      }
+      return {
+        isValid: true,
+        payer,
+        extra: {
+          provider: input.providerId,
+          callId: input.callId,
+          paymentId: getPayloadString(input.paymentPayload, "paymentId")
+        }
+      };
+    },
+    settle(input) {
+      const payer = options.payer ?? getPayloadString(input.paymentPayload, "payer") ?? DEFAULT_PAYER;
+      const transaction = options.transaction ?? `${input.callId}:x402_local_settlement`;
+      const baseResponse = {
+        payer,
+        transaction,
+        network: input.paymentRequirements.network,
+        amount: input.paymentRequirements.amount,
+        extra: {
+          provider: input.providerId,
+          callId: input.callId,
+          paymentId: getPayloadString(input.paymentPayload, "paymentId")
+        }
+      };
+      if (options.failSettle) {
+        return {
+          ...baseResponse,
+          success: false,
+          errorReason: options.errorReason ?? "local_settle_failed",
+          errorMessage: options.errorMessage ?? `x402 local facilitator failed settlement for provider "${input.providerId}".`
+        };
+      }
+      return {
+        ...baseResponse,
+        success: true
+      };
+    }
+  };
+}
+async function resolvePaymentRequired(options) {
+  const defaultPaymentRequired = createDefaultPaymentRequired({
+    providerId: options.manifest.id,
+    capability: options.request.capability,
+    config: options.options.paymentRequired
+  });
+  const paymentRequired = options.options.resolvePaymentRequired ? await options.options.resolvePaymentRequired({
+    manifest: options.manifest,
+    request: options.request,
+    context: options.context
+  }) : defaultPaymentRequired;
+  assertPaymentRequired(paymentRequired);
+  return paymentRequired;
+}
+function decodePreparedPayment(preparation, capability, provider, callId) {
+  const paymentRequiredHeader = preparation?.headers?.[PAYMENT_REQUIRED_HEADER];
+  const paymentSignatureHeader = preparation?.headers?.[PAYMENT_SIGNATURE_HEADER];
+  if (!paymentRequiredHeader || !paymentSignatureHeader) {
+    throw new ProbeMeshError({
+      code: "payment_failed",
+      message: `x402 prepared payment headers are missing for provider "${provider}".`,
+      capability,
+      provider,
+      callId,
+      safety: {
+        paymentStatus: "authorized",
+        settlementStatus: "failed",
+        deliveryStatus: "missing",
+        moneyMayHaveMoved: true
+      }
+    });
+  }
+  const paymentRequired = decodePaymentRequiredHeader(paymentRequiredHeader);
+  const paymentPayload = decodePaymentSignatureHeader(paymentSignatureHeader);
+  assertPaymentRequired(paymentRequired);
+  assertPaymentPayload(
+    paymentPayload,
+    paymentPayload.accepted,
+    capability,
+    provider,
+    callId
+  );
+  return {
+    paymentRequired,
+    paymentPayload,
+    paymentRequirements: paymentPayload.accepted
+  };
+}
+function assertSignerResult(signerResult, capability, provider, callId) {
+  if (!signerResult || typeof signerResult !== "object" || Array.isArray(signerResult)) {
+    throw new ProbeMeshError({
+      code: "payment_failed",
+      message: `x402 signer returned an invalid result for provider "${provider}".`,
+      capability,
+      provider,
+      callId,
+      safety: failedPaymentSafety()
+    });
+  }
+}
+function assertPaymentPayload(paymentPayload, paymentRequirements, capability, provider, callId) {
+  if (!paymentPayload || typeof paymentPayload !== "object" || Array.isArray(paymentPayload)) {
+    throw new ProbeMeshError({
+      code: "payment_failed",
+      message: `x402 signer returned an invalid payment payload for provider "${provider}".`,
+      capability,
+      provider,
+      callId,
+      safety: failedPaymentSafety()
+    });
+  }
+  if (paymentPayload.x402Version !== 2) {
+    throw new ProbeMeshError({
+      code: "payment_failed",
+      message: "x402 payment payload x402Version must be 2.",
+      capability,
+      provider,
+      callId,
+      safety: failedPaymentSafety()
+    });
+  }
+  if (!paymentPayload.accepted || typeof paymentPayload.accepted !== "object" || Array.isArray(paymentPayload.accepted)) {
+    throw new ProbeMeshError({
+      code: "payment_failed",
+      message: "x402 payment payload accepted requirements must be an object.",
+      capability,
+      provider,
+      callId,
+      safety: failedPaymentSafety()
+    });
+  }
+  if (!paymentPayload.payload || typeof paymentPayload.payload !== "object" || Array.isArray(paymentPayload.payload)) {
+    throw new ProbeMeshError({
+      code: "payment_failed",
+      message: "x402 payment payload payload must be an object.",
+      capability,
+      provider,
+      callId,
+      safety: failedPaymentSafety()
+    });
+  }
+  if (!paymentRequirementsMatch(paymentPayload.accepted, paymentRequirements)) {
+    throw new ProbeMeshError({
+      code: "payment_failed",
+      message: "x402 payment payload does not match the selected payment requirements.",
+      capability,
+      provider,
+      callId,
+      safety: failedPaymentSafety()
+    });
+  }
+}
+function assertVerifyResult(verifyResult, capability, provider, callId) {
+  if (!verifyResult || typeof verifyResult !== "object" || Array.isArray(verifyResult) || typeof verifyResult.isValid !== "boolean") {
+    throw new ProbeMeshError({
+      code: "payment_failed",
+      message: `x402 facilitator returned an invalid verify response for provider "${provider}".`,
+      capability,
+      provider,
+      callId,
+      safety: failedPaymentSafety()
+    });
+  }
+}
+function assertSettleResult(settleResult, capability, provider, callId) {
+  if (!settleResult || typeof settleResult !== "object" || Array.isArray(settleResult) || typeof settleResult.success !== "boolean" || typeof settleResult.transaction !== "string" || settleResult.transaction.length === 0 || typeof settleResult.network !== "string" || settleResult.network.length === 0) {
+    throw new ProbeMeshError({
+      code: "payment_failed",
+      message: `x402 facilitator returned an invalid settlement response for provider "${provider}".`,
+      capability,
+      provider,
+      callId,
+      safety: {
+        paymentStatus: "authorized",
+        settlementStatus: "failed",
+        deliveryStatus: "missing",
+        moneyMayHaveMoved: true
+      }
+    });
+  }
+}
+function createDefaultPaymentRequired(options) {
+  const config = options.config ?? {};
+  const accepts = config.accepts ?? [
+    {
+      scheme: config.scheme ?? "exact",
+      network: normalizeNetwork(config.network ?? DEFAULT_NETWORK2),
+      asset: config.asset ?? DEFAULT_ASSET,
+      amount: config.amount ?? DEFAULT_AMOUNT2,
+      payTo: config.payTo ?? DEFAULT_PAY_TO,
+      maxTimeoutSeconds: config.maxTimeoutSeconds ?? DEFAULT_TIMEOUT_SECONDS,
+      extra: config.extra ?? {}
+    }
+  ];
+  return {
+    x402Version: config.x402Version ?? 2,
+    error: config.error,
+    resource: normalizeResourceInfo(
+      config.resource,
+      options.providerId,
+      options.capability
+    ),
+    accepts,
+    extensions: config.extensions
+  };
+}
+function assertPaymentRequired(paymentRequired) {
+  if (!paymentRequired || typeof paymentRequired !== "object" || Array.isArray(paymentRequired)) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "x402 paymentRequired must be an object."
+    });
+  }
+  if (paymentRequired.x402Version !== 2) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "x402 paymentRequired.x402Version must be 2."
+    });
+  }
+  if (!paymentRequired.resource || typeof paymentRequired.resource !== "object" || typeof paymentRequired.resource.url !== "string" || paymentRequired.resource.url.length === 0) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "x402 paymentRequired.resource.url must be a non-empty string."
+    });
+  }
+  if (!Array.isArray(paymentRequired.accepts) || paymentRequired.accepts.length === 0) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "x402 paymentRequired.accepts must include at least one option."
+    });
+  }
+  for (const requirements of paymentRequired.accepts) {
+    assertPaymentRequirements(requirements);
+  }
+}
+function assertPaymentRequirements(requirements) {
+  if (!requirements || typeof requirements !== "object") {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "x402 payment requirements must be an object."
+    });
+  }
+  for (const field of ["scheme", "network", "asset", "amount", "payTo"]) {
+    const value = requirements[field];
+    if (typeof value !== "string" || value.length === 0) {
+      throw new ProbeMeshError({
+        code: "invalid_request",
+        message: `x402 payment requirements ${field} must be a non-empty string.`
+      });
+    }
+  }
+  if (typeof requirements.maxTimeoutSeconds !== "number" || !Number.isFinite(requirements.maxTimeoutSeconds) || requirements.maxTimeoutSeconds <= 0) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "x402 payment requirements maxTimeoutSeconds must be a positive number."
+    });
+  }
+  if (!requirements.extra || typeof requirements.extra !== "object" || Array.isArray(requirements.extra)) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "x402 payment requirements extra must be an object."
+    });
+  }
+}
+function assertX402ProtocolOptions(options) {
+  validateOptionalString(options.mode, "mode");
+  validateOptionalString(options.providerId, "providerId");
+  validateOptionalString(options.payer, "payer");
+  validateOptionalString(options.paymentId, "paymentId");
+  if (options.paymentRequired !== void 0 && (!options.paymentRequired || typeof options.paymentRequired !== "object" || Array.isArray(options.paymentRequired))) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "x402 paymentRequired config must be an object when provided."
+    });
+  }
+  if (options.resolvePaymentRequired !== void 0 && typeof options.resolvePaymentRequired !== "function") {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "x402 resolvePaymentRequired must be a function when provided."
+    });
+  }
+  if (options.signer !== void 0 && typeof options.signer !== "function") {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "x402 signer must be a function when provided."
+    });
+  }
+  if (options.facilitator !== void 0 && (!options.facilitator || typeof options.facilitator !== "object" || typeof options.facilitator.verify !== "function" || typeof options.facilitator.settle !== "function")) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "x402 facilitator must expose verify(...) and settle(...) functions."
+    });
+  }
+}
+function assertLocalSignerOptions(options) {
+  validateOptionalString(options.payer, "local signer payer");
+  validateOptionalString(options.paymentId, "local signer paymentId");
+  if (options.failSign !== void 0 && typeof options.failSign !== "boolean") {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "x402 local signer failSign must be a boolean when provided."
+    });
+  }
+  if (options.payload !== void 0 && (!options.payload || typeof options.payload !== "object" || Array.isArray(options.payload))) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "x402 local signer payload must be an object when provided."
+    });
+  }
+}
+function assertLocalFacilitatorOptions(options) {
+  validateOptionalString(options.payer, "local facilitator payer");
+  validateOptionalString(options.invalidReason, "local facilitator invalidReason");
+  validateOptionalString(options.invalidMessage, "local facilitator invalidMessage");
+  validateOptionalString(options.errorReason, "local facilitator errorReason");
+  validateOptionalString(options.errorMessage, "local facilitator errorMessage");
+  validateOptionalString(options.transaction, "local facilitator transaction");
+  if (options.failVerify !== void 0 && typeof options.failVerify !== "boolean") {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "x402 local facilitator failVerify must be a boolean when provided."
+    });
+  }
+  if (options.failSettle !== void 0 && typeof options.failSettle !== "boolean") {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "x402 local facilitator failSettle must be a boolean when provided."
+    });
+  }
+}
+function normalizeResourceInfo(resource, providerId, capability) {
+  if (typeof resource === "string") {
+    return {
+      url: resource,
+      description: `ProbeMesh x402 payment for ${capability}.`,
+      mimeType: "application/json",
+      serviceName: providerId
+    };
+  }
+  return {
+    url: resource?.url ?? `probemesh://${providerId}/${capability}`,
+    description: resource?.description ?? `ProbeMesh x402 payment for ${capability}.`,
+    mimeType: resource?.mimeType ?? "application/json",
+    serviceName: resource?.serviceName ?? providerId,
+    tags: resource?.tags,
+    iconUrl: resource?.iconUrl
+  };
+}
+function normalizeNetwork(network) {
+  if (!network.includes(":")) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "x402 payment requirements network must use CAIP-2 format."
+    });
+  }
+  return network;
+}
+function defineNonEnumerableHeaders(target, headers) {
+  Object.defineProperty(target, "headers", {
+    value: Object.freeze(headers),
+    enumerable: false,
+    configurable: false,
+    writable: false
+  });
+}
+function assertProviderMatches(configuredProviderId, manifestProviderId, capability, callId) {
+  if (!configuredProviderId || configuredProviderId === manifestProviderId) {
+    return;
+  }
+  throw new ProbeMeshError({
+    code: "invalid_request",
+    message: `x402 protocol is configured for provider "${configuredProviderId}", but manifest "${manifestProviderId}" was used.`,
+    capability,
+    provider: manifestProviderId,
+    callId
+  });
+}
+function paymentRequirementsMatch(left, right) {
+  return left.scheme === right.scheme && left.network === right.network && left.asset === right.asset && left.amount === right.amount && left.payTo === right.payTo;
+}
+function getPayloadString(paymentPayload, field) {
+  const value = paymentPayload.payload[field];
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function validateOptionalString(value, field) {
+  if (value !== void 0 && (typeof value !== "string" || value.length === 0)) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: `x402 ${field} must be a non-empty string when provided.`
+    });
+  }
+}
+function noPaymentSafety2() {
+  return failedPaymentSafety();
+}
+function failedPaymentSafety() {
+  return {
+    paymentStatus: "failed",
+    settlementStatus: "not_attempted",
+    deliveryStatus: "not_attempted",
+    moneyMayHaveMoved: false
+  };
+}
+var X402_PROTOCOL_DEFAULT_MODE = DEFAULT_MODE2;
+
+// src/protocols/x402SandboxProtocol.ts
+var DEFAULT_MODE3 = "x402";
+var DEFAULT_PAYER2 = "sandbox-agent";
+var DEFAULT_NETWORK3 = "eip155:84532";
+var DEFAULT_ASSET2 = "USDC";
+var DEFAULT_AMOUNT3 = "10000";
+var DEFAULT_PAY_TO2 = "sandbox-provider-wallet";
+var PAYMENT_REQUIRED_HEADER2 = "PAYMENT-REQUIRED";
+var PAYMENT_SIGNATURE_HEADER2 = "PAYMENT-SIGNATURE";
+var PAYMENT_RESPONSE_HEADER2 = "PAYMENT-RESPONSE";
+function createX402SandboxProtocol(options = {}) {
+  assertX402SandboxProtocolOptions(options);
+  const mode = options.mode ?? DEFAULT_MODE3;
+  return {
+    mode,
+    prepare({ manifest, request, context }) {
+      if (options.failPrepare) {
+        throw new ProbeMeshError({
+          code: "payment_failed",
+          message: `x402 sandbox payment authorization failed for provider "${manifest.id}".`,
+          capability: request.capability,
+          provider: manifest.id,
+          callId: context.callId,
+          safety: failedPaymentSafety2()
+        });
+      }
+      assertProviderMatches2(options.providerId, manifest.id, request.capability, context.callId);
+      const paymentRequired = createPaymentRequirement({
+        providerId: manifest.id,
+        capability: request.capability,
+        options
+      });
+      const paymentId = options.paymentId ?? `${context.callId}:x402_payment`;
+      const payer = options.payer ?? DEFAULT_PAYER2;
+      const paymentAttemptId = `${paymentId}:attempt`;
+      const paymentPayload = createPaymentPayload({
+        paymentRequired,
+        providerId: manifest.id,
+        callId: context.callId,
+        paymentId,
+        payer,
+        issuedAt: context.startedAt.toISOString()
+      });
+      const headers = {
+        [PAYMENT_REQUIRED_HEADER2]: encodeBase64Json(paymentRequired),
+        [PAYMENT_SIGNATURE_HEADER2]: encodeBase64Json(paymentPayload)
+      };
+      const preparation = {
+        mode: manifest.protocolMode,
+        metadata: {
+          authorized: true,
+          x402Version: 2,
+          paymentId,
+          paymentAttemptId,
+          payer,
+          network: paymentRequired.network,
+          asset: paymentRequired.asset,
+          amount: paymentRequired.amount,
+          paymentRequired,
+          paymentPayload,
+          paymentRequiredHeader: PAYMENT_REQUIRED_HEADER2,
+          paymentSignatureHeader: PAYMENT_SIGNATURE_HEADER2
+        },
+        receiptRefs: [
+          {
+            type: "payment_proof",
+            provider: manifest.id,
+            status: "recorded",
+            ref: `${context.callId}:x402_payment_proof`,
+            timestamp: context.startedAt.toISOString()
+          }
+        ],
+        safety: {
+          paymentAttemptId,
+          paymentStatus: "authorized",
+          settlementStatus: "not_attempted",
+          deliveryStatus: "not_attempted",
+          moneyMayHaveMoved: true
+        }
+      };
+      defineNonEnumerableHeaders2(preparation, headers);
+      return preparation;
+    },
+    settle({ manifest, request, context, result, preparation }) {
+      assertProviderMatches2(options.providerId, manifest.id, request.capability, context.callId);
+      const paymentAttemptId = getMetadataString(
+        preparation?.metadata?.paymentAttemptId,
+        `${context.callId}:x402_payment:attempt`
+      );
+      const paymentId = getMetadataString(
+        preparation?.metadata?.paymentId,
+        `${context.callId}:x402_payment`
+      );
+      const payer = getMetadataString(preparation?.metadata?.payer, DEFAULT_PAYER2);
+      const network = getMetadataString(
+        preparation?.metadata?.network,
+        DEFAULT_NETWORK3
+      );
+      const asset = getMetadataString(preparation?.metadata?.asset, DEFAULT_ASSET2);
+      const amount = getMetadataString(
+        preparation?.metadata?.amount,
+        DEFAULT_AMOUNT3
+      );
+      const hasDeliveryReceipt = Array.isArray(result.receiptRefs) && result.receiptRefs.some(
+        (receiptRef) => receiptRef.type === "provider_delivery"
+      );
+      if (options.failSettle) {
+        throw new ProbeMeshError({
+          code: "payment_failed",
+          message: `x402 sandbox settlement failed for provider "${manifest.id}".`,
+          capability: request.capability,
+          provider: manifest.id,
+          callId: context.callId,
+          safety: {
+            paymentAttemptId,
+            paymentStatus: "authorized",
+            settlementStatus: "failed",
+            deliveryStatus: "missing",
+            moneyMayHaveMoved: true
+          }
+        });
+      }
+      const settlementResponse = {
+        x402Version: 2,
+        success: true,
+        provider: manifest.id,
+        payer,
+        paymentId,
+        paymentAttemptId,
+        network,
+        asset,
+        amount,
+        settledAt: context.startedAt.toISOString(),
+        sandboxSettlementId: `${context.callId}:x402_settlement`
+      };
+      const headers = {
+        [PAYMENT_RESPONSE_HEADER2]: encodeBase64Json(settlementResponse)
+      };
+      const settlement = {
+        mode: manifest.protocolMode,
+        metadata: {
+          settled: true,
+          x402Version: 2,
+          paymentId,
+          paymentAttemptId,
+          settlementResponse,
+          paymentResponseHeader: PAYMENT_RESPONSE_HEADER2
+        },
+        receiptRefs: [
+          {
+            type: "settlement_confirmation",
+            provider: manifest.id,
+            status: "recorded",
+            ref: `${context.callId}:x402_settlement_confirmed`,
+            timestamp: context.startedAt.toISOString()
+          }
+        ],
+        safety: {
+          paymentAttemptId,
+          paymentStatus: "authorized",
+          settlementStatus: "settled",
+          deliveryStatus: hasDeliveryReceipt ? "delivered" : "missing",
+          moneyMayHaveMoved: true
+        }
+      };
+      defineNonEnumerableHeaders2(settlement, headers);
+      return settlement;
+    }
+  };
+}
+function assertX402SandboxProtocolOptions(options) {
+  validateOptionalString2(options.mode, "mode");
+  validateOptionalString2(options.providerId, "providerId");
+  validateOptionalString2(options.paymentId, "paymentId");
+  validateOptionalString2(options.payer, "payer");
+  if (options.paymentRequired !== void 0 && (!options.paymentRequired || typeof options.paymentRequired !== "object" || Array.isArray(options.paymentRequired))) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "x402 sandbox paymentRequired must be an object when provided."
+    });
+  }
+  if (options.failPrepare !== void 0 && typeof options.failPrepare !== "boolean") {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "x402 sandbox failPrepare must be a boolean when provided."
+    });
+  }
+  if (options.failSettle !== void 0 && typeof options.failSettle !== "boolean") {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "x402 sandbox failSettle must be a boolean when provided."
+    });
+  }
+}
+function validateOptionalString2(value, field) {
+  if (value !== void 0 && (typeof value !== "string" || value.length === 0)) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: `x402 sandbox ${field} must be a non-empty string when provided.`
+    });
+  }
+}
+function assertProviderMatches2(configuredProviderId, manifestProviderId, capability, callId) {
+  if (!configuredProviderId || configuredProviderId === manifestProviderId) {
+    return;
+  }
+  throw new ProbeMeshError({
+    code: "invalid_request",
+    message: `x402 sandbox protocol is configured for provider "${configuredProviderId}", but manifest "${manifestProviderId}" was used.`,
+    capability,
+    provider: manifestProviderId,
+    callId
+  });
+}
+function createPaymentRequirement(options) {
+  const overrides = options.options.paymentRequired ?? {};
+  return {
+    x402Version: 2,
+    scheme: overrides.scheme ?? "exact",
+    network: overrides.network ?? DEFAULT_NETWORK3,
+    asset: overrides.asset ?? DEFAULT_ASSET2,
+    amount: overrides.amount ?? DEFAULT_AMOUNT3,
+    payTo: overrides.payTo ?? DEFAULT_PAY_TO2,
+    resource: overrides.resource ?? `probemesh://${options.providerId}/${options.capability}`,
+    description: overrides.description ?? `ProbeMesh x402 sandbox payment for ${options.capability}.`,
+    maxTimeoutSeconds: overrides.maxTimeoutSeconds ?? 60,
+    extra: overrides.extra
+  };
+}
+function createPaymentPayload(options) {
+  return {
+    x402Version: 2,
+    scheme: options.paymentRequired.scheme,
+    network: options.paymentRequired.network,
+    asset: options.paymentRequired.asset,
+    amount: options.paymentRequired.amount,
+    payTo: options.paymentRequired.payTo,
+    resource: options.paymentRequired.resource,
+    payer: options.payer,
+    provider: options.providerId,
+    callId: options.callId,
+    paymentId: options.paymentId,
+    issuedAt: options.issuedAt,
+    sandboxSignature: `sandbox:${options.providerId}:${options.paymentId}`
+  };
+}
+function defineNonEnumerableHeaders2(target, headers) {
+  Object.defineProperty(target, "headers", {
+    value: Object.freeze(headers),
+    enumerable: false,
+    configurable: false,
+    writable: false
+  });
+}
+function encodeBase64Json(value) {
+  return Buffer.from(JSON.stringify(value), "utf8").toString("base64");
+}
+function getMetadataString(value, fallback) {
+  return typeof value === "string" && value.length > 0 ? value : fallback;
+}
+function failedPaymentSafety2() {
+  return {
+    paymentStatus: "failed",
+    settlementStatus: "not_attempted",
+    deliveryStatus: "not_attempted",
+    moneyMayHaveMoved: false
+  };
+}
+
+// src/receipts.ts
+function getReceiptRefs(source, type) {
+  const receiptRefs = readReceiptRefs(source);
+  if (type === void 0) {
+    return [...receiptRefs];
+  }
+  return receiptRefs.filter((receiptRef) => receiptRef.type === type);
+}
+function findReceiptRef(source, type) {
+  return getReceiptRefs(source, type)[0];
+}
+function hasReceipt(source, type) {
+  return findReceiptRef(source, type) !== void 0;
+}
+function summarizeReceipts(source) {
+  const receiptRefs = readReceiptRefs(source);
+  const types = [];
+  const providers = [];
+  const byType = {};
+  for (const receiptRef of receiptRefs) {
+    if (!types.includes(receiptRef.type)) {
+      types.push(receiptRef.type);
+    }
+    if (!providers.includes(receiptRef.provider)) {
+      providers.push(receiptRef.provider);
+    }
+    byType[receiptRef.type] = (byType[receiptRef.type] ?? 0) + 1;
+  }
+  return {
+    total: receiptRefs.length,
+    types,
+    providers,
+    byType,
+    hasPaymentProof: hasReceipt(receiptRefs, "payment_proof"),
+    hasProviderDelivery: hasReceipt(receiptRefs, "provider_delivery")
+  };
+}
+function readReceiptRefs(source) {
+  return Array.isArray(source) ? source : source.receiptRefs;
+}
+export {
+  PROBEMESH_AUDIT_TRAIL_BUNDLE_SCHEMA_VERSION,
+  PROBEMESH_CALL_AUDIT_ARTIFACT_SCHEMA_VERSION,
+  PROVIDER_CATALOG_ARTIFACT_SCHEMA_VERSION,
+  PROVIDER_CATALOG_POLICY_BUNDLE_SCHEMA_VERSION,
+  PROVIDER_CATALOG_SCHEMA_VERSION,
+  PROVIDER_CONFORMANCE_ARTIFACT_SCHEMA_VERSION,
+  PROVIDER_ONBOARDING_DOSSIER_SCHEMA_VERSION,
+  ProbeMeshError,
+  assertJsonSchemaLikeValue,
+  assertProbeMeshAuditTrailBundle,
+  assertProbeMeshCallAuditArtifact,
+  assertProviderCatalog,
+  assertProviderCatalogArtifact,
+  assertProviderCatalogPolicyBundle,
+  assertProviderConformanceArtifact,
+  assertProviderManifest,
+  assertProviderOnboardingDossier,
+  createAdapterFromManifest,
+  createApiKeyProtocol,
+  createHostedCatalogPolicyFromOnboardingDossiers,
+  createHostedRouter,
+  createMockPaymentProtocol,
+  createPaidPriceLookupProvider,
+  createPriceLookupAdapter,
+  createProbeMesh,
+  createProbeMeshAuditTrailBundle,
+  createProbeMeshAuditTrailCollector,
+  createProbeMeshCallAuditArtifact,
+  createProviderCatalog,
+  createProviderCatalogArtifact,
+  createProviderCatalogFromOnboardingDossiers,
+  createProviderCatalogPolicyBundle,
+  createProviderCatalogPolicyReport,
+  createProviderConformanceArtifact,
+  createProviderConformanceReport,
+  createProviderOnboardingDossier,
+  createProviderOnboardingDossierImportReport,
+  createX402EvmSigner,
+  createX402HttpFacilitator,
+  createX402LocalFacilitator,
+  createX402LocalSigner,
+  createX402Protocol,
+  createX402ProviderAcceptanceReport,
+  createX402SandboxProtocol,
+  evaluateProviderCatalogPolicy,
+  evaluateProviderOnboardingDossiers,
+  evaluateX402ProviderAcceptanceGate,
+  findProviderCatalogMatches,
+  findReceiptRef,
+  formatProbeMeshAuditTrailBundle,
+  formatProbeMeshCallAuditArtifact,
+  formatProviderCatalogArtifact,
+  formatProviderCatalogPolicyBundle,
+  formatProviderCatalogPolicyReport,
+  formatProviderConformanceArtifact,
+  formatProviderConformanceReport,
+  formatProviderOnboardingDossier,
+  formatProviderOnboardingDossierImportReport,
+  formatX402ProviderAcceptanceReport,
+  getProbeMeshIntegrationTemplate,
+  getProviderPaymentOptions,
+  getReceiptRefs,
+  hasReceipt,
+  isProbeMeshError,
+  listProbeMeshIntegrationTemplates,
+  mergePaymentPreferences,
+  parseProviderCatalogArtifactJson,
+  parseProviderOnboardingDossierJson,
+  redactX402Secrets,
+  renderProbeMeshIntegrationTemplate,
+  resolveProviderPaymentOption,
+  resolveX402EvmTestnetConfig,
+  runProbeMeshAuditTrailExportCli,
+  runProbeMeshInitCli,
+  runProviderCatalogPolicyCli,
+  runProviderConformance,
+  runProviderConformanceCli,
+  runProviderDossierCheckCli,
+  runProviderOnboardingDossierCli,
+  runX402ProviderAcceptance,
+  runX402ProviderAcceptanceCli,
+  startHostedRouter,
+  summarizeProbeMeshAuditTrailBundle,
+  summarizeProviderCatalog,
+  summarizeReceipts,
+  summarizeX402AcceptanceResult,
+  validateJsonSchemaLikeValue,
+  validatePaymentStrategy,
+  validateProbeMeshAuditTrailBundle,
+  validateProbeMeshCallAuditArtifact,
+  validateProviderCatalog,
+  validateProviderCatalogArtifact,
+  validateProviderCatalogPolicyBundle,
+  validateProviderConformanceArtifact,
+  validateProviderManifest,
+  validateProviderOnboardingDossier,
+  verifyProviderCatalogPolicyBundleRuntime
+};
+//# sourceMappingURL=index.js.map