opentool 0.7.2 → 0.7.3

package/dist/cli/index.js

@@ -8,10 +8,13 @@ import { z } from 'zod';
 import { createRequire } from 'module';
 import { fileURLToPath, pathToFileURL } from 'url';
 import { zodToJsonSchema } from '@alcyone-labs/zod-to-json-schema';
+import 'viem';
+import 'viem/accounts';
+import 'viem/chains';
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { ListToolsRequestSchema, CallToolRequestSchema } from '@modelcontextprotocol/sdk/types.js';
-import * as http from 'http';
+import * as http2 from 'http';
 
 function resolveTsconfig(projectRoot) {
   const candidate = path5.join(projectRoot, "tsconfig.json");
@@ -88,23 +91,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());
@@ -125,7 +150,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(),
@@ -149,11 +174,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(),
@@ -189,7 +213,7 @@ async function importFresh(modulePath) {
 
 // src/cli/shared/metadata.ts
 var METADATA_ENTRY = "metadata.ts";
-async function loadAuthoredMetadata(projectRoot) {
+async function loadMetadata(projectRoot) {
   const absPath = path5.join(projectRoot, METADATA_ENTRY);
   if (!fs4.existsSync(absPath)) {
     throw new Error(
@@ -210,7 +234,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();
@@ -251,7 +275,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 loadMetadata(projectRoot);
   const defaultsApplied = [];
   const folderName = path5.basename(projectRoot);
   const name = resolveField(
@@ -296,7 +320,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);
@@ -329,7 +353,7 @@ async function buildMetadataArtifact(options) {
     }
     return toolDefinition;
   });
-  const metadata = MetadataSchema.parse({
+  const metadata = BuildMetadataSchema.parse({
     metadataSpecVersion: authored.metadataSpecVersion ?? METADATA_SPEC_VERSION,
     name,
     displayName,
@@ -385,32 +409,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 = {};
@@ -432,145 +432,14 @@ 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 ?? {}
   };
   return Object.keys(merged).length > 0 ? merged : void 0;
 }
-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),
@@ -585,272 +454,195 @@ 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()
+});
+
+// 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: 402,
-    headers
+    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);
@@ -864,10 +656,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;
@@ -876,200 +664,25 @@ 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
-      })
-    };
-  }
-  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
-    });
-    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
-        })
-      };
-    }
-    if (!settle) {
-      return {
-        success: true,
-        optionId: option.id,
-        attemptType: attempt.type,
-        metadata: paymentSuccessMetadataSchema.parse({
-          optionId: option.id,
-          verifier: facilitator.vendor ?? "facilitator"
-        })
-      };
-    }
-    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) {
-      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
-        })
-      };
-    }
-    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
-        })
-      };
-    }
-    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)
-      }
-    };
-  } catch (error) {
-    return {
-      success: false,
-      optionId: option.id,
-      attemptType: attempt.type,
-      failure: paymentFailureSchema.parse({
-        reason: `Facilitator request error: ${error.message}`,
-        code: "verification_failed",
-        retryable: false
-      })
-    };
-  } finally {
-    if (timeout) {
-      clearTimeout(timeout);
-    }
-  }
-}
-function buildFacilitatorHeaders(config) {
+function buildFacilitatorHeaders(facilitator) {
   const headers = {
-    "content-type": "application/json"
+    "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;
+  if (facilitator.apiKeyHeader && process.env.X402_FACILITATOR_API_KEY) {
+    headers[facilitator.apiKeyHeader] = process.env.X402_FACILITATOR_API_KEY;
   }
   return headers;
 }
-function resolveFacilitatorApiKey(config) {
-  if (!config) {
-    return void 0;
-  }
-  if (config.apiKey) {
-    return config.apiKey;
-  }
-  if (config.apiKeyEnv && typeof process !== "undefined") {
-    return process.env?.[config.apiKeyEnv];
-  }
-  return void 0;
-}
-function ensureTrailingSlash(value) {
-  return value.endsWith("/") ? value : `${value}/`;
+function ensureTrailingSlash(url) {
+  return url.endsWith("/") ? url : `${url}/`;
 }
 
-// src/payment/index.ts
-var PAYMENT_CONTEXT_SYMBOL = Symbol.for("opentool.payment.context");
-var PaymentRequiredError = class extends Error {
+// 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;
   }
@@ -1086,6 +699,45 @@ function setPaymentContext(request, context) {
     request[PAYMENT_CONTEXT_SYMBOL] = context;
   }
 }
+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 = {};
+  if (options.settle !== void 0) {
+    verifyOptions.settle = options.settle;
+  }
+  if (options.fetchImpl !== void 0) {
+    verifyOptions.fetchImpl = options.fetchImpl;
+  }
+  const verification = await verifyX402Payment(attempt, definition, verifyOptions);
+  if (!verification.success || !verification.metadata) {
+    if (options.onFailure) {
+      return options.onFailure(verification);
+    }
+    const response = createX402PaymentRequired(definition);
+    throw new X402PaymentRequiredError(response, verification);
+  }
+  return {
+    payment: verification.metadata,
+    headers: verification.responseHeaders ?? {},
+    result: verification
+  };
+}
+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 applyPaymentHeaders(response, headers) {
   const entries = Object.entries(headers ?? {});
   if (entries.length === 0) {
@@ -1108,64 +760,7 @@ function applyPaymentHeaders(response, headers) {
     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);
-  };
-}
-async function requirePayment(request, payment, options = {}) {
-  const { definition, verifiers } = normalizePayment(payment);
-  const mergedVerifiers = {
-    ...verifiers,
-    ...options.verifiers ?? {}
-  };
-  const verifyOptions = {
-    definition,
-    request
-  };
-  if (Object.keys(mergedVerifiers).length > 0) {
-    verifyOptions.verifiers = mergedVerifiers;
-  }
-  if (options.settle !== void 0) {
-    verifyOptions.settle = options.settle;
-  }
-  if (options.fetchImpl) {
-    verifyOptions.fetchImpl = options.fetchImpl;
-  }
-  const verification = await verifyPayment(verifyOptions);
-  if (!verification.success || !verification.metadata) {
-    if (options.onFailure) {
-      return options.onFailure(verification);
-    }
-    const response = paymentRequiredResponse(definition);
-    throw new PaymentRequiredError(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 isDefinedPayment(value) {
+function isX402Payment(value) {
   return !!value && typeof value === "object" && "definition" in value && value.definition !== void 0;
 }
 
@@ -1186,7 +781,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;
@@ -1406,7 +1001,7 @@ async function loadAndValidateTools(toolsDir, options = {}) {
           const entry = httpHandlers[index];
           httpHandlers[index] = {
             ...entry,
-            handler: withPaymentRequirement(entry.handler, paymentExport)
+            handler: withX402Payment(entry.handler, paymentExport)
           };
         }
       }
@@ -1419,11 +1014,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
@@ -1431,7 +1026,7 @@ async function loadAndValidateTools(toolsDir, options = {}) {
           };
         } else {
           metadataOverrides = {
-            payment: paymentExport.metadata,
+            payment: paymentExport,
             annotations: { requiresPayment: true }
           };
         }
@@ -2119,7 +1714,7 @@ Detected change in ${changedPath ?? "tools directory"}, reloading...${reset}`
         });
       }
     }
-    const server = http.createServer(async (req, res) => {
+    const server = http2.createServer(async (req, res) => {
       const method = (req.method || "GET").toUpperCase();
       const url = new URL(req.url || "/", `http://localhost:${port}`);
       const routePath = url.pathname;
@@ -2309,7 +1904,7 @@ async function handleRequest(params) {
   try {
     response = await route.handler(request);
   } catch (error) {
-    if (error instanceof PaymentRequiredError) {
+    if (error instanceof X402PaymentRequiredError) {
       response = error.response;
     } else {
       throw error;