opentool 0.7.2 → 0.7.4

package/dist/index.js

@@ -6,9 +6,9 @@ import * as path5 from 'path';
 import { fileURLToPath, pathToFileURL } from 'url';
 import { zodToJsonSchema } from '@alcyone-labs/zod-to-json-schema';
 import { z } from 'zod';
-import { zeroAddress, createPublicClient, http, createWalletClient } from 'viem';
-import { baseSepolia, mainnet, base } from 'viem/chains';
+import { zeroAddress, createWalletClient, http, createPublicClient } from 'viem';
 import { privateKeyToAccount } from 'viem/accounts';
+import { baseSepolia, mainnet, base } from 'viem/chains';
 import { Turnkey } from '@turnkey/sdk-server';
 import { createAccount } from '@turnkey/viem';
 import { tmpdir } from 'os';
@@ -21,136 +21,8 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   if (typeof require !== "undefined") return require.apply(this, arguments);
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
-var PAYMENT_SCHEMA_VERSION = 1;
-var paymentSchemaVersionSchema = z.literal(PAYMENT_SCHEMA_VERSION);
-var decimalStringSchema = z.string().regex(/^(?:0|[1-9]\d*)(?:\.\d+)?$/, "Value must be a positive decimal string");
-var currencySchema = z.object({
-  code: z.string().min(2).max(12).transform((value) => value.toUpperCase()),
-  symbol: z.string().min(1).max(6).optional(),
-  decimals: z.number().int().min(0).max(36).optional(),
-  kind: z.enum(["fiat", "crypto"]).default("crypto").optional(),
-  description: z.string().optional()
-});
-var paymentAmountSchema = z.object({
-  value: decimalStringSchema,
-  currency: currencySchema,
-  display: z.string().optional()
-});
-var cryptoAssetSchema = z.object({
-  symbol: z.string().min(2).max(12),
-  network: z.string().min(1).optional(),
-  chainId: z.number().int().min(0).optional(),
-  address: z.string().min(1).optional(),
-  decimals: z.number().int().min(0).max(36).optional(),
-  standard: z.enum(["erc20", "spl", "custom"]).default("erc20").optional(),
-  description: z.string().optional()
-});
-var facilitatorConfigSchema = z.object({
-  url: z.string().url(),
-  vendor: z.string().optional(),
-  verifyPath: z.string().default("/verify").optional(),
-  settlePath: z.string().default("/settle").optional(),
-  apiKey: z.string().optional(),
-  apiKeyEnv: z.string().optional(),
-  apiKeyHeader: z.string().default("Authorization").optional(),
-  headers: z.record(z.string(), z.string()).optional(),
-  timeoutMs: z.number().int().positive().optional()
-});
-var settlementTermsSchema = z.object({
-  windowSeconds: z.number().int().positive().optional(),
-  targetConfirmations: z.number().int().positive().optional(),
-  finalityDescription: z.string().optional(),
-  slaDescription: z.string().optional()
-});
-var paymentFieldSchema = z.object({
-  key: z.string().min(1),
-  label: z.string().min(1),
-  required: z.boolean().default(true).optional(),
-  description: z.string().optional(),
-  example: z.string().optional()
-});
-var x402ProofSchema = z.object({
-  mode: z.literal("x402"),
-  scheme: z.string().min(1),
-  network: z.string().min(1),
-  version: z.number().int().min(1).optional(),
-  facilitator: facilitatorConfigSchema.optional(),
-  verifier: z.string().optional()
-});
-var directProofSchema = z.object({
-  mode: z.literal("direct"),
-  proofTypes: z.array(z.string().min(1)).nonempty(),
-  verifier: z.string().optional(),
-  instructions: z.string().optional(),
-  fields: z.array(paymentFieldSchema).optional(),
-  allowsManualReview: z.boolean().optional()
-});
-var paymentProofSchema = z.discriminatedUnion("mode", [
-  x402ProofSchema,
-  directProofSchema
-]);
-var paymentOptionSchema = z.object({
-  id: z.string().min(1),
-  title: z.string().min(1),
-  description: z.string().optional(),
-  amount: paymentAmountSchema,
-  asset: cryptoAssetSchema,
-  payTo: z.string().min(1),
-  resource: z.string().url().optional(),
-  proof: paymentProofSchema,
-  settlement: settlementTermsSchema.optional(),
-  metadata: z.record(z.string(), z.unknown()).optional()
-});
-var paymentRequirementsSchema = z.object({
-  schemaVersion: paymentSchemaVersionSchema,
-  message: z.string().optional(),
-  title: z.string().optional(),
-  resource: z.string().url().optional(),
-  accepts: z.array(paymentOptionSchema).nonempty(),
-  metadata: z.record(z.string(), z.unknown()).optional(),
-  fallbackText: z.string().optional()
-});
-var x402PaymentHeaderSchema = z.object({
-  x402Version: z.number().int().min(1),
-  scheme: z.string().min(1),
-  network: z.string().min(1),
-  payload: z.unknown(),
-  correlationId: z.string().optional()
-});
-var directPaymentPayloadSchema = z.object({
-  schemaVersion: z.literal(1),
-  optionId: z.string().min(1),
-  proofType: z.string().min(1),
-  payload: z.unknown(),
-  metadata: z.record(z.string(), z.unknown()).optional()
-});
-var paymentSuccessMetadataSchema = z.object({
-  optionId: z.string().min(1),
-  verifier: z.string().optional(),
-  txHash: z.string().optional(),
-  networkId: z.string().optional(),
-  amount: paymentAmountSchema.optional(),
-  settledAt: z.string().datetime().optional(),
-  payload: z.unknown().optional()
-});
-var paymentFailureSchema = z.object({
-  reason: z.string().min(1),
-  code: z.enum([
-    "verifier_not_found",
-    "verification_failed",
-    "invalid_payload",
-    "unsupported_option",
-    "missing_header",
-    "unknown"
-  ]).default("unknown").optional(),
-  retryable: z.boolean().optional(),
-  detail: z.unknown().optional()
-});
-
-// src/helpers/payment.ts
-var X402_VERSION_DEFAULT = 1;
+var X402_VERSION = 1;
 var HEADER_X402 = "X-PAYMENT";
-var HEADER_DIRECT = "X-PAYMENT-PROOF";
 var HEADER_PAYMENT_RESPONSE = "X-PAYMENT-RESPONSE";
 var x402RequirementSchema = z.object({
   scheme: z.string().min(1),
@@ -165,272 +37,209 @@ var x402RequirementSchema = z.object({
   maxTimeoutSeconds: z.number().int().positive().optional(),
   extra: z.record(z.string(), z.unknown()).nullable().optional()
 });
-function createPaymentRequiredBody(definition) {
-  const parsed = paymentRequirementsSchema.parse(definition);
-  const x402Accepts = parsed.accepts.filter((option) => option.proof.mode === "x402").map(
-    (option) => toX402Requirement(option, parsed.resource, option.settlement)
-  ).filter((value) => Boolean(value));
-  const x402Body = x402Accepts.length > 0 ? {
-    x402Version: resolveX402Version(parsed.accepts),
-    error: parsed.message ?? "Payment required",
-    accepts: x402Accepts
-  } : void 0;
-  if (x402Body) {
-    return {
-      ...parsed,
-      x402: x402Body
-    };
-  }
-  return parsed;
-}
-function paymentRequiredResponse(definition, init) {
-  const body = createPaymentRequiredBody(definition);
-  const headers = new Headers(init?.headers);
-  if (!headers.has("content-type")) {
-    headers.set("content-type", "application/json; charset=utf-8");
+var x402PaymentHeaderSchema = z.object({
+  x402Version: z.number().int().positive(),
+  scheme: z.string().min(1),
+  network: z.string().min(1),
+  correlationId: z.string().optional(),
+  payload: z.unknown()
+});
+var SUPPORTED_CURRENCIES = {
+  USDC: {
+    decimals: 6,
+    symbol: "USDC",
+    network: "base",
+    assetAddress: "0x833589fCD6eDb6E08f4c7C37b7b4c6e997E08A43"
   }
+};
+var DEFAULT_FACILITATOR = {
+  url: "https://facilitator.x402.rs",
+  verifyPath: "/verify",
+  settlePath: "/settle",
+  apiKeyHeader: "Authorization"
+};
+
+// src/x402/helpers.ts
+function createX402PaymentRequired(definition) {
+  const requirement = toX402Requirement(definition);
+  const body = {
+    schemaVersion: 1,
+    message: definition.description ?? "Payment required",
+    resource: definition.resource,
+    accepts: [
+      {
+        id: "x402",
+        title: `Pay ${definition.amount} ${definition.currency.code}`,
+        description: definition.description,
+        amount: {
+          value: definition.amount,
+          currency: {
+            code: definition.currency.code,
+            symbol: definition.currency.symbol,
+            decimals: definition.currency.decimals,
+            kind: "crypto"
+          }
+        },
+        asset: {
+          symbol: definition.asset.symbol,
+          network: definition.asset.network,
+          address: definition.asset.address,
+          decimals: definition.asset.decimals,
+          standard: "erc20"
+        },
+        payTo: definition.payTo,
+        resource: definition.resource,
+        proof: {
+          mode: "x402",
+          scheme: definition.scheme,
+          network: definition.network,
+          version: X402_VERSION,
+          facilitator: definition.facilitator,
+          verifier: "x402:facilitator"
+        }
+      }
+    ],
+    metadata: definition.metadata ?? {},
+    x402: {
+      x402Version: X402_VERSION,
+      error: definition.description ?? "Payment required",
+      accepts: [requirement]
+    }
+  };
   return new Response(JSON.stringify(body), {
-    ...init,
-    status: init?.status ?? 402,
-    headers
+    status: 402,
+    headers: {
+      "Content-Type": "application/json"
+    }
   });
 }
-function extractPaymentAttempts(source) {
-  const attempts = [];
-  const failures = [];
-  const x402Header = source.headers.get(HEADER_X402);
-  if (x402Header) {
-    const { attempt, failure } = parseX402Header(x402Header);
-    if (attempt) {
-      attempts.push(attempt);
-    } else if (failure) {
-      failures.push(failure);
-    }
-  }
-  const directHeader = source.headers.get(HEADER_DIRECT);
-  if (directHeader) {
-    const { attempt, failure } = parseDirectHeader(directHeader);
-    if (attempt) {
-      attempts.push(attempt);
-    } else if (failure) {
-      failures.push(failure);
-    }
-  }
-  if (attempts.length === 0 && failures.length === 0) {
-    failures.push(
-      paymentFailureSchema.parse({
-        reason: "No payment headers present",
-        code: "missing_header",
-        retryable: false
-      })
-    );
+function extractX402Attempt(request) {
+  const raw = request.headers.get(HEADER_X402);
+  if (!raw) {
+    return null;
   }
-  return { attempts, failures };
-}
-async function verifyPayment(options) {
-  const definition = paymentRequirementsSchema.parse(options.definition);
-  const attempts = options.attempts ? options.attempts : options.request ? extractPaymentAttempts(options.request).attempts : [];
-  if (attempts.length === 0) {
+  try {
+    const payload = decodeJson(raw, x402PaymentHeaderSchema);
     return {
-      success: false,
-      optionId: "",
-      attemptType: "direct",
-      failure: paymentFailureSchema.parse({
-        reason: "No payment attempt found",
-        code: "missing_header",
-        retryable: false
-      })
+      type: "x402",
+      headerName: HEADER_X402,
+      raw,
+      payload
     };
+  } catch {
+    return null;
   }
-  for (const attempt of attempts) {
-    const option = findMatchingOption(definition, attempt);
-    if (!option) {
-      continue;
+}
+async function verifyX402Payment(attempt, definition, options = {}) {
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const facilitator = definition.facilitator;
+  const verifierUrl = new URL(
+    facilitator.verifyPath ?? "/verify",
+    ensureTrailingSlash(facilitator.url)
+  ).toString();
+  const requirement = toX402Requirement(definition);
+  const headers = buildFacilitatorHeaders(facilitator);
+  try {
+    const verifyResponse = await fetchImpl(verifierUrl, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        x402Version: attempt.payload.x402Version,
+        paymentPayload: attempt.payload,
+        paymentRequirements: requirement
+      })
+    });
+    if (!verifyResponse.ok) {
+      return {
+        success: false,
+        failure: {
+          reason: `Facilitator verify request failed: ${verifyResponse.status}`,
+          code: "verification_failed"
+        }
+      };
     }
-    if (attempt.type === "x402") {
-      const proof = option.proof;
-      const verifierId = proof.verifier ?? (proof.facilitator ? "x402:facilitator" : void 0);
-      if (verifierId === "x402:facilitator" && proof.facilitator) {
-        const context2 = {
-          attempt,
-          option,
-          definition
-        };
-        if (options.settle !== void 0) {
-          context2.settle = options.settle;
+    const verifyPayload = await verifyResponse.json();
+    if (!verifyPayload.isValid) {
+      return {
+        success: false,
+        failure: {
+          reason: verifyPayload.invalidReason ?? "Facilitator verification failed",
+          code: "verification_failed"
         }
-        return runFacilitatorVerifier({
-          ...context2,
-          fetchImpl: options.fetchImpl ?? fetch
-        });
-      }
-      const verifier = verifierId ? options.verifiers?.[verifierId] : void 0;
-      if (!verifier) {
-        return {
-          success: false,
-          optionId: option.id,
-          attemptType: attempt.type,
-          failure: paymentFailureSchema.parse({
-            reason: `No verifier registered for id: ${verifierId ?? "(missing)"}`,
-            code: "verifier_not_found",
-            retryable: false
-          })
-        };
-      }
-      const context = {
-        attempt,
-        option,
-        definition
       };
-      if (options.settle !== void 0) {
-        context.settle = options.settle;
-      }
-      return verifier(context);
     }
-    if (attempt.type === "direct") {
-      const proof = option.proof;
-      const verifierId = proof.verifier ?? `direct:${attempt.payload.proofType}`;
-      const verifier = verifierId ? options.verifiers?.[verifierId] : void 0;
-      if (!verifier) {
-        return {
-          success: false,
-          optionId: option.id,
-          attemptType: attempt.type,
-          failure: paymentFailureSchema.parse({
-            reason: `No verifier registered for id: ${verifierId}`,
-            code: "verifier_not_found",
-            retryable: false
+    const responseHeaders = {};
+    if (options.settle) {
+      const settleUrl = new URL(
+        facilitator.settlePath ?? "/settle",
+        ensureTrailingSlash(facilitator.url)
+      ).toString();
+      try {
+        const settleResponse = await fetchImpl(settleUrl, {
+          method: "POST",
+          headers,
+          body: JSON.stringify({
+            x402Version: attempt.payload.x402Version,
+            paymentPayload: attempt.payload,
+            paymentRequirements: requirement
           })
-        };
-      }
-      const context = {
-        attempt,
-        option,
-        definition
-      };
-      if (options.settle !== void 0) {
-        context.settle = options.settle;
+        });
+        if (settleResponse.ok) {
+          const settlePayload = await settleResponse.json();
+          if (settlePayload.txHash) {
+            responseHeaders[HEADER_PAYMENT_RESPONSE] = JSON.stringify({
+              settled: true,
+              txHash: settlePayload.txHash
+            });
+          }
+        }
+      } catch {
       }
-      return verifier(context);
     }
-  }
-  return {
-    success: false,
-    optionId: "",
-    attemptType: attempts[0]?.type ?? "direct",
-    failure: paymentFailureSchema.parse({
-      reason: "No matching payment option for attempt",
-      code: "unsupported_option",
-      retryable: false
-    })
-  };
-}
-function createPaymentResponseHeader(metadata) {
-  const parsed = paymentSuccessMetadataSchema.parse(metadata);
-  return encodeJson(parsed);
-}
-function parseX402Header(value) {
-  try {
-    const payload = decodeJson(value, x402PaymentHeaderSchema);
-    return {
-      attempt: {
-        type: "x402",
-        headerName: HEADER_X402,
-        raw: value,
-        payload
+    const result = {
+      success: true,
+      metadata: {
+        optionId: "x402",
+        verifier: "x402:facilitator",
+        amount: definition.amount,
+        currency: definition.currency.code,
+        network: definition.network
       }
     };
+    if (Object.keys(responseHeaders).length > 0) {
+      result.responseHeaders = responseHeaders;
+    }
+    return result;
   } catch (error) {
     return {
-      failure: paymentFailureSchema.parse({
-        reason: `Invalid X-PAYMENT header: ${error.message}`,
-        code: "invalid_payload",
-        retryable: false
-      })
-    };
-  }
-}
-function parseDirectHeader(value) {
-  try {
-    const payload = decodeJson(value, directPaymentPayloadSchema);
-    return {
-      attempt: {
-        type: "direct",
-        headerName: HEADER_DIRECT,
-        raw: value,
-        payload
+      success: false,
+      failure: {
+        reason: error instanceof Error ? error.message : "Unknown error",
+        code: "verification_failed"
       }
     };
-  } catch (error) {
-    return {
-      failure: paymentFailureSchema.parse({
-        reason: `Invalid X-PAYMENT-PROOF header: ${error.message}`,
-        code: "invalid_payload",
-        retryable: false
-      })
-    };
   }
 }
-function findMatchingOption(definition, attempt) {
-  return definition.accepts.find((candidate) => {
-    const option = paymentOptionSchema.parse(candidate);
-    if (attempt.type === "x402" && option.proof.mode === "x402") {
-      return option.proof.scheme === attempt.payload.scheme && option.proof.network === attempt.payload.network;
-    }
-    if (attempt.type === "direct" && option.proof.mode === "direct") {
-      return option.id === attempt.payload.optionId;
-    }
-    return false;
-  });
-}
-function resolveX402Version(options) {
-  const versions = [];
-  for (const option of options) {
-    if (option.proof.mode === "x402" && option.proof.version) {
-      versions.push(option.proof.version);
-    }
-  }
-  return versions.length > 0 ? Math.max(...versions) : X402_VERSION_DEFAULT;
-}
-function toX402Requirement(option, fallbackResource, settlement) {
-  if (option.proof.mode !== "x402") {
-    return void 0;
-  }
-  const decimals = resolveDecimals(option);
-  const assetAddress = option.asset.address;
-  if (!assetAddress) {
-    throw new Error(
-      `x402 payment option '${option.id}' is missing asset.address`
-    );
-  }
-  const units = decimalToBaseUnits(option.amount.value, decimals);
+function toX402Requirement(definition) {
+  const decimals = definition.asset.decimals;
+  const units = decimalToBaseUnits(definition.amount, decimals);
   return x402RequirementSchema.parse({
-    scheme: option.proof.scheme,
-    network: option.proof.network,
+    scheme: definition.scheme,
+    network: definition.network,
     maxAmountRequired: units,
-    asset: assetAddress,
-    payTo: option.payTo,
-    resource: option.resource ?? fallbackResource,
-    description: option.description,
-    maxTimeoutSeconds: settlement?.windowSeconds,
+    asset: definition.asset.address,
+    payTo: definition.payTo,
+    resource: definition.resource,
+    description: definition.description,
+    mimeType: "application/json",
+    maxTimeoutSeconds: 900,
     extra: {
-      symbol: option.asset.symbol,
-      currencyCode: option.amount.currency.code,
+      symbol: definition.asset.symbol,
+      currencyCode: definition.currency.code,
       decimals
     }
   });
 }
-function resolveDecimals(option) {
-  if (typeof option.asset.decimals === "number") {
-    return option.asset.decimals;
-  }
-  if (typeof option.amount.currency.decimals === "number") {
-    return option.amount.currency.decimals;
-  }
-  throw new Error(
-    `Payment option '${option.id}' must specify asset.decimals or currency.decimals`
-  );
-}
 function decimalToBaseUnits(value, decimals) {
   const [whole, fraction = ""] = value.split(".");
   const sanitizedFraction = fraction.slice(0, decimals);
@@ -444,10 +253,6 @@ function decodeJson(value, schema) {
   const parsed = JSON.parse(json);
   return schema.parse(parsed);
 }
-function encodeJson(value) {
-  const json = JSON.stringify(value);
-  return Buffer.from(json, "utf-8").toString("base64");
-}
 function normalizeBase64(input) {
   if (/^[A-Za-z0-9+/=]+$/.test(input)) {
     return input;
@@ -456,221 +261,313 @@ function normalizeBase64(input) {
   const paddingNeeded = (4 - restored.length % 4) % 4;
   return restored + "=".repeat(paddingNeeded);
 }
-async function runFacilitatorVerifier({
-  attempt,
-  option,
-  definition,
-  settle,
-  fetchImpl
-}) {
-  if (option.proof.mode !== "x402" || attempt.type !== "x402" || !option.proof.facilitator) {
-    return {
-      success: false,
-      optionId: option.id,
-      attemptType: attempt.type,
-      failure: paymentFailureSchema.parse({
-        reason: "Facilitator verifier invoked for non-x402 option",
-        code: "verification_failed",
-        retryable: false
-      })
-    };
-  }
-  const facilitator = option.proof.facilitator;
-  const verifierUrl = new URL(
-    facilitator.verifyPath ?? "/verify",
-    ensureTrailingSlash(facilitator.url)
-  ).toString();
-  const requirement = toX402Requirement(option, definition.resource, option.settlement);
-  if (!requirement) {
-    return {
-      success: false,
-      optionId: option.id,
-      attemptType: attempt.type,
-      failure: paymentFailureSchema.parse({
-        reason: "Unable to derive x402 requirement for facilitator",
-        code: "verification_failed",
-        retryable: false
-      })
-    };
+function buildFacilitatorHeaders(facilitator) {
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  if (facilitator.apiKeyHeader && process.env.X402_FACILITATOR_API_KEY) {
+    headers[facilitator.apiKeyHeader] = process.env.X402_FACILITATOR_API_KEY;
   }
-  const headers = buildFacilitatorHeaders(facilitator);
-  const controller = facilitator.timeoutMs ? new AbortController() : void 0;
-  const timeout = facilitator.timeoutMs ? setTimeout(() => controller?.abort(), facilitator.timeoutMs) : void 0;
-  try {
-    const verifyResponse = await fetchImpl(verifierUrl, {
-      method: "POST",
-      headers,
-      body: JSON.stringify({
-        x402Version: attempt.payload.x402Version,
-        paymentHeader: attempt.raw,
-        paymentRequirements: requirement
-      }),
-      signal: controller?.signal ?? null
+  return headers;
+}
+function ensureTrailingSlash(url) {
+  return url.endsWith("/") ? url : `${url}/`;
+}
+var PAYMENT_HEADERS = [HEADER_X402, HEADER_PAYMENT_RESPONSE];
+var X402Client = class {
+  constructor(config) {
+    this.account = privateKeyToAccount(config.privateKey);
+    const chain = baseSepolia;
+    this.walletClient = createWalletClient({
+      account: this.account,
+      chain,
+      transport: http(config.rpcUrl)
     });
-    if (!verifyResponse.ok) {
-      return {
-        success: false,
-        optionId: option.id,
-        attemptType: attempt.type,
-        failure: paymentFailureSchema.parse({
-          reason: `Facilitator verify request failed: ${verifyResponse.status}`,
-          code: "verification_failed",
-          retryable: verifyResponse.status >= 500
-        })
-      };
-    }
-    const verifyPayload = await verifyResponse.json();
-    if (!verifyPayload.isValid) {
-      return {
-        success: false,
-        optionId: option.id,
-        attemptType: attempt.type,
-        failure: paymentFailureSchema.parse({
-          reason: verifyPayload.invalidReason ?? "Facilitator verification failed",
-          code: "verification_failed",
-          retryable: false
-        })
+  }
+  async pay(request) {
+    try {
+      const initialResponse = await fetch(request.url, {
+        method: request.method ?? "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...request.headers
+        },
+        ...request.body ? { body: JSON.stringify(request.body) } : {}
+      });
+      if (initialResponse.status !== 402) {
+        return {
+          success: initialResponse.ok,
+          response: initialResponse
+        };
+      }
+      const paymentRequirements = await initialResponse.json();
+      const x402Requirements = paymentRequirements.x402?.accepts?.[0];
+      if (!x402Requirements) {
+        return {
+          success: false,
+          error: "No x402 payment requirements found in 402 response"
+        };
+      }
+      const authorization = await this.signTransferAuthorization({
+        from: this.account.address,
+        to: x402Requirements.payTo,
+        value: BigInt(x402Requirements.maxAmountRequired),
+        validAfter: BigInt(Math.floor(Date.now() / 1e3)),
+        validBefore: BigInt(Math.floor(Date.now() / 1e3) + 900),
+        // 15 min
+        nonce: `0x${Array.from(
+          { length: 32 },
+          () => Math.floor(Math.random() * 256).toString(16).padStart(2, "0")
+        ).join("")}`,
+        tokenAddress: x402Requirements.asset
+      });
+      const paymentProof = {
+        x402Version: 1,
+        scheme: x402Requirements.scheme,
+        network: x402Requirements.network,
+        correlationId: "",
+        payload: {
+          signature: authorization.signature,
+          authorization: {
+            from: authorization.from,
+            to: authorization.to,
+            value: authorization.value.toString(),
+            validAfter: authorization.validAfter.toString(),
+            validBefore: authorization.validBefore.toString(),
+            nonce: authorization.nonce
+          }
+        }
       };
-    }
-    if (!settle) {
+      const paymentHeader = Buffer.from(JSON.stringify(paymentProof)).toString("base64");
+      const paidResponse = await fetch(request.url, {
+        method: request.method ?? "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "X-PAYMENT": paymentHeader,
+          ...request.headers
+        },
+        ...request.body ? { body: JSON.stringify(request.body) } : {}
+      });
       return {
-        success: true,
-        optionId: option.id,
-        attemptType: attempt.type,
-        metadata: paymentSuccessMetadataSchema.parse({
-          optionId: option.id,
-          verifier: facilitator.vendor ?? "facilitator"
-        })
+        success: paidResponse.ok,
+        response: paidResponse,
+        paymentDetails: {
+          amount: x402Requirements.maxAmountRequired,
+          currency: x402Requirements.extra?.currencyCode ?? "USDC",
+          network: x402Requirements.network,
+          signature: authorization.signature
+        }
       };
-    }
-    const settleUrl = new URL(
-      facilitator.settlePath ?? "/settle",
-      ensureTrailingSlash(facilitator.url)
-    ).toString();
-    const settleResponse = await fetchImpl(settleUrl, {
-      method: "POST",
-      headers,
-      body: JSON.stringify({
-        x402Version: attempt.payload.x402Version,
-        paymentHeader: attempt.raw,
-        paymentRequirements: requirement
-      }),
-      signal: controller?.signal ?? null
-    });
-    if (!settleResponse.ok) {
+    } catch (error) {
       return {
         success: false,
-        optionId: option.id,
-        attemptType: attempt.type,
-        failure: paymentFailureSchema.parse({
-          reason: `Facilitator settle request failed: ${settleResponse.status}`,
-          code: "verification_failed",
-          retryable: settleResponse.status >= 500
-        })
+        error: error instanceof Error ? error.message : String(error)
       };
     }
-    const settlePayload = await settleResponse.json();
-    if (!settlePayload.success) {
-      return {
-        success: false,
-        optionId: option.id,
-        attemptType: attempt.type,
-        failure: paymentFailureSchema.parse({
-          reason: settlePayload.error ?? "Facilitator settlement failed",
-          code: "verification_failed",
-          retryable: false
-        })
-      };
+  }
+  async signTransferAuthorization(params) {
+    if (!this.walletClient.chain) {
+      throw new Error("Wallet client chain not configured");
     }
-    const metadata = paymentSuccessMetadataSchema.parse({
-      optionId: option.id,
-      verifier: facilitator.vendor ?? "facilitator",
-      txHash: settlePayload.txHash ?? void 0,
-      networkId: settlePayload.networkId ?? void 0
-    });
-    return {
-      success: true,
-      optionId: option.id,
-      attemptType: attempt.type,
-      metadata,
-      responseHeaders: {
-        [HEADER_PAYMENT_RESPONSE]: createPaymentResponseHeader(metadata)
-      }
+    const domain = {
+      name: "USD Coin",
+      version: "2",
+      chainId: this.walletClient.chain.id,
+      verifyingContract: params.tokenAddress
     };
-  } catch (error) {
+    const types = {
+      TransferWithAuthorization: [
+        { name: "from", type: "address" },
+        { name: "to", type: "address" },
+        { name: "value", type: "uint256" },
+        { name: "validAfter", type: "uint256" },
+        { name: "validBefore", type: "uint256" },
+        { name: "nonce", type: "bytes32" }
+      ]
+    };
+    const message = {
+      from: params.from,
+      to: params.to,
+      value: params.value,
+      validAfter: params.validAfter,
+      validBefore: params.validBefore,
+      nonce: params.nonce
+    };
+    const signature = await this.walletClient.signTypedData({
+      account: this.account,
+      domain,
+      types,
+      primaryType: "TransferWithAuthorization",
+      message
+    });
     return {
-      success: false,
-      optionId: option.id,
-      attemptType: attempt.type,
-      failure: paymentFailureSchema.parse({
-        reason: `Facilitator request error: ${error.message}`,
-        code: "verification_failed",
-        retryable: false
-      })
+      signature,
+      from: params.from,
+      to: params.to,
+      value: params.value,
+      validAfter: params.validAfter,
+      validBefore: params.validBefore,
+      nonce: params.nonce
     };
-  } finally {
-    if (timeout) {
-      clearTimeout(timeout);
-    }
   }
-}
-function buildFacilitatorHeaders(config) {
-  const headers = {
-    "content-type": "application/json"
-  };
-  if (config?.headers) {
-    Object.assign(headers, config.headers);
-  }
-  const apiKey = resolveFacilitatorApiKey(config);
-  if (apiKey) {
-    const headerName = config?.apiKeyHeader ?? "Authorization";
-    headers[headerName] = apiKey;
+  getAddress() {
+    return this.account.address;
   }
-  return headers;
+};
+async function payX402(config) {
+  const client = new X402Client({
+    privateKey: config.privateKey,
+    ...config.rpcUrl ? { rpcUrl: config.rpcUrl } : {}
+  });
+  return client.pay({
+    url: config.url,
+    body: config.body
+  });
 }
-function resolveFacilitatorApiKey(config) {
-  if (!config) {
-    return void 0;
+var X402BrowserClient = class {
+  constructor(config) {
+    this.walletClient = config.walletClient;
+    this.chainId = config.chainId;
   }
-  if (config.apiKey) {
-    return config.apiKey;
-  }
-  if (config.apiKeyEnv && typeof process !== "undefined") {
-    return process.env?.[config.apiKeyEnv];
+  async pay(request) {
+    try {
+      const initialResponse = await fetch(request.url, {
+        method: request.method ?? "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...request.headers
+        },
+        ...request.body ? { body: JSON.stringify(request.body) } : {}
+      });
+      if (initialResponse.status !== 402) {
+        return {
+          success: initialResponse.ok,
+          response: initialResponse
+        };
+      }
+      const paymentRequirements = await initialResponse.json();
+      const x402Requirements = paymentRequirements.x402?.accepts?.[0];
+      if (!x402Requirements) {
+        return {
+          success: false,
+          error: "No x402 payment requirements found in 402 response"
+        };
+      }
+      const account = this.walletClient.account;
+      if (!account) {
+        return {
+          success: false,
+          error: "No account connected to wallet"
+        };
+      }
+      const authorization = {
+        from: account.address,
+        to: x402Requirements.payTo,
+        value: BigInt(x402Requirements.maxAmountRequired),
+        validAfter: BigInt(Math.floor(Date.now() / 1e3)),
+        validBefore: BigInt(Math.floor(Date.now() / 1e3) + 900),
+        nonce: `0x${Array.from(
+          { length: 32 },
+          () => Math.floor(Math.random() * 256).toString(16).padStart(2, "0")
+        ).join("")}`
+      };
+      const signature = await this.signTransferAuthorization(
+        authorization,
+        x402Requirements.asset
+      );
+      const paymentProof = {
+        x402Version: 1,
+        scheme: x402Requirements.scheme,
+        network: x402Requirements.network,
+        correlationId: "",
+        payload: {
+          signature,
+          authorization: {
+            from: authorization.from,
+            to: authorization.to,
+            value: authorization.value.toString(),
+            validAfter: authorization.validAfter.toString(),
+            validBefore: authorization.validBefore.toString(),
+            nonce: authorization.nonce
+          }
+        }
+      };
+      const paymentHeader = btoa(JSON.stringify(paymentProof));
+      const paidResponse = await fetch(request.url, {
+        method: request.method ?? "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "X-PAYMENT": paymentHeader,
+          ...request.headers
+        },
+        ...request.body ? { body: JSON.stringify(request.body) } : {}
+      });
+      return {
+        success: paidResponse.ok,
+        response: paidResponse,
+        paymentDetails: {
+          amount: x402Requirements.maxAmountRequired,
+          currency: x402Requirements.extra?.currencyCode ?? "USDC",
+          network: x402Requirements.network,
+          signature
+        }
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
   }
-  return void 0;
-}
-function ensureTrailingSlash(value) {
-  return value.endsWith("/") ? value : `${value}/`;
-}
-var PAYMENT_HEADERS = {
-  x402: HEADER_X402,
-  direct: HEADER_DIRECT,
-  response: HEADER_PAYMENT_RESPONSE
-};
-
-// src/payment/index.ts
-var DEFAULT_ID_X402 = "x402";
-var DEFAULT_ID_402 = "402";
-var SUPPORTED_CURRENCIES = {
-  USDC: {
-    decimals: 6,
-    symbol: "USDC",
-    x402: {
-      network: "base",
-      assetAddress: "0x833589fCD6eDb6E08f4c7C37b7b4c6e997E08A43"
+  async signTransferAuthorization(authorization, tokenAddress) {
+    const account = this.walletClient.account;
+    if (!account) {
+      throw new Error("No account connected to wallet");
     }
+    const domain = {
+      name: "USD Coin",
+      version: "2",
+      chainId: this.chainId,
+      verifyingContract: tokenAddress
+    };
+    const types = {
+      TransferWithAuthorization: [
+        { name: "from", type: "address" },
+        { name: "to", type: "address" },
+        { name: "value", type: "uint256" },
+        { name: "validAfter", type: "uint256" },
+        { name: "validBefore", type: "uint256" },
+        { name: "nonce", type: "bytes32" }
+      ]
+    };
+    const message = {
+      from: authorization.from,
+      to: authorization.to,
+      value: authorization.value,
+      validAfter: authorization.validAfter,
+      validBefore: authorization.validBefore,
+      nonce: authorization.nonce
+    };
+    return await this.walletClient.signTypedData({
+      account,
+      domain,
+      types,
+      primaryType: "TransferWithAuthorization",
+      message
+    });
   }
 };
-var DEFAULT_FACILITATORS = {
-  opentool: "https://facilitator.opentool.dev/x402",
-  coinbase: "https://payments.coinbase.com/x402"
-};
-var PAYMENT_CONTEXT_SYMBOL = Symbol.for("opentool.payment.context");
-var PaymentRequiredError = class extends Error {
+async function payX402WithWallet(walletClient, chainId, request) {
+  const client = new X402BrowserClient({ walletClient, chainId });
+  return client.pay(request);
+}
+
+// src/x402/index.ts
+var PAYMENT_CONTEXT_SYMBOL = Symbol.for("opentool.x402.context");
+var X402PaymentRequiredError = class extends Error {
   constructor(response, verification) {
-    super("Payment required");
-    this.name = "PaymentRequiredError";
+    super("X402 Payment required");
+    this.name = "X402PaymentRequiredError";
     this.response = response;
     this.verification = verification;
   }
@@ -687,246 +584,133 @@ function setPaymentContext(request, context) {
     request[PAYMENT_CONTEXT_SYMBOL] = context;
   }
 }
-function getPaymentContext(request) {
+function getX402PaymentContext(request) {
   return request[PAYMENT_CONTEXT_SYMBOL];
 }
-function applyPaymentHeaders(response, headers) {
-  const entries = Object.entries(headers ?? {});
-  if (entries.length === 0) {
-    return response;
-  }
-  let mutated = false;
-  const merged = new Headers(response.headers);
-  for (const [key, value] of entries) {
-    if (!merged.has(key)) {
-      merged.set(key, value);
-      mutated = true;
-    }
-  }
-  if (!mutated) {
-    return response;
-  }
-  return new Response(response.body, {
-    status: response.status,
-    statusText: response.statusText,
-    headers: merged
-  });
-}
-function withPaymentRequirement(handler, payment, options = {}) {
-  return async (request) => {
-    const verification = await requirePayment(request, payment, options);
-    if (verification instanceof Response) {
-      return verification;
-    }
-    setPaymentContext(request, verification);
-    const response = await Promise.resolve(handler(request));
-    return applyPaymentHeaders(response, verification.headers);
-  };
-}
-function definePayment(config) {
-  const verifiers = {
-    ...config.verifiers ?? {}
-  };
-  const methods = config.acceptedMethods ?? ["402"];
-  const includeX402 = methods.includes("x402");
-  const includePlain402 = methods.includes("402");
-  if (!includeX402 && !includePlain402) {
-    throw new Error(
-      "definePayment requires at least one payment transport (x402 or 402)"
-    );
-  }
+function defineX402Payment(config) {
   const currencyCode = normalizeCurrency(config.currency);
   const currencySpec = SUPPORTED_CURRENCIES[currencyCode];
   if (!currencySpec) {
-    throw new Error(`Unsupported currency for payments: ${currencyCode}`);
+    throw new Error(`Unsupported currency for x402 payments: ${currencyCode}`);
   }
-  const decimals = currencySpec.decimals;
-  const symbol = currencySpec.symbol;
-  const value = toDecimalString(config.amount);
-  const accepts = [];
-  if (includeX402) {
-    const overrides = config.x402 ?? {};
-    const defaults = currencySpec.x402;
-    if (!defaults && (!overrides.network || !overrides.assetAddress)) {
-      throw new Error(
-        "x402 payments require a network and assetAddress; supply them or choose a supported currency."
-      );
-    }
-    const facilitator = resolveFacilitator(
-      config.facilitator ?? overrides.facilitator ?? "opentool"
-    );
-    accepts.push(
-      paymentOptionSchema.parse({
-        id: overrides.id ?? DEFAULT_ID_X402,
-        title: `Pay ${value} ${currencyCode}`,
-        amount: {
-          value,
-          currency: { code: currencyCode, symbol, decimals }
-        },
-        asset: {
-          symbol,
-          network: overrides.network ?? defaults?.network ?? "",
-          address: overrides.assetAddress ?? defaults?.assetAddress ?? "",
-          decimals,
-          standard: "erc20"
-        },
-        payTo: config.payTo,
-        proof: {
-          mode: "x402",
-          network: overrides.network ?? defaults?.network ?? "",
-          scheme: overrides.scheme ?? "exact",
-          version: overrides.version ?? 1,
-          facilitator,
-          verifier: facilitator ? "x402:facilitator" : void 0
-        },
-        settlement: overrides.settlement
-      })
-    );
-  }
-  if (includePlain402) {
-    const overrides = config.direct ?? {};
-    const id = overrides.id ?? DEFAULT_ID_402;
-    const verifierId = overrides.verifierId ?? `direct:${id}`;
-    const proofType = overrides.proofType ?? id;
-    const verifier = overrides.verify ?? buildDefaultDirectVerifier(overrides.token, verifierId, id);
-    verifiers[verifierId] = verifier;
-    accepts.push(
-      paymentOptionSchema.parse({
-        id,
-        title: `Pay ${value} ${currencyCode}`,
-        amount: {
-          value,
-          currency: { code: currencyCode, symbol, decimals }
-        },
-        asset: {
-          symbol,
-          decimals,
-          standard: "erc20"
-        },
-        payTo: config.payTo,
-        proof: {
-          mode: "direct",
-          proofTypes: [proofType],
-          verifier: verifierId,
-          instructions: overrides.instructions,
-          fields: overrides.fields,
-          allowsManualReview: overrides.allowsManualReview
-        },
-        settlement: overrides.settlement
-      })
+  const network = config.network ?? currencySpec.network;
+  const assetAddress = config.assetAddress ?? currencySpec.assetAddress;
+  if (!network || !assetAddress) {
+    throw new Error(
+      "x402 payments require a network and assetAddress; supply them or choose a supported currency."
     );
   }
-  const facilitatorLabel = includeX402 ? resolveFacilitatorLabel(config.facilitator ?? config.x402?.facilitator) : void 0;
-  const baseMetadata = {};
-  if (currencyCode === "USDC") {
-    baseMetadata.amountUSDC = Number(value);
-  }
-  baseMetadata.x402 = includeX402;
-  baseMetadata.plain402 = includePlain402;
-  baseMetadata.acceptedMethods = methods;
-  baseMetadata.acceptedCurrencies = config.acceptedCurrencies ?? [currencyCode];
-  if (config.chains) {
-    baseMetadata.chains = config.chains;
-  }
-  if (facilitatorLabel) {
-    baseMetadata.facilitator = facilitatorLabel;
-  }
-  const metadata = config.metadata ? { ...baseMetadata, ...config.metadata } : baseMetadata;
+  const facilitator = resolveFacilitator(config.facilitator);
+  const value = toDecimalString(config.amount);
   const definition = {
-    schemaVersion: PAYMENT_SCHEMA_VERSION,
-    accepts,
-    metadata
+    amount: value,
+    currency: {
+      code: currencyCode,
+      symbol: currencySpec.symbol,
+      decimals: currencySpec.decimals
+    },
+    asset: {
+      symbol: currencySpec.symbol,
+      network,
+      address: assetAddress,
+      decimals: currencySpec.decimals
+    },
+    payTo: config.payTo,
+    scheme: config.scheme ?? "exact",
+    network,
+    facilitator
   };
-  if (config.message !== void 0) {
-    definition.message = config.message;
-  }
-  if (config.resource !== void 0) {
+  if (config.resource) {
     definition.resource = config.resource;
   }
-  const defined = {
+  if (config.message) {
+    definition.description = config.message;
+  }
+  if (config.metadata) {
+    definition.metadata = config.metadata;
+  }
+  const baseMetadata = {
+    amountUSDC: currencyCode === "USDC" ? Number(value) : void 0,
+    facilitator: "x402rs",
+    network
+  };
+  const metadata = config.metadata ? { ...baseMetadata, ...config.metadata } : baseMetadata;
+  return {
     definition,
-    verifiers,
     metadata
   };
-  if (config.message !== void 0) {
-    defined.message = config.message;
-  }
-  return defined;
 }
-async function requirePayment(request, payment, options = {}) {
-  const { definition, verifiers } = normalizePayment(payment);
-  const mergedVerifiers = {
-    ...verifiers,
-    ...options.verifiers ?? {}
-  };
+async function requireX402Payment(request, payment, options = {}) {
+  const definition = isX402Payment(payment) ? payment.definition : payment;
+  const attempt = extractX402Attempt(request);
+  if (!attempt) {
+    const response = createX402PaymentRequired(definition);
+    throw new X402PaymentRequiredError(response);
+  }
   const verifyOptions = {
-    definition,
-    request
+    settle: options.settle !== void 0 ? options.settle : true
   };
-  if (Object.keys(mergedVerifiers).length > 0) {
-    verifyOptions.verifiers = mergedVerifiers;
-  }
-  if (options.settle !== void 0) {
-    verifyOptions.settle = options.settle;
-  }
-  if (options.fetchImpl) {
+  if (options.fetchImpl !== void 0) {
     verifyOptions.fetchImpl = options.fetchImpl;
   }
-  const verification = await verifyPayment(verifyOptions);
+  const verification = await verifyX402Payment(attempt, definition, verifyOptions);
   if (!verification.success || !verification.metadata) {
     if (options.onFailure) {
       return options.onFailure(verification);
     }
-    const response = paymentRequiredResponse(definition);
-    throw new PaymentRequiredError(response, verification);
+    const response = createX402PaymentRequired(definition);
+    throw new X402PaymentRequiredError(response, verification);
   }
   return {
     payment: verification.metadata,
     headers: verification.responseHeaders ?? {},
-    optionId: verification.optionId,
     result: verification
   };
 }
-function normalizePayment(payment) {
-  if (isDefinedPayment(payment)) {
-    return {
-      definition: payment.definition,
-      verifiers: payment.verifiers ?? {}
-    };
-  }
-  return {
-    definition: payment,
-    verifiers: {}
+function withX402Payment(handler, payment, options = {}) {
+  return async (request) => {
+    const verification = await requireX402Payment(request, payment, options);
+    if (verification instanceof Response) {
+      return verification;
+    }
+    setPaymentContext(request, verification);
+    const response = await Promise.resolve(handler(request));
+    return applyPaymentHeaders(response, verification.headers);
   };
 }
-function isDefinedPayment(value) {
-  return !!value && typeof value === "object" && "definition" in value && value.definition !== void 0;
-}
-function resolveFacilitator(value) {
-  if (!value) {
-    return void 0;
+function applyPaymentHeaders(response, headers) {
+  const entries = Object.entries(headers ?? {});
+  if (entries.length === 0) {
+    return response;
   }
-  if (typeof value === "string") {
-    if (value in DEFAULT_FACILITATORS) {
-      return {
-        url: DEFAULT_FACILITATORS[value]
-      };
+  let mutated = false;
+  const merged = new Headers(response.headers);
+  for (const [key, value] of entries) {
+    if (!merged.has(key)) {
+      merged.set(key, value);
+      mutated = true;
     }
-    return { url: value };
   }
-  return value;
+  if (!mutated) {
+    return response;
+  }
+  return new Response(response.body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers: merged
+  });
 }
-function resolveFacilitatorLabel(value) {
+function isX402Payment(value) {
+  return !!value && typeof value === "object" && "definition" in value && value.definition !== void 0;
+}
+function resolveFacilitator(value) {
   if (!value) {
-    return "opentool";
+    return DEFAULT_FACILITATOR;
   }
   if (typeof value === "string") {
-    if (value === "opentool" || value === "coinbase") {
-      return value;
-    }
-    return "custom";
+    return { ...DEFAULT_FACILITATOR, url: value };
   }
-  return "custom";
+  return value;
 }
 function normalizeCurrency(currency) {
   return (currency ?? "USDC").toUpperCase();
@@ -934,55 +718,6 @@ function normalizeCurrency(currency) {
 function toDecimalString(value) {
   return typeof value === "number" ? value.toString() : value;
 }
-function buildDefaultDirectVerifier(expectedToken, verifierId, optionId) {
-  return async ({ attempt, option }) => {
-    if (attempt.type !== "direct") {
-      return {
-        success: false,
-        optionId: option.id,
-        attemptType: attempt.type,
-        failure: {
-          reason: "Expected direct payment payload",
-          code: "invalid_payload"
-        }
-      };
-    }
-    const payload = attempt.payload.payload;
-    if (expectedToken) {
-      if (payload?.token !== expectedToken) {
-        return {
-          success: false,
-          optionId: option.id,
-          attemptType: attempt.type,
-          failure: {
-            reason: "Invalid or missing payment proof",
-            code: "verification_failed"
-          }
-        };
-      }
-    } else if (!payload) {
-      return {
-        success: false,
-        optionId: option.id,
-        attemptType: attempt.type,
-        failure: {
-          reason: "Payment proof is required",
-          code: "verification_failed"
-        }
-      };
-    }
-    return {
-      success: true,
-      optionId,
-      attemptType: attempt.type,
-      metadata: {
-        optionId,
-        verifier: verifierId,
-        payload
-      }
-    };
-  };
-}
 
 // src/adapters/mcp.ts
 var HTTP_METHODS = [
@@ -1010,7 +745,7 @@ function createMcpAdapter(options) {
       const response = await Promise.resolve(httpHandler(request));
       return await responseToToolResponse(response);
     } catch (error) {
-      if (error instanceof PaymentRequiredError) {
+      if (error instanceof X402PaymentRequiredError) {
         return await responseToToolResponse(error.response);
       }
       throw error;
@@ -1249,7 +984,7 @@ async function loadToolsFromDirectory(metadataMap) {
           const entry = httpHandlers[index];
           httpHandlers[index] = {
             ...entry,
-            handler: withPaymentRequirement(entry.handler, payment)
+            handler: withX402Payment(entry.handler, payment)
           };
         }
       }
@@ -2505,23 +2240,45 @@ var McpAnnotationsSchema = z.object({
   openWorldHint: z.boolean().optional(),
   requiresPayment: z.boolean().optional()
 }).strict();
-var PaymentConfigSchema = z.object({
-  amountUSDC: z.number().nonnegative().optional(),
-  description: z.string().optional(),
-  x402: z.boolean().optional(),
-  plain402: z.boolean().optional(),
-  acceptedMethods: z.array(z.union([z.literal("x402"), z.literal("402")])).optional(),
-  acceptedCurrencies: z.array(z.string()).optional(),
-  chains: z.array(z.union([z.string(), z.number()])).optional(),
-  facilitator: z.string().optional()
-}).strict();
+var X402PaymentSchema = z.object({
+  definition: z.object({
+    amount: z.string(),
+    currency: z.object({
+      code: z.string(),
+      symbol: z.string(),
+      decimals: z.number()
+    }),
+    asset: z.object({
+      symbol: z.string(),
+      network: z.string(),
+      address: z.string(),
+      decimals: z.number()
+    }),
+    payTo: z.string(),
+    resource: z.string().optional(),
+    description: z.string().optional(),
+    scheme: z.string(),
+    network: z.string(),
+    facilitator: z.object({
+      url: z.string(),
+      verifyPath: z.string().optional(),
+      settlePath: z.string().optional(),
+      apiKeyHeader: z.string().optional()
+    }),
+    metadata: z.record(z.string(), z.unknown()).optional()
+  }),
+  metadata: z.record(z.string(), z.unknown()).optional()
+}).passthrough();
+var PaymentConfigSchema = z.union([
+  X402PaymentSchema,
+  z.record(z.string(), z.unknown())
+]);
 var DiscoveryMetadataSchema = z.object({
   keywords: z.array(z.string()).optional(),
   category: z.string().optional(),
   useCases: z.array(z.string()).optional(),
   capabilities: z.array(z.string()).optional(),
   requirements: z.record(z.string(), z.any()).optional(),
-  pricing: z.record(z.string(), z.any()).optional(),
   compatibility: z.record(z.string(), z.any()).optional(),
   documentation: z.union([z.string(), z.array(z.string())]).optional()
 }).catchall(z.any());
@@ -2542,7 +2299,7 @@ var ToolSchema = z.object({
   discovery: DiscoveryMetadataSchema.optional(),
   chains: z.array(z.union([z.string(), z.number()])).optional()
 }).strict();
-var AuthoredMetadataSchema = z.object({
+var MetadataSchema = z.object({
   metadataSpecVersion: z.string().optional(),
   name: z.string().optional(),
   displayName: z.string().optional(),
@@ -2566,11 +2323,10 @@ var AuthoredMetadataSchema = z.object({
   useCases: z.array(z.string()).optional(),
   capabilities: z.array(z.string()).optional(),
   requirements: z.record(z.string(), z.any()).optional(),
-  pricing: z.record(z.string(), z.any()).optional(),
   compatibility: z.record(z.string(), z.any()).optional(),
   chains: z.array(z.union([z.string(), z.number()])).optional()
 }).catchall(z.any());
-var MetadataSchema = z.object({
+var BuildMetadataSchema = z.object({
   metadataSpecVersion: z.string().default(METADATA_SPEC_VERSION),
   name: z.string(),
   displayName: z.string(),
@@ -2672,7 +2428,7 @@ async function importFresh(modulePath) {
 
 // src/cli/shared/metadata.ts
 var METADATA_ENTRY = "metadata.ts";
-async function loadAuthoredMetadata(projectRoot) {
+async function loadMetadata2(projectRoot) {
   const absPath = path5.join(projectRoot, METADATA_ENTRY);
   if (!fs2.existsSync(absPath)) {
     throw new Error(
@@ -2693,7 +2449,7 @@ async function loadAuthoredMetadata(projectRoot) {
     const compiledPath = resolveCompiledPath(outDir, METADATA_ENTRY);
     const moduleExports = await importFresh(compiledPath);
     const metadataExport = extractMetadataExport(moduleExports);
-    const parsed = AuthoredMetadataSchema.parse(metadataExport);
+    const parsed = MetadataSchema.parse(metadataExport);
     return { metadata: parsed, sourcePath: absPath };
   } finally {
     cleanup();
@@ -2734,7 +2490,7 @@ function readPackageJson(projectRoot) {
 async function buildMetadataArtifact(options) {
   const projectRoot = options.projectRoot;
   const packageInfo = readPackageJson(projectRoot);
-  const { metadata: authored, sourcePath } = await loadAuthoredMetadata(projectRoot);
+  const { metadata: authored, sourcePath } = await loadMetadata2(projectRoot);
   const defaultsApplied = [];
   const folderName = path5.basename(projectRoot);
   const name = resolveField(
@@ -2779,7 +2535,7 @@ async function buildMetadataArtifact(options) {
   if (!authored.website && packageInfo.homepage) {
     defaultsApplied.push("website \u2192 package.json homepage");
   }
-  const payment = resolvePayment(authored, defaultsApplied);
+  const payment = resolvePayment(authored);
   const baseImage = authored.image ?? authored.iconPath;
   const animation = authored.animation_url ?? authored.videoPath;
   const discovery = buildDiscovery(authored);
@@ -2812,7 +2568,7 @@ async function buildMetadataArtifact(options) {
     }
     return toolDefinition;
   });
-  const metadata = MetadataSchema.parse({
+  const metadata = BuildMetadataSchema.parse({
     metadataSpecVersion: authored.metadataSpecVersion ?? METADATA_SPEC_VERSION,
     name,
     displayName,
@@ -2868,32 +2624,8 @@ function extractRepository(repository) {
   }
   return repository.url;
 }
-function resolvePayment(authored, defaults) {
-  if (authored.payment) {
-    return authored.payment;
-  }
-  const discoveryPricing = authored.discovery?.pricing;
-  const legacyPricing = authored.pricing;
-  const pricing = discoveryPricing ?? legacyPricing;
-  if (!pricing) {
-    return void 0;
-  }
-  const amount = typeof pricing.defaultAmount === "number" ? pricing.defaultAmount : 0;
-  const sourceLabel = discoveryPricing ? "discovery.pricing.defaultAmount" : "pricing.defaultAmount";
-  defaults.push(`payment \u2192 synthesized from ${sourceLabel}`);
-  const acceptedMethodsRaw = Array.isArray(pricing.acceptedMethods) ? pricing.acceptedMethods : ["402"];
-  const acceptedMethods = acceptedMethodsRaw.map(
-    (method) => method === "x402" ? "x402" : "402"
-  );
-  return {
-    amountUSDC: amount,
-    description: typeof pricing.description === "string" ? pricing.description : void 0,
-    x402: acceptedMethods.includes("x402"),
-    plain402: acceptedMethods.includes("402"),
-    acceptedMethods,
-    acceptedCurrencies: Array.isArray(pricing.acceptedCurrencies) ? pricing.acceptedCurrencies : ["USDC"],
-    chains: Array.isArray(pricing.chains) ? pricing.chains : [8453]
-  };
+function resolvePayment(authored, _defaults) {
+  return authored.payment ?? void 0;
 }
 function buildDiscovery(authored) {
   const legacyDiscovery = {};
@@ -2915,9 +2647,6 @@ function buildDiscovery(authored) {
   if (Array.isArray(authored.categories) && authored.categories.length > 0) {
     legacyDiscovery.category = authored.categories[0];
   }
-  if (authored.pricing) {
-    legacyDiscovery.pricing = authored.pricing;
-  }
   const merged = {
     ...legacyDiscovery,
     ...authored.discovery ?? {}
@@ -3000,7 +2729,7 @@ async function loadAndValidateTools(toolsDir, options = {}) {
           const entry = httpHandlers[index];
           httpHandlers[index] = {
             ...entry,
-            handler: withPaymentRequirement(entry.handler, paymentExport)
+            handler: withX402Payment(entry.handler, paymentExport)
           };
         }
       }
@@ -3013,11 +2742,11 @@ async function loadAndValidateTools(toolsDir, options = {}) {
         ...schema ? { schema } : {}
       });
       let metadataOverrides = toolModule.metadata ?? null;
-      if (paymentExport?.metadata) {
+      if (paymentExport) {
         if (metadataOverrides) {
           metadataOverrides = {
             ...metadataOverrides,
-            payment: metadataOverrides.payment ?? paymentExport.metadata,
+            payment: metadataOverrides.payment ?? paymentExport,
             annotations: {
               ...metadataOverrides.annotations ?? {},
               requiresPayment: metadataOverrides.annotations?.requiresPayment ?? true
@@ -3025,7 +2754,7 @@ async function loadAndValidateTools(toolsDir, options = {}) {
           };
         } else {
           metadataOverrides = {
-            payment: paymentExport.metadata,
+            payment: paymentExport,
             annotations: { requiresPayment: true }
           };
         }
@@ -3271,6 +3000,6 @@ function timestamp() {
   return (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19);
 }
 
-export { AIAbortError, AIError, AIFetchError, AIResponseError, DEFAULT_BASE_URL, DEFAULT_CHAIN, DEFAULT_MODEL, DEFAULT_TIMEOUT_MS, DEFAULT_TOKENS, HEADER_PAYMENT_RESPONSE, HTTP_METHODS2 as HTTP_METHODS, PAYMENT_HEADERS, PAYMENT_SCHEMA_VERSION, PaymentRequiredError, WEBSEARCH_TOOL_DEFINITION, WEBSEARCH_TOOL_NAME, chains, createAIClient, createDevServer, createMcpAdapter, createPaymentRequiredBody, createPaymentResponseHeader, createStdioServer, cryptoAssetSchema, currencySchema, decimalStringSchema, definePayment, directPaymentPayloadSchema, directProofSchema, ensureTextContent, extractPaymentAttempts, facilitatorConfigSchema, flattenMessageContent, generateMetadata, generateMetadataCommand, generateText, getModelConfig, getPaymentContext, getRpcUrl, isStreamingSupported, isToolCallingSupported, listModels, loadAndValidateTools, normalizeModelName, paymentAmountSchema, paymentFailureSchema, paymentFieldSchema, paymentOptionSchema, paymentProofSchema, paymentRequiredResponse, paymentRequirementsSchema, paymentSchemaVersionSchema, paymentSuccessMetadataSchema, registry, requirePayment, resolveConfig, resolveRuntimePath, resolveToolset, responseToToolResponse, settlementTermsSchema, streamText, tokens, validateCommand, verifyPayment, wallet, walletToolkit, withPaymentRequirement, x402PaymentHeaderSchema, x402ProofSchema };
+export { AIAbortError, AIError, AIFetchError, AIResponseError, DEFAULT_BASE_URL, DEFAULT_CHAIN, DEFAULT_FACILITATOR, DEFAULT_MODEL, DEFAULT_TIMEOUT_MS, DEFAULT_TOKENS, HTTP_METHODS2 as HTTP_METHODS, PAYMENT_HEADERS, SUPPORTED_CURRENCIES, WEBSEARCH_TOOL_DEFINITION, WEBSEARCH_TOOL_NAME, X402BrowserClient, X402Client, X402PaymentRequiredError, chains, createAIClient, createDevServer, createMcpAdapter, createStdioServer, defineX402Payment, ensureTextContent, flattenMessageContent, generateMetadata, generateMetadataCommand, generateText, getModelConfig, getRpcUrl, getX402PaymentContext, isStreamingSupported, isToolCallingSupported, listModels, loadAndValidateTools, normalizeModelName, payX402, payX402WithWallet, registry, requireX402Payment, resolveConfig, resolveRuntimePath, resolveToolset, responseToToolResponse, streamText, tokens, validateCommand, wallet, walletToolkit, withX402Payment };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map