@bankofai/x402-extensions 1.0.0-beta.0

package/dist/esm/chunk-4IPDE3NS.mjs

@@ -0,0 +1,990 @@
+// src/bazaar/http/types.ts
+var isQueryExtensionConfig = (config) => {
+  return !("bodyType" in config) && !("toolName" in config);
+};
+var isBodyExtensionConfig = (config) => {
+  return "bodyType" in config;
+};
+
+// src/bazaar/mcp/types.ts
+var isMcpExtensionConfig = (config) => {
+  return "toolName" in config;
+};
+
+// src/bazaar/types.ts
+var BAZAAR = { key: "bazaar" };
+
+// src/bazaar/http/resourceService.ts
+function createQueryDiscoveryExtension({
+  method,
+  input = {},
+  inputSchema = { properties: {} },
+  pathParams,
+  pathParamsSchema,
+  output
+}) {
+  return {
+    info: {
+      input: {
+        type: "http",
+        ...method ? { method } : {},
+        ...input ? { queryParams: input } : {},
+        ...pathParams ? { pathParams } : {}
+      },
+      ...output?.example ? {
+        output: {
+          type: "json",
+          example: output.example
+        }
+      } : {}
+    },
+    schema: {
+      $schema: "https://json-schema.org/draft/2020-12/schema",
+      type: "object",
+      properties: {
+        input: {
+          type: "object",
+          properties: {
+            type: {
+              type: "string",
+              const: "http"
+            },
+            method: {
+              type: "string",
+              enum: ["GET", "HEAD", "DELETE"]
+            },
+            ...inputSchema ? {
+              queryParams: {
+                type: "object",
+                ...typeof inputSchema === "object" ? inputSchema : {}
+              }
+            } : {},
+            ...pathParamsSchema ? {
+              pathParams: {
+                type: "object",
+                ...typeof pathParamsSchema === "object" ? pathParamsSchema : {}
+              }
+            } : {}
+          },
+          required: ["type", "method"],
+          // pathParams are not declared here at schema build time --
+          // the server extension's enrichDeclaration adds them to both info and schema
+          // atomically at request time, keeping data and schema consistent.
+          additionalProperties: false
+        },
+        ...output?.example ? {
+          output: {
+            type: "object",
+            properties: {
+              type: {
+                type: "string"
+              },
+              example: {
+                type: "object",
+                ...output.schema && typeof output.schema === "object" ? output.schema : {}
+              }
+            },
+            required: ["type"]
+          }
+        } : {}
+      },
+      required: ["input"]
+    }
+  };
+}
+function createBodyDiscoveryExtension({
+  method,
+  input = {},
+  inputSchema = { properties: {} },
+  pathParams,
+  pathParamsSchema,
+  bodyType,
+  output
+}) {
+  return {
+    info: {
+      input: {
+        type: "http",
+        ...method ? { method } : {},
+        bodyType,
+        body: input,
+        ...pathParams ? { pathParams } : {}
+      },
+      ...output?.example ? {
+        output: {
+          type: "json",
+          example: output.example
+        }
+      } : {}
+    },
+    schema: {
+      $schema: "https://json-schema.org/draft/2020-12/schema",
+      type: "object",
+      properties: {
+        input: {
+          type: "object",
+          properties: {
+            type: {
+              type: "string",
+              const: "http"
+            },
+            method: {
+              type: "string",
+              enum: ["POST", "PUT", "PATCH"]
+            },
+            bodyType: {
+              type: "string",
+              enum: ["json", "form-data", "text"]
+            },
+            body: inputSchema,
+            ...pathParamsSchema ? {
+              pathParams: {
+                type: "object",
+                ...typeof pathParamsSchema === "object" ? pathParamsSchema : {}
+              }
+            } : {}
+          },
+          required: ["type", "method", "bodyType", "body"],
+          // pathParams are not declared here at schema build time --
+          // the server extension's enrichDeclaration adds them to both info and schema
+          // atomically at request time, keeping data and schema consistent.
+          additionalProperties: false
+        },
+        ...output?.example ? {
+          output: {
+            type: "object",
+            properties: {
+              type: {
+                type: "string"
+              },
+              example: {
+                type: "object",
+                ...output.schema && typeof output.schema === "object" ? output.schema : {}
+              }
+            },
+            required: ["type"]
+          }
+        } : {}
+      },
+      required: ["input"]
+    }
+  };
+}
+
+// src/bazaar/mcp/resourceService.ts
+function createMcpDiscoveryExtension({
+  toolName,
+  description,
+  transport,
+  inputSchema,
+  example,
+  output
+}) {
+  return {
+    info: {
+      input: {
+        type: "mcp",
+        toolName,
+        ...description !== void 0 ? { description } : {},
+        ...transport !== void 0 ? { transport } : {},
+        inputSchema,
+        ...example !== void 0 ? { example } : {}
+      },
+      ...output?.example ? {
+        output: {
+          type: "json",
+          example: output.example
+        }
+      } : {}
+    },
+    schema: {
+      $schema: "https://json-schema.org/draft/2020-12/schema",
+      type: "object",
+      properties: {
+        input: {
+          type: "object",
+          properties: {
+            type: {
+              type: "string",
+              const: "mcp"
+            },
+            toolName: {
+              type: "string"
+            },
+            ...description !== void 0 ? {
+              description: {
+                type: "string"
+              }
+            } : {},
+            ...transport !== void 0 ? {
+              transport: {
+                type: "string",
+                ...transport === "streamable-http" || transport === "sse" ? { enum: [transport] } : {}
+              }
+            } : {},
+            inputSchema: {
+              type: "object"
+            },
+            ...example !== void 0 ? {
+              example: {
+                type: "object"
+              }
+            } : {}
+          },
+          required: ["type", "toolName", "inputSchema"],
+          additionalProperties: false
+        },
+        ...output?.example ? {
+          output: {
+            type: "object",
+            properties: {
+              type: {
+                type: "string"
+              },
+              example: {
+                type: "object",
+                ...output.schema && typeof output.schema === "object" ? output.schema : {}
+              }
+            },
+            required: ["type"]
+          }
+        } : {}
+      },
+      required: ["input"]
+    }
+  };
+}
+
+// src/bazaar/resourceService.ts
+function declareDiscoveryExtension(config) {
+  if ("toolName" in config) {
+    const extension2 = createMcpDiscoveryExtension(config);
+    return { bazaar: extension2 };
+  }
+  const bodyType = config.bodyType;
+  const isBodyMethod2 = bodyType !== void 0;
+  const extension = isBodyMethod2 ? createBodyDiscoveryExtension(config) : createQueryDiscoveryExtension(config);
+  return { bazaar: extension };
+}
+
+// src/bazaar/server.ts
+var BRACKET_PARAM_REGEX = /\[([^\]]+)\]/;
+var BRACKET_PARAM_REGEX_ALL = /\[([^\]]+)\]/g;
+var COLON_PARAM_REGEX = /:([a-zA-Z_][a-zA-Z0-9_]*)/;
+function isHTTPRequestContext(ctx) {
+  return ctx !== null && typeof ctx === "object" && "method" in ctx && "adapter" in ctx;
+}
+function normalizeWildcardPattern(pattern) {
+  if (!pattern.includes("*")) {
+    return pattern;
+  }
+  let counter = 0;
+  return pattern.split("/").map((seg) => {
+    if (seg === "*") {
+      counter++;
+      return `:var${counter}`;
+    }
+    return seg;
+  }).join("/");
+}
+function extractDynamicRouteInfo(routePattern, urlPath) {
+  const hasBracket = BRACKET_PARAM_REGEX.test(routePattern);
+  const hasColon = COLON_PARAM_REGEX.test(routePattern);
+  if (!hasBracket && !hasColon) {
+    return null;
+  }
+  const normalizedPattern = hasBracket ? routePattern.replace(BRACKET_PARAM_REGEX_ALL, ":$1") : routePattern;
+  const pathParams = extractPathParams(normalizedPattern, urlPath, false);
+  return { routeTemplate: normalizedPattern, pathParams };
+}
+function extractPathParams(routePattern, urlPath, isBracket) {
+  const paramNames = [];
+  const splitRegex = isBracket ? BRACKET_PARAM_REGEX : COLON_PARAM_REGEX;
+  const parts = routePattern.split(splitRegex);
+  const regexParts = [];
+  parts.forEach((part, i) => {
+    if (i % 2 === 0) {
+      regexParts.push(part.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+    } else {
+      paramNames.push(part);
+      regexParts.push("([^/]+)");
+    }
+  });
+  const regex = new RegExp(`^${regexParts.join("")}$`);
+  const match = urlPath.match(regex);
+  if (!match) return {};
+  const result = {};
+  paramNames.forEach((name, idx) => {
+    result[name] = match[idx + 1];
+  });
+  return result;
+}
+var bazaarResourceServerExtension = {
+  key: BAZAAR.key,
+  enrichDeclaration: (declaration, transportContext) => {
+    if (!isHTTPRequestContext(transportContext)) {
+      return declaration;
+    }
+    const extension = declaration;
+    if (extension.info?.input?.type === "mcp") {
+      return declaration;
+    }
+    const method = transportContext.method;
+    const existingInputProps = extension.schema?.properties?.input?.properties || {};
+    const updatedInputProps = {
+      ...existingInputProps,
+      method: {
+        type: "string",
+        enum: [method]
+      }
+    };
+    const enrichedResult = {
+      ...extension,
+      info: {
+        ...extension.info || {},
+        input: {
+          ...extension.info?.input || {},
+          method
+        }
+      },
+      schema: {
+        ...extension.schema || {},
+        properties: {
+          ...extension.schema?.properties || {},
+          input: {
+            ...extension.schema?.properties?.input || {},
+            properties: updatedInputProps,
+            required: [
+              ...extension.schema?.properties?.input?.required || [],
+              ...!(extension.schema?.properties?.input?.required || []).includes("method") ? ["method"] : []
+            ]
+          }
+        }
+      }
+    };
+    const rawRoutePattern = transportContext.routePattern;
+    const routePattern = rawRoutePattern ? normalizeWildcardPattern(rawRoutePattern) : void 0;
+    const dynamicRoute = routePattern ? extractDynamicRouteInfo(routePattern, transportContext.adapter.getPath()) : null;
+    if (dynamicRoute) {
+      const inputSchemaProps = enrichedResult.schema?.properties?.input?.properties || {};
+      const hasPathParamsInSchema = "pathParams" in inputSchemaProps;
+      return {
+        ...enrichedResult,
+        routeTemplate: dynamicRoute.routeTemplate,
+        info: {
+          ...enrichedResult.info,
+          input: { ...enrichedResult.info.input, pathParams: dynamicRoute.pathParams }
+        },
+        ...!hasPathParamsInSchema ? {
+          schema: {
+            ...enrichedResult.schema,
+            properties: {
+              ...enrichedResult.schema?.properties,
+              input: {
+                ...enrichedResult.schema?.properties?.input,
+                properties: {
+                  ...inputSchemaProps,
+                  pathParams: { type: "object" }
+                }
+              }
+            }
+          }
+        } : {}
+      };
+    }
+    return enrichedResult;
+  }
+};
+
+// src/bazaar/facilitator.ts
+import { domainToASCII } from "url";
+import Ajv from "ajv/dist/2020.js";
+
+// src/bazaar/v1/facilitator.ts
+function hasV1OutputSchema(obj) {
+  return obj !== null && typeof obj === "object" && "input" in obj && obj.input !== null && typeof obj.input === "object" && "type" in obj.input && obj.input.type === "http" && "method" in obj.input;
+}
+function isQueryMethod(method) {
+  const upperMethod = method.toUpperCase();
+  return upperMethod === "GET" || upperMethod === "HEAD" || upperMethod === "DELETE";
+}
+function isBodyMethod(method) {
+  const upperMethod = method.toUpperCase();
+  return upperMethod === "POST" || upperMethod === "PUT" || upperMethod === "PATCH";
+}
+function extractQueryParams(v1Input) {
+  if (v1Input.queryParams && typeof v1Input.queryParams === "object") {
+    return v1Input.queryParams;
+  }
+  if (v1Input.query_params && typeof v1Input.query_params === "object") {
+    return v1Input.query_params;
+  }
+  if (v1Input.query && typeof v1Input.query === "object") {
+    return v1Input.query;
+  }
+  if (v1Input.params && typeof v1Input.params === "object") {
+    return v1Input.params;
+  }
+  return void 0;
+}
+function extractBodyInfo(v1Input) {
+  let bodyType = "json";
+  const bodyTypeField = v1Input.bodyType || v1Input.body_type;
+  if (bodyTypeField && typeof bodyTypeField === "string") {
+    const type = bodyTypeField.toLowerCase();
+    if (type.includes("form") || type.includes("multipart")) {
+      bodyType = "form-data";
+    } else if (type.includes("text") || type.includes("plain")) {
+      bodyType = "text";
+    } else {
+      bodyType = "json";
+    }
+  }
+  let body = {};
+  if (v1Input.bodyFields && typeof v1Input.bodyFields === "object") {
+    body = v1Input.bodyFields;
+  } else if (v1Input.body_fields && v1Input.body_fields !== null && typeof v1Input.body_fields === "object") {
+    body = v1Input.body_fields;
+  } else if (v1Input.bodyParams && typeof v1Input.bodyParams === "object") {
+    body = v1Input.bodyParams;
+  } else if (v1Input.body && typeof v1Input.body === "object") {
+    body = v1Input.body;
+  } else if (v1Input.data && typeof v1Input.data === "object") {
+    body = v1Input.data;
+  } else if (v1Input.properties && typeof v1Input.properties === "object") {
+    body = v1Input.properties;
+  }
+  return { body, bodyType };
+}
+function extractDiscoveryInfoV1(paymentRequirements) {
+  const { outputSchema } = paymentRequirements;
+  if (!outputSchema || !hasV1OutputSchema(outputSchema)) {
+    return null;
+  }
+  const v1Input = outputSchema.input;
+  const isDiscoverable = v1Input.discoverable ?? true;
+  if (!isDiscoverable) {
+    return null;
+  }
+  const method = typeof v1Input.method === "string" ? v1Input.method.toUpperCase() : "";
+  const headersRaw = v1Input.headerFields || v1Input.header_fields || v1Input.headers;
+  const headers = headersRaw && typeof headersRaw === "object" ? headersRaw : void 0;
+  const output = outputSchema.output ? {
+    type: "json",
+    example: outputSchema.output
+  } : void 0;
+  if (isQueryMethod(method)) {
+    const queryParams = extractQueryParams(v1Input);
+    const discoveryInfo = {
+      input: {
+        type: "http",
+        method,
+        ...queryParams ? { queryParams } : {},
+        ...headers ? { headers } : {}
+      },
+      ...output ? { output } : {}
+    };
+    return discoveryInfo;
+  } else if (isBodyMethod(method)) {
+    const { body, bodyType } = extractBodyInfo(v1Input);
+    const queryParams = extractQueryParams(v1Input);
+    const discoveryInfo = {
+      input: {
+        type: "http",
+        method,
+        bodyType,
+        body,
+        ...queryParams ? { queryParams } : {},
+        ...headers ? { headers } : {}
+      },
+      ...output ? { output } : {}
+    };
+    return discoveryInfo;
+  }
+  return null;
+}
+function isDiscoverableV1(paymentRequirements) {
+  return extractDiscoveryInfoV1(paymentRequirements) !== null;
+}
+function extractResourceMetadataV1(paymentRequirements) {
+  return {
+    url: paymentRequirements.resource,
+    description: paymentRequirements.description,
+    mimeType: paymentRequirements.mimeType
+  };
+}
+function buildBazaarExtensionFromDiscoveryInfo(discoveryInfo) {
+  return {
+    info: discoveryInfo,
+    schema: {
+      $schema: "https://json-schema.org/draft/2020-12/schema",
+      type: "object",
+      properties: {
+        input: { type: "object" },
+        output: { type: "object" }
+      },
+      required: ["input"]
+    }
+  };
+}
+function buildV1CatalogExtensions(existingExtensions, discoveryInfo) {
+  if (existingExtensions?.[BAZAAR.key]) {
+    return existingExtensions;
+  }
+  const extensions = existingExtensions ? { ...existingExtensions } : {};
+  delete extensions.outputSchema;
+  extensions[BAZAAR.key] = buildBazaarExtensionFromDiscoveryInfo(discoveryInfo);
+  return extensions;
+}
+
+// src/bazaar/facilitator.ts
+var ROUTE_TEMPLATE_REGEX = /^\/[a-zA-Z0-9_/:.\-~%]+$/;
+function isValidRouteTemplate(value) {
+  if (!value) return false;
+  if (!ROUTE_TEMPLATE_REGEX.test(value)) return false;
+  let decoded;
+  try {
+    decoded = decodeURIComponent(value);
+  } catch {
+    return false;
+  }
+  if (decoded.includes("..")) return false;
+  if (decoded.includes("://")) return false;
+  return true;
+}
+function validateRouteTemplate(value) {
+  return isValidRouteTemplate(value) ? value : void 0;
+}
+var MAX_SERVICE_NAME_LEN = 32;
+var MAX_TAG_LEN = 32;
+var MAX_TAGS = 5;
+var MAX_ICON_URL_LEN = 2048;
+var CONTROL_CHAR_REGEX = /[\x00-\x1f\x7f]/;
+var PRINTABLE_ASCII_REGEX = /^[\x20-\x7e]+$/;
+var UNICODE_CONTROL_REGEX = /\p{Cc}/u;
+var LOOPBACK_HOSTNAMES = /* @__PURE__ */ new Set([
+  "localhost",
+  "localhost.localdomain",
+  "ip6-localhost",
+  "ip6-loopback"
+]);
+var IPV4_REGEX = /^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/;
+var ALL_DIGITS_REGEX = /^\d+$/;
+var HEX_LITERAL_REGEX = /^0x[0-9a-f]+$/i;
+function isValidServiceName(value) {
+  if (typeof value !== "string") return false;
+  if (value.length === 0 || value.length > MAX_SERVICE_NAME_LEN) return false;
+  if (UNICODE_CONTROL_REGEX.test(value)) return false;
+  if (!PRINTABLE_ASCII_REGEX.test(value)) return false;
+  return true;
+}
+function sanitizeTags(value) {
+  if (!Array.isArray(value)) return void 0;
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of value) {
+    if (typeof entry !== "string") continue;
+    if (entry.length === 0 || entry.length > MAX_TAG_LEN) continue;
+    if (UNICODE_CONTROL_REGEX.test(entry)) continue;
+    if (!PRINTABLE_ASCII_REGEX.test(entry)) continue;
+    const key = entry.toLowerCase();
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(entry);
+    if (out.length === MAX_TAGS) break;
+  }
+  return out.length > 0 ? out : void 0;
+}
+function isValidIconUrl(value) {
+  if (typeof value !== "string") return false;
+  if (value.length === 0 || value.length > MAX_ICON_URL_LEN) return false;
+  if (CONTROL_CHAR_REGEX.test(value)) return false;
+  let parsed;
+  try {
+    parsed = new URL(value);
+  } catch {
+    return false;
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return false;
+  if (parsed.username !== "" || parsed.password !== "") return false;
+  if (parsed.host.startsWith("[")) return false;
+  let hostname;
+  try {
+    hostname = decodeURIComponent(parsed.hostname);
+  } catch {
+    return false;
+  }
+  const asciiHost = domainToASCII(hostname);
+  if (asciiHost === "") return false;
+  hostname = asciiHost.toLowerCase();
+  if (hostname === "") return false;
+  if (LOOPBACK_HOSTNAMES.has(hostname)) return false;
+  if (IPV4_REGEX.test(hostname)) return false;
+  if (ALL_DIGITS_REGEX.test(hostname)) return false;
+  if (HEX_LITERAL_REGEX.test(hostname)) return false;
+  return true;
+}
+function sanitizeResourceServiceMetadata(resource) {
+  if (!resource) return {};
+  const out = {};
+  if (isValidServiceName(resource.serviceName)) {
+    out.serviceName = resource.serviceName;
+  }
+  const tags = sanitizeTags(resource.tags);
+  if (tags) {
+    out.tags = tags;
+  }
+  if (isValidIconUrl(resource.iconUrl)) {
+    out.iconUrl = resource.iconUrl;
+  }
+  return out;
+}
+function validateDiscoveryExtension(extension) {
+  try {
+    const ajv = new Ajv({ strict: false, allErrors: true });
+    const validate = ajv.compile(extension.schema);
+    const valid = validate(extension.info);
+    if (valid) {
+      return { valid: true };
+    }
+    const errors = validate.errors?.map((err) => {
+      const path = err.instancePath || "(root)";
+      return `${path}: ${err.message}`;
+    }) || ["Unknown validation error"];
+    return { valid: false, errors };
+  } catch (error) {
+    return {
+      valid: false,
+      errors: [
+        `Schema validation failed: ${error instanceof Error ? error.message : String(error)}`
+      ]
+    };
+  }
+}
+var VALID_QUERY_METHODS = /* @__PURE__ */ new Set(["GET", "HEAD", "DELETE"]);
+var VALID_BODY_METHODS = /* @__PURE__ */ new Set(["POST", "PUT", "PATCH"]);
+var VALID_METHODS = /* @__PURE__ */ new Set([...VALID_QUERY_METHODS, ...VALID_BODY_METHODS]);
+var VALID_BODY_TYPES = /* @__PURE__ */ new Set(["json", "form-data", "text"]);
+var VALID_MCP_TRANSPORTS = /* @__PURE__ */ new Set(["streamable-http", "sse"]);
+function validateDiscoveryExtensionSpec(extension) {
+  const errors = [];
+  const info = extension.info;
+  if (!info || typeof info !== "object") {
+    return { valid: false, errors: ["Missing or invalid 'info' field"] };
+  }
+  const input = info.input;
+  if (!input || typeof input !== "object") {
+    return { valid: false, errors: ["Missing or invalid 'info.input' field"] };
+  }
+  const inputObj = input;
+  const inputType = inputObj.type;
+  if (inputType !== "http" && inputType !== "mcp") {
+    errors.push(`info.input.type must be "http" or "mcp", got "${String(inputType)}"`);
+    return { valid: false, errors };
+  }
+  if (inputType === "http") {
+    const method = inputObj.method;
+    if (method !== void 0 && !VALID_METHODS.has(method)) {
+      errors.push(
+        `info.input.method must be one of ${[...VALID_METHODS].join(", ")}, got "${String(method)}"`
+      );
+    }
+    const bodyType = inputObj.bodyType;
+    if (bodyType !== void 0) {
+      if (!VALID_BODY_TYPES.has(bodyType)) {
+        errors.push(
+          `info.input.bodyType must be one of ${[...VALID_BODY_TYPES].join(", ")}, got "${String(bodyType)}"`
+        );
+      }
+      if (method !== void 0 && !VALID_BODY_METHODS.has(method)) {
+        errors.push(
+          `info.input.bodyType is set but method "${String(method)}" is not a body method (POST, PUT, PATCH)`
+        );
+      }
+    }
+  }
+  if (inputType === "mcp") {
+    if (typeof inputObj.toolName !== "string" || inputObj.toolName.length === 0) {
+      errors.push(
+        "info.input.toolName is required and must be a non-empty string for MCP extensions"
+      );
+    }
+    if (!inputObj.inputSchema || typeof inputObj.inputSchema !== "object") {
+      errors.push("info.input.inputSchema is required and must be an object for MCP extensions");
+    }
+    const transport = inputObj.transport;
+    if (transport !== void 0 && !VALID_MCP_TRANSPORTS.has(transport)) {
+      errors.push(
+        `info.input.transport must be one of ${[...VALID_MCP_TRANSPORTS].join(", ")}, got "${String(transport)}"`
+      );
+    }
+  }
+  return errors.length === 0 ? { valid: true } : { valid: false, errors };
+}
+function extractDiscoveryInfo(paymentPayload, paymentRequirements, validate = true) {
+  let discoveryInfo = null;
+  let resourceUrl;
+  let routeTemplate;
+  if (paymentPayload.x402Version === 2) {
+    resourceUrl = paymentPayload.resource?.url ?? "";
+    if (paymentPayload.extensions) {
+      const bazaarExtension = paymentPayload.extensions[BAZAAR.key];
+      if (bazaarExtension && typeof bazaarExtension === "object") {
+        try {
+          const rawExt = bazaarExtension;
+          const rawTemplate = typeof rawExt.routeTemplate === "string" ? rawExt.routeTemplate : void 0;
+          if (isValidRouteTemplate(rawTemplate)) {
+            routeTemplate = rawTemplate;
+          }
+          const extension = bazaarExtension;
+          if (validate) {
+            const result = validateDiscoveryExtension(extension);
+            if (!result.valid) {
+              console.warn(
+                `V2 discovery extension validation failed: ${result.errors?.join(", ")}`
+              );
+            } else {
+              discoveryInfo = extension.info;
+            }
+          } else {
+            discoveryInfo = extension.info;
+          }
+        } catch (error) {
+          console.warn(`V2 discovery extension extraction failed: ${error}`);
+        }
+      }
+    }
+  } else if (paymentPayload.x402Version === 1) {
+    const requirementsV1 = paymentRequirements;
+    resourceUrl = requirementsV1.resource;
+    discoveryInfo = extractDiscoveryInfoV1(requirementsV1);
+  } else {
+    return null;
+  }
+  if (!discoveryInfo) {
+    return null;
+  }
+  const url = new URL(resourceUrl);
+  const canonicalUrl = routeTemplate ? `${url.origin}${routeTemplate}` : `${url.origin}${url.pathname}`;
+  let description;
+  let mimeType;
+  let serviceMetadata = {};
+  if (paymentPayload.x402Version === 2) {
+    description = paymentPayload.resource?.description;
+    mimeType = paymentPayload.resource?.mimeType;
+    serviceMetadata = sanitizeResourceServiceMetadata(paymentPayload.resource);
+  } else if (paymentPayload.x402Version === 1) {
+    const requirementsV1 = paymentRequirements;
+    description = requirementsV1.description;
+    mimeType = requirementsV1.mimeType;
+  }
+  let extensions;
+  if (paymentPayload.x402Version === 2) {
+    extensions = paymentPayload.extensions;
+  } else if (paymentPayload.x402Version === 1) {
+    extensions = buildV1CatalogExtensions(paymentPayload.extensions, discoveryInfo);
+  }
+  const base = {
+    resourceUrl: canonicalUrl,
+    description,
+    mimeType,
+    ...serviceMetadata,
+    x402Version: paymentPayload.x402Version,
+    discoveryInfo,
+    extensions
+  };
+  if (discoveryInfo.input.type === "mcp") {
+    return { ...base, toolName: discoveryInfo.input.toolName };
+  }
+  return { ...base, routeTemplate, method: discoveryInfo.input.method };
+}
+function extractDiscoveryInfoFromExtension(extension, validate = true) {
+  if (validate) {
+    const result = validateDiscoveryExtension(extension);
+    if (!result.valid) {
+      throw new Error(
+        `Invalid discovery extension: ${result.errors?.join(", ") || "Unknown error"}`
+      );
+    }
+  }
+  return extension.info;
+}
+function validateAndExtract(extension) {
+  const result = validateDiscoveryExtension(extension);
+  if (result.valid) {
+    return {
+      valid: true,
+      info: extension.info
+    };
+  }
+  return {
+    valid: false,
+    errors: result.errors
+  };
+}
+
+// src/bazaar/startupValidation.ts
+import { checkIfBazaarNeeded } from "@bankofai/x402-core/server";
+var HTTP_VERB_RE = /^(GET|POST|PUT|PATCH|DELETE|HEAD)\b/i;
+function withSyntheticMethod(ext, pattern) {
+  const info = ext.info;
+  const input = info?.input;
+  if (!input || typeof input.method === "string" && input.method) {
+    return ext;
+  }
+  const verbMatch = pattern.match(HTTP_VERB_RE);
+  const method = verbMatch ? verbMatch[1].toUpperCase() : input.body !== void 0 || input.bodyType !== void 0 ? "POST" : "GET";
+  return { ...ext, info: { ...info, input: { ...input, method } } };
+}
+function validateBazaarRouteExtensions(routes) {
+  const entries = "accepts" in routes ? [["*", routes]] : Object.entries(routes);
+  for (const [pattern, config] of entries) {
+    const bazaarExt = config.extensions?.["bazaar"];
+    if (!bazaarExt) continue;
+    if (typeof bazaarExt === "object" && bazaarExt !== null && "info" in bazaarExt && "schema" in bazaarExt) {
+      const specResult = validateDiscoveryExtensionSpec(bazaarExt);
+      if (!specResult.valid) {
+        console.warn(
+          `x402: Route "${pattern}" has an invalid bazaar extension: ${specResult.errors?.join(", ")}`
+        );
+        continue;
+      }
+      const extForSchema = withSyntheticMethod(bazaarExt, pattern);
+      const schemaResult = validateDiscoveryExtension(
+        extForSchema
+      );
+      if (!schemaResult.valid) {
+        console.warn(
+          `x402: Route "${pattern}" has an invalid bazaar extension: ${schemaResult.errors?.join(", ")}`
+        );
+      }
+    } else {
+      console.warn(
+        `x402: Route "${pattern}" declares a bazaar extension but it is malformed (expected an object with "info" and "schema" fields)`
+      );
+    }
+  }
+}
+
+// src/bazaar/facilitatorClient.ts
+function withBazaar(client) {
+  const existingExtensions = client.extensions ?? {};
+  const extended = client;
+  extended.extensions = {
+    ...existingExtensions,
+    bazaar: {
+      async listResources(params) {
+        let headers = {
+          "Content-Type": "application/json"
+        };
+        const authHeaders = await client.createAuthHeaders("bazaar");
+        headers = { ...headers, ...authHeaders.headers };
+        const queryParams = new URLSearchParams();
+        if (params?.type !== void 0) {
+          queryParams.set("type", params.type);
+        }
+        if (params?.payTo !== void 0) {
+          queryParams.set("payTo", params.payTo);
+        }
+        if (params?.scheme !== void 0) {
+          queryParams.set("scheme", params.scheme);
+        }
+        if (params?.network !== void 0) {
+          queryParams.set("network", params.network);
+        }
+        if (params?.extensions !== void 0) {
+          queryParams.set("extensions", params.extensions);
+        }
+        if (params?.limit !== void 0) {
+          queryParams.set("limit", params.limit.toString());
+        }
+        if (params?.offset !== void 0) {
+          queryParams.set("offset", params.offset.toString());
+        }
+        const queryString = queryParams.toString();
+        const endpoint = `${client.url}/discovery/resources${queryString ? `?${queryString}` : ""}`;
+        const response = await fetch(endpoint, {
+          method: "GET",
+          headers
+        });
+        if (!response.ok) {
+          const errorText = await response.text().catch(() => response.statusText);
+          throw new Error(
+            `Facilitator listDiscoveryResources failed (${response.status}): ${errorText}`
+          );
+        }
+        return await response.json();
+      },
+      async search(params) {
+        let headers = {
+          "Content-Type": "application/json"
+        };
+        const authHeaders = await client.createAuthHeaders("bazaar");
+        headers = { ...headers, ...authHeaders.headers };
+        const queryParams = new URLSearchParams();
+        queryParams.set("query", params.query);
+        if (params.type !== void 0) {
+          queryParams.set("type", params.type);
+        }
+        if (params.payTo !== void 0) {
+          queryParams.set("payTo", params.payTo);
+        }
+        if (params.scheme !== void 0) {
+          queryParams.set("scheme", params.scheme);
+        }
+        if (params.network !== void 0) {
+          queryParams.set("network", params.network);
+        }
+        if (params.extensions !== void 0) {
+          queryParams.set("extensions", params.extensions);
+        }
+        if (params.limit !== void 0) {
+          queryParams.set("limit", params.limit.toString());
+        }
+        if (params.cursor !== void 0) {
+          queryParams.set("cursor", params.cursor);
+        }
+        const endpoint = `${client.url}/discovery/search?${queryParams.toString()}`;
+        const response = await fetch(endpoint, {
+          method: "GET",
+          headers
+        });
+        if (!response.ok) {
+          const errorText = await response.text().catch(() => response.statusText);
+          throw new Error(
+            `Facilitator searchDiscoveryResources failed (${response.status}): ${errorText}`
+          );
+        }
+        return await response.json();
+      }
+    }
+  };
+  return extended;
+}
+
+export {
+  isQueryExtensionConfig,
+  isBodyExtensionConfig,
+  isMcpExtensionConfig,
+  BAZAAR,
+  declareDiscoveryExtension,
+  bazaarResourceServerExtension,
+  extractDiscoveryInfoV1,
+  isDiscoverableV1,
+  extractResourceMetadataV1,
+  isValidRouteTemplate,
+  validateRouteTemplate,
+  isValidServiceName,
+  sanitizeTags,
+  isValidIconUrl,
+  sanitizeResourceServiceMetadata,
+  validateDiscoveryExtension,
+  validateDiscoveryExtensionSpec,
+  extractDiscoveryInfo,
+  extractDiscoveryInfoFromExtension,
+  validateAndExtract,
+  validateBazaarRouteExtensions,
+  checkIfBazaarNeeded,
+  withBazaar
+};
+//# sourceMappingURL=chunk-4IPDE3NS.mjs.map