agentcash 0.3.4 → 0.3.6

package/dist/esm/chunk-FM2E2QVT.js

@@ -0,0 +1,716 @@
+import {
+  MCP_VERSION
+} from "./chunk-DZC5MTYY.js";
+import {
+  err,
+  getBalance,
+  getBaseUrl,
+  getDepositLink,
+  log,
+  ok,
+  resultFromPromise,
+  resultFromThrowable,
+  safeFetch,
+  safeFetchJson,
+  safeParseResponse
+} from "./chunk-PJFATGPH.js";
+
+// src/shared/operations/check-endpoint.ts
+import { x402Client, x402HTTPClient } from "@x402/core/client";
+
+// src/shared/neverthrow/x402/index.ts
+import { createSIWxPayload } from "@x402/extensions/sign-in-with-x";
+var errorType = "x402";
+var x402Ok = (value) => ok(value);
+var x402Err = (cause, error) => err(errorType, cause, error);
+var x402ResultFromPromise = (surface, promise, error) => resultFromPromise(errorType, surface, promise, error);
+var x402ResultFromThrowable = (surface, fn, error) => resultFromThrowable(errorType, surface, fn, error);
+var safeGetPaymentRequired = (surface, client, response) => {
+  return x402ResultFromPromise(
+    surface,
+    response.json().then(
+      (json) => client.getPaymentRequiredResponse(
+        (name) => response.headers.get(name),
+        json
+      ),
+      () => client.getPaymentRequiredResponse((name) => response.headers.get(name))
+    ),
+    (error) => ({
+      cause: "parse_payment_required",
+      message: error instanceof Error ? error.message : "Failed to parse payment required"
+    })
+  );
+};
+var safeCreatePaymentPayload = (surface, client, paymentRequired) => {
+  return x402ResultFromPromise(
+    surface,
+    client.createPaymentPayload(paymentRequired),
+    (error) => ({
+      cause: "create_payment_payload",
+      message: error instanceof Error ? error.message : "Failed to create payment payload"
+    })
+  );
+};
+var safeGetPaymentSettlement = (surface, client, response) => {
+  return x402ResultFromThrowable(
+    surface,
+    () => client.getPaymentSettleResponse((name) => response.headers.get(name)),
+    (error) => ({
+      cause: "get_payment_settlement",
+      message: error instanceof Error ? error.message : "Failed to get payment settlement"
+    })
+  );
+};
+var safeCreateSIWxPayload = (surface, serverInfo, signer) => {
+  return x402ResultFromPromise(
+    surface,
+    createSIWxPayload(serverInfo, signer),
+    (error) => ({
+      cause: "create_siwx_payload",
+      message: error instanceof Error ? error.message : "Failed to create SIWX payload"
+    })
+  );
+};
+
+// src/shared/neverthrow/mpp/index.ts
+import { Challenge, Receipt } from "mpay";
+var errorType2 = "mpp";
+var mppOk = (value) => ok(value);
+var mppErr = (surface, error) => err(errorType2, surface, error);
+var mppResultFromPromise = (surface, promise, error) => resultFromPromise(errorType2, surface, promise, error);
+var mppResultFromThrowable = (surface, fn, error) => resultFromThrowable(errorType2, surface, fn, error);
+var safeGetMppChallenge = (surface, response) => {
+  return mppResultFromThrowable(
+    surface,
+    () => Challenge.fromResponse(response),
+    (error) => ({
+      cause: "parse_mpp_challenge",
+      message: error instanceof Error ? error.message : "Failed to parse MPP challenge from response"
+    })
+  );
+};
+var safeCreateMppCredential = (surface, mpayClient, response) => {
+  return mppResultFromPromise(
+    surface,
+    mpayClient.createCredential(response),
+    (error) => ({
+      cause: "create_mpp_credential",
+      message: error instanceof Error ? error.message : "Failed to create MPP credential"
+    })
+  );
+};
+var safeGetMppReceipt = (surface, response) => {
+  return mppResultFromThrowable(
+    surface,
+    () => Receipt.fromResponse(response),
+    (error) => ({
+      cause: "parse_mpp_receipt",
+      message: error instanceof Error ? error.message : "Failed to parse MPP receipt from response"
+    })
+  );
+};
+
+// src/shared/protocol.ts
+function detectPaymentProtocols(response) {
+  const protocols = [];
+  const wwwAuth = response.headers.get("WWW-Authenticate");
+  if (wwwAuth?.startsWith("Payment")) {
+    protocols.push("mpp");
+  }
+  const paymentRequired = response.headers.get("payment-required");
+  if (paymentRequired) {
+    protocols.push("x402");
+  }
+  if (protocols.length === 0) {
+    protocols.push("x402");
+  }
+  return protocols;
+}
+
+// src/shared/openapi-cache.ts
+var specCache = /* @__PURE__ */ new Map();
+async function fetchOpenApiSpec(origin) {
+  const cached = specCache.get(origin);
+  if (cached) return cached;
+  const uniqueUrls = [
+    `${origin}/openapi.json`,
+    `${origin}/.well-known/openapi.json`,
+    `${origin}/.well-known/x402`,
+    `${origin}/.well-known/mpp`
+  ];
+  for (const url of uniqueUrls) {
+    log.debug(`Fetching OpenAPI spec from: ${url}`);
+    const fetchResult = await safeFetch(
+      "fetchOpenApiSpec",
+      new Request(url, { headers: { Accept: "application/json" } })
+    );
+    if (fetchResult.isErr()) {
+      log.debug(`Failed to fetch OpenAPI spec from: ${url}`);
+      continue;
+    }
+    const response = fetchResult.value;
+    if (!response.ok) continue;
+    const jsonResult = await resultFromPromise(
+      "json",
+      "fetchOpenApiSpec",
+      response.json(),
+      () => ({
+        cause: "parse",
+        message: `Failed to parse JSON from: ${url}`
+      })
+    );
+    if (jsonResult.isErr()) {
+      log.debug(`Failed to fetch OpenAPI spec from: ${url}`);
+      continue;
+    }
+    const spec = jsonResult.value;
+    if (spec && typeof spec === "object" && spec.paths) {
+      specCache.set(origin, spec);
+      log.info(`Cached OpenAPI spec for origin: ${origin}`);
+      return spec;
+    }
+  }
+  log.debug(`No OpenAPI spec found for origin: ${origin}`);
+  return null;
+}
+function resolveRef(spec, ref, seen) {
+  if (!ref.startsWith("#/")) return void 0;
+  if (seen.has(ref)) return { $circular: ref };
+  seen.add(ref);
+  const parts = ref.slice(2).split("/");
+  let current = spec;
+  for (const part of parts) {
+    if (current == null || typeof current !== "object" || Array.isArray(current))
+      return void 0;
+    const next = current[part];
+    if (next === void 0) return void 0;
+    current = next;
+  }
+  if (current != null && typeof current === "object" && !Array.isArray(current)) {
+    return resolveRefs(spec, current, seen);
+  }
+  return current;
+}
+function resolveRefs(spec, obj, seen, depth = 0) {
+  if (depth > 4) return obj;
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (key === "$ref" && typeof value === "string") {
+      const resolved = resolveRef(spec, value, seen);
+      if (resolved != null && typeof resolved === "object" && !Array.isArray(resolved)) {
+        Object.assign(result, resolved);
+      } else {
+        result[key] = value;
+      }
+    } else if (value != null && typeof value === "object" && !Array.isArray(value)) {
+      result[key] = resolveRefs(spec, value, seen, depth + 1);
+    } else if (Array.isArray(value)) {
+      result[key] = value.map((item) => {
+        if (item != null && typeof item === "object" && !Array.isArray(item)) {
+          return resolveRefs(spec, item, seen, depth + 1);
+        }
+        return item;
+      });
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function extractPath(url, origin) {
+  if (url.startsWith(origin)) {
+    return url.slice(origin.length) || "/";
+  }
+  return URL.canParse(url) ? new URL(url).pathname : url;
+}
+async function getEndpointSchema(endpointUrl, method) {
+  if (!URL.canParse(endpointUrl)) return null;
+  const origin = new URL(endpointUrl).origin;
+  const spec = await fetchOpenApiSpec(origin);
+  if (!spec) return null;
+  const paths = spec.paths;
+  if (!paths) return null;
+  const path = extractPath(endpointUrl, origin);
+  const httpMethod = (method ?? "post").toLowerCase();
+  let pathEntry = paths[path];
+  if (!pathEntry) {
+    for (const [specPath, specEntry] of Object.entries(paths)) {
+      if (specEntry == null || typeof specEntry !== "object") continue;
+      const pattern = specPath.replace(/\{[^}]+\}/g, "[^/]+");
+      const regex = new RegExp(`^${pattern}$`);
+      if (regex.test(path)) {
+        pathEntry = specEntry;
+        break;
+      }
+    }
+  }
+  if (!pathEntry) {
+    log.debug(`No OpenAPI path entry found for: ${path}`);
+    return null;
+  }
+  const operation = pathEntry[httpMethod];
+  if (!operation) {
+    log.debug(`No OpenAPI operation found for ${httpMethod.toUpperCase()} ${path}`);
+    return null;
+  }
+  const resolved = resolveRefs(spec, operation, /* @__PURE__ */ new Set());
+  return { path, method: httpMethod, ...resolved };
+}
+var indexCache = /* @__PURE__ */ new Map();
+async function getOriginIndex(origin) {
+  const cached = indexCache.get(origin);
+  if (cached) return cached;
+  const spec = await fetchOpenApiSpec(origin);
+  if (!spec?.paths) return null;
+  const endpoints = [];
+  for (const [path, methods] of Object.entries(
+    spec.paths
+  )) {
+    for (const [method, operation] of Object.entries(methods)) {
+      if (typeof operation === "object" && operation !== null) {
+        const op = operation;
+        const paymentInfo = op["x-payment-info"];
+        const entry = {
+          path,
+          method: method.toUpperCase(),
+          summary: op.summary || op.description || ""
+        };
+        if (paymentInfo?.price != null) {
+          entry.price = `$${paymentInfo.price}`;
+        }
+        if (Array.isArray(paymentInfo?.protocols)) {
+          entry.protocols = paymentInfo.protocols;
+        }
+        endpoints.push(entry);
+      }
+    }
+  }
+  indexCache.set(origin, endpoints);
+  return endpoints;
+}
+var OPENAPI_HTTP_METHODS = /* @__PURE__ */ new Set([
+  "get",
+  "post",
+  "put",
+  "delete",
+  "patch",
+  "head",
+  "options",
+  "trace"
+]);
+async function getSpecMethods(endpointUrl) {
+  if (!URL.canParse(endpointUrl)) return null;
+  const origin = new URL(endpointUrl).origin;
+  const spec = await fetchOpenApiSpec(origin);
+  if (!spec?.paths) return null;
+  const paths = spec.paths;
+  const path = extractPath(endpointUrl, origin);
+  let pathEntry = paths[path];
+  if (!pathEntry) {
+    for (const [specPath, specEntry] of Object.entries(paths)) {
+      if (specEntry == null || typeof specEntry !== "object") continue;
+      const pattern = specPath.replace(/\{[^}]+\}/g, "[^/]+");
+      const regex = new RegExp(`^${pattern}$`);
+      if (regex.test(path)) {
+        pathEntry = specEntry;
+        break;
+      }
+    }
+  }
+  if (!pathEntry) return null;
+  return Object.keys(pathEntry).filter((k) => OPENAPI_HTTP_METHODS.has(k)).map((k) => k.toUpperCase());
+}
+function getIndexEntry(origin, path, method) {
+  const entries = indexCache.get(origin);
+  if (!entries) return void 0;
+  const m = method.toUpperCase();
+  return entries.find((e) => e.path === path && e.method === m);
+}
+
+// src/shared/token.ts
+import { formatUnits } from "viem";
+var tokenStringToNumber = (amount, decimals = 6) => {
+  return Number(formatUnits(BigInt(amount), decimals));
+};
+
+// src/server/lib/x402-extensions.ts
+var getBazaarExtension = (extensions) => {
+  const { bazaar } = extensions ?? {};
+  if (!bazaar) {
+    return void 0;
+  }
+  return bazaar;
+};
+var getInputSchema = (extensions) => getBazaarExtension(extensions)?.schema.properties.input;
+var getSiwxExtension = (extensions) => {
+  const siwx = extensions?.["sign-in-with-x"];
+  if (!siwx?.info) {
+    return void 0;
+  }
+  const chain = siwx.supportedChains?.find(
+    (c) => c.chainId.startsWith("eip155:")
+  );
+  return {
+    ...siwx.info,
+    chainId: chain?.chainId ?? "eip155:8453",
+    type: chain?.type ?? "eip191",
+    signatureScheme: chain?.signatureScheme
+  };
+};
+
+// src/shared/operations/check-endpoint.ts
+var SUPPORTED_METHODS = [
+  "GET",
+  "POST",
+  "PUT",
+  "DELETE",
+  "PATCH"
+];
+async function checkEndpoint({
+  surface,
+  url,
+  methods,
+  body,
+  headers = {},
+  includeMethodErrors = false,
+  probeAllMethods = false
+}) {
+  let methodsToCheck;
+  if (methods) {
+    methodsToCheck = methods;
+  } else if (probeAllMethods) {
+    methodsToCheck = [...SUPPORTED_METHODS];
+  } else {
+    const specMethods = await getSpecMethods(url);
+    if (specMethods?.length) {
+      methodsToCheck = specMethods.filter(
+        (m) => SUPPORTED_METHODS.includes(m)
+      );
+    } else {
+      methodsToCheck = [...SUPPORTED_METHODS];
+    }
+  }
+  log.info("Checking endpoint", { url, methods: methodsToCheck });
+  const results = await Promise.all(
+    methodsToCheck.map(
+      (method) => probeMethod({ surface, method, url, body, headers, includeMethodErrors })
+    )
+  );
+  return {
+    url,
+    results: results.filter((r) => r !== null)
+  };
+}
+async function probeMethod({
+  surface,
+  method,
+  url,
+  body,
+  headers,
+  includeMethodErrors
+}) {
+  const cachedSchemaResult = await resultFromPromise(
+    "openapi",
+    surface,
+    getEndpointSchema(url, method),
+    (e) => ({
+      cause: "cache_lookup",
+      message: e instanceof Error ? e.message : String(e)
+    })
+  );
+  if (cachedSchemaResult.isOk() && cachedSchemaResult.value) {
+    const cachedSchema = cachedSchemaResult.value;
+    const origin = new URL(url).origin;
+    const path = new URL(url).pathname || "/";
+    const indexEntry = getIndexEntry(origin, path, method);
+    return {
+      method,
+      source: "openapi",
+      requiresPayment: true,
+      schema: cachedSchema,
+      ...indexEntry?.price ? { estimatedPrice: indexEntry.price } : {},
+      ...indexEntry?.protocols ? { protocols: indexEntry.protocols } : {},
+      ...indexEntry?.summary ? { summary: indexEntry.summary } : {}
+    };
+  }
+  if (cachedSchemaResult.isErr()) {
+    log.debug(
+      `Cache lookup failed for ${method} ${url}, falling back to 402 probe`
+    );
+  }
+  const request = buildProbeRequest(url, method, body, headers);
+  const responseResult = await safeFetch(surface, request);
+  if (responseResult.isErr()) {
+    log.debug(`${method} ${url} probe failed`, responseResult.error);
+    return null;
+  }
+  const response = responseResult.value;
+  if (!response.ok && response.status !== 402) {
+    if (includeMethodErrors && (response.status === 404 || response.status === 405)) {
+      return {
+        method,
+        source: "probe",
+        requiresPayment: false,
+        statusCode: response.status
+      };
+    }
+    log.debug(`${method} ${url} returned ${response.status} \u2014 skipping`);
+    return null;
+  }
+  if (response.status !== 402) {
+    return {
+      method,
+      source: "probe",
+      requiresPayment: false,
+      statusCode: response.status
+    };
+  }
+  const protocols = detectPaymentProtocols(response);
+  const paymentMethods = [];
+  if (protocols.includes("mpp")) {
+    const challengeResult = safeGetMppChallenge(surface, response);
+    if (challengeResult.isOk()) {
+      const challenge = challengeResult.value;
+      const currency = challenge.request.currency;
+      const amount = challenge.request.amount;
+      const decimals = challenge.request.decimals ?? 6;
+      let schema;
+      const endpointSchemaResult = await resultFromPromise(
+        "openapi",
+        surface,
+        getEndpointSchema(url, method),
+        (e) => ({
+          cause: "schema_fetch",
+          message: e instanceof Error ? e.message : String(e)
+        })
+      );
+      if (endpointSchemaResult.isOk() && endpointSchemaResult.value) {
+        schema = endpointSchemaResult.value;
+      } else if (endpointSchemaResult.isErr()) {
+        log.debug(`Failed to fetch OpenAPI schema for: ${url}`);
+      }
+      paymentMethods.push({
+        protocol: "mpp",
+        method: challenge.method,
+        intent: challenge.intent,
+        realm: challenge.realm,
+        ...challenge.description ? { description: challenge.description } : {},
+        ...amount ? { price: tokenStringToNumber(amount, decimals) } : {},
+        ...currency ? { currency } : {},
+        ...schema ? { schema } : {},
+        network: `tempo:${challenge.method}`
+      });
+    }
+  }
+  if (protocols.includes("x402")) {
+    const client = new x402HTTPClient(new x402Client());
+    const paymentRequiredResult = await safeGetPaymentRequired(
+      surface,
+      client,
+      response
+    );
+    if (paymentRequiredResult.isOk()) {
+      const { resource, extensions, accepts } = paymentRequiredResult.value;
+      for (const accept of accepts) {
+        paymentMethods.push({
+          protocol: "x402",
+          ...resource,
+          schema: getInputSchema(extensions),
+          price: tokenStringToNumber(accept.amount),
+          network: accept.network,
+          asset: accept.asset
+        });
+      }
+    }
+  }
+  return {
+    method,
+    source: "probe",
+    requiresPayment: true,
+    statusCode: response.status,
+    protocols,
+    paymentMethods
+  };
+}
+function buildProbeRequest(url, method, body, headers) {
+  const supportsBody = ["POST", "PUT", "PATCH"].includes(method);
+  const requestBody = supportsBody && body ? typeof body === "string" ? body : JSON.stringify(body) : void 0;
+  return new Request(url, {
+    method,
+    body: requestBody,
+    headers: {
+      ...requestBody ? { "Content-Type": "application/json" } : {},
+      ...headers
+    }
+  });
+}
+
+// src/shared/operations/discover.ts
+async function fetchLlmsTxt(surface, origin) {
+  const llmsTxtUrl = `${origin}/llms.txt`;
+  log.debug(`Fetching llms.txt from: ${llmsTxtUrl}`);
+  const result = await safeFetch(
+    surface,
+    new Request(llmsTxtUrl, { headers: { Accept: "text/plain" } })
+  );
+  if (result.isErr()) return null;
+  const parseResult = await safeParseResponse(surface, result.value);
+  if (parseResult.isErr() || parseResult.value.type !== "text") return null;
+  return parseResult.value.data;
+}
+async function discoverResources(surface, url) {
+  const origin = URL.canParse(url) ? new URL(url).origin : url;
+  log.info(`Discovering resources for origin: ${origin}`);
+  const [spec, instructions] = await Promise.all([
+    fetchOpenApiSpec(origin),
+    fetchLlmsTxt(surface, origin)
+  ]);
+  if (!spec?.paths) {
+    log.debug(
+      `No OpenAPI spec found for ${origin}. Tried: /openapi.json, /.well-known/openapi.json, /.well-known/x402, /.well-known/mpp`
+    );
+    return null;
+  }
+  const endpoints = await getOriginIndex(origin);
+  if (!endpoints || endpoints.length === 0) {
+    log.debug(`OpenAPI spec found for ${origin} but no endpoints extracted`);
+    return null;
+  }
+  log.info(`Found ${endpoints.length} endpoints for: ${origin}`);
+  return {
+    origin,
+    source: "openapi",
+    endpoints: endpoints.map(({ path, method, summary, price, protocols }) => ({
+      path,
+      method,
+      summary,
+      ...price ? { price } : {},
+      ...protocols ? { protocols } : {}
+    })),
+    ...instructions ? { instructions } : {}
+  };
+}
+
+// src/shared/operations/wallet-info.ts
+import { formatUnits as formatUnits2 } from "viem";
+
+// src/shared/tempo.ts
+var TEMPO_RPC_URL = "https://eng:acard-melody-fashion-finish@rpc.mainnet.tempo.xyz";
+var TEMPO_TOKEN_ADDRESS = "0x20c0000000000000000000000000000000000000";
+
+// src/shared/tempo-balance.ts
+import { tempo } from "viem/chains";
+var MPPSCAN_BASE = "https://mppscan.com";
+async function getTempoBalance({
+  address,
+  tokenAddress
+}) {
+  const url = `${MPPSCAN_BASE}/api/balance/${address}`;
+  const res = await fetch(url, {
+    method: "GET",
+    headers: { accept: "application/json" }
+  });
+  if (!res.ok) {
+    throw new Error(`mppscan balance request failed: ${res.status}`);
+  }
+  const data = await res.json();
+  return {
+    chainId: tempo.id,
+    chainName: tempo.name,
+    balance: BigInt(data.balance),
+    tokenAddress
+  };
+}
+
+// src/shared/operations/wallet-info.ts
+async function getWalletInfo(surface, address, flags) {
+  const [balanceResult, tempoResult] = await Promise.all([
+    getBalance({ address, flags, surface }),
+    getTempoBalance({ address, tokenAddress: TEMPO_TOKEN_ADDRESS }).then((r) => Number(formatUnits2(r.balance, 6))).catch((e) => {
+      log.info(`Failed to fetch Tempo balance: ${e}`);
+      return null;
+    })
+  ]);
+  if (balanceResult.isErr()) {
+    return balanceResult;
+  }
+  const baseBalance = balanceResult.value.balance;
+  const tempoBalance = tempoResult ?? 0;
+  const totalBalance = baseBalance + tempoBalance;
+  const chains = [
+    { chain: "Base", balance: baseBalance },
+    { chain: "Tempo", balance: tempoBalance }
+  ];
+  return ok({
+    address,
+    balance: totalBalance,
+    chains,
+    isNewWallet: totalBalance === 0,
+    depositLink: getDepositLink(address, flags),
+    ...totalBalance < 2.5 && totalBalance > 0 ? { message: "Your balance is low. Consider topping it up" } : {}
+  });
+}
+
+// src/shared/operations/report-error.ts
+import { z } from "zod";
+async function submitErrorReport(surface, input, address, dev) {
+  const telemetryResult = await safeFetchJson(
+    surface,
+    new Request(`${getBaseUrl(dev)}/api/telemetry`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        tool: input.tool,
+        summary: input.summary,
+        errorMessage: input.errorMessage,
+        resource: input.resource,
+        stack: input.stack,
+        fullReport: input.fullReport,
+        walletAddress: address,
+        mcpVersion: MCP_VERSION,
+        reportedAt: (/* @__PURE__ */ new Date()).toISOString()
+      })
+    }),
+    z.object({
+      reportId: z.string()
+    })
+  );
+  if (telemetryResult.isErr()) {
+    return telemetryResult;
+  }
+  const { reportId } = telemetryResult.value;
+  return ok({
+    submitted: true,
+    reportId,
+    message: "Error report submitted successfully. The agentcash team will investigate."
+  });
+}
+
+export {
+  TEMPO_RPC_URL,
+  x402Ok,
+  x402Err,
+  safeGetPaymentRequired,
+  safeCreatePaymentPayload,
+  safeGetPaymentSettlement,
+  safeCreateSIWxPayload,
+  mppOk,
+  mppErr,
+  safeGetMppChallenge,
+  safeCreateMppCredential,
+  safeGetMppReceipt,
+  detectPaymentProtocols,
+  tokenStringToNumber,
+  getTempoBalance,
+  getOriginIndex,
+  getInputSchema,
+  getSiwxExtension,
+  SUPPORTED_METHODS,
+  checkEndpoint,
+  discoverResources,
+  getWalletInfo,
+  submitErrorReport
+};
+//# sourceMappingURL=chunk-FM2E2QVT.js.map