@agentwonderland/mcp 0.1.37 → 0.1.39

package/dist/tools/providers.js

@@ -0,0 +1,40 @@
+import { z } from "zod";
+import { apiGet } from "../core/api-client.js";
+import { agentLine } from "../core/formatters.js";
+function text(t) {
+    return { content: [{ type: "text", text: t }] };
+}
+export function registerProviderTools(server) {
+    server.tool("search_providers", "Search API providers listed on Agent Wonderland.", {
+        query: z.string().optional().describe("Provider name or keyword"),
+        limit: z.number().int().min(1).max(25).default(10),
+    }, async ({ query, limit }) => {
+        const params = new URLSearchParams();
+        if (query)
+            params.set("q", query);
+        params.set("limit", String(limit));
+        const providers = await apiGet(`/providers?${params}`);
+        if (providers.length === 0)
+            return text(query ? `No providers found matching "${query}".` : "No providers found.");
+        return text([
+            `Found ${providers.length} provider${providers.length === 1 ? "" : "s"}:`,
+            "",
+            ...providers.map((provider) => `  ${provider.name} (${provider.slug}) • ${provider.stats?.live_endpoints ?? 0} endpoints`),
+        ].join("\n"));
+    });
+    server.tool("get_provider", "Get an API provider profile and its live payable endpoints.", {
+        provider: z.string().describe("Provider slug"),
+        limit: z.number().int().min(1).max(100).default(50),
+    }, async ({ provider, limit }) => {
+        const profile = await apiGet(`/providers/${provider}`);
+        const agents = await apiGet(`/providers/${provider}/agents?limit=${limit}`);
+        return text([
+            `${profile.name} (${profile.slug})`,
+            profile.description ?? "",
+            ...(profile.website_url ? [`Website: ${profile.website_url}`] : []),
+            `Live endpoints: ${profile.stats?.live_endpoints ?? agents.length}`,
+            "",
+            ...agents.map((agent) => `  ${agentLine(agent)}`),
+        ].filter(Boolean).join("\n"));
+    });
+}

package/dist/tools/run.js

@@ -87,7 +87,7 @@ function buildCreditPackOfferLines(agent) {
 export function registerRunTools(server) {
     server.tool("run_agent", "Run an AI agent from the marketplace. Pays automatically via configured wallet. Returns the agent's output, cost, and job ID for tracking. If spending confirmation is enabled, first call returns a price quote — call again with confirmed: true to execute. Local file paths in the input (e.g. /Users/.../photo.jpg) are automatically uploaded to temporary storage and replaced with download URLs before execution. If a file you need isn't on this MCP server's filesystem (e.g. a sandboxed /mnt/... attachment), call upload_file first to get a presigned upload URL, PUT the bytes to it, then pass the returned GET URL as input instead — that keeps the bytes out of the conversation context.", {
         agent_id: z.string().describe("Agent ID (UUID, slug, or name)"),
-        input: z.record(z.unknown()).describe("Input payload for the agent"),
+        input: z.record(z.string(), z.unknown()).describe("Input payload for the agent"),
         pay_with: z.string().trim().min(1).optional().describe("Payment method — wallet ID, chain name (tempo, base, etc.), or 'card'. Auto-detected if omitted."),
         confirmed: z.boolean().optional().describe("Set to true to confirm spending after seeing the price quote."),
     }, async ({ agent_id, input, pay_with, confirmed }) => {

package/dist/tools/search.js

@@ -9,17 +9,23 @@ function text(t) {
 export function registerSearchTools(server) {
     server.tool("search_agents", "Search the Agent Wonderland marketplace for AI agents. Returns a ranked list of matching agents with ratings, pricing, and job counts.", {
         query: z.string().optional().describe("Search query (natural language or keywords)"),
+        provider: z.string().optional().describe("Filter by API provider name or slug"),
+        provider_slug: z.string().optional().describe("Filter by exact API provider slug"),
         tag: z.string().optional().describe("Filter by tag (e.g. 'code', 'image', 'data')"),
         limit: z.number().optional().default(10).describe("Max results (1-50)"),
         max_price: z.number().optional().describe("Maximum price per request in USD"),
         min_rating: z.number().min(1).max(5).optional().describe("Minimum star rating (1-5)"),
         sort: z.enum(["relevance", "price", "rating", "popularity", "newest"]).optional()
             .describe("Sort results by: relevance (default), price, rating, popularity, or newest"),
-    }, async ({ query, tag, limit, max_price, min_rating, sort }) => {
+    }, async ({ query, provider, provider_slug, tag, limit, max_price, min_rating, sort }) => {
         const requestedLimit = Math.max(1, Math.min(50, limit ?? 10));
         const params = new URLSearchParams();
         if (query)
             params.set("q", query);
+        if (provider_slug)
+            params.set("provider_slug", provider_slug);
+        else if (provider)
+            params.set("provider", provider);
         if (tag)
             params.set("tag", tag);
         // min_rating is filtered client-side on avgRating. Request extra candidates

package/dist/tools/solve.js

@@ -110,7 +110,7 @@ export function registerSolveTools(server) {
             .string()
             .describe("What you want to accomplish (natural language)"),
         input: z
-            .record(z.unknown())
+            .record(z.string(), z.unknown())
             .optional()
             .default({})
             .describe("Input payload for the agent"),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentwonderland/mcp",
-  "version": "0.1.37",
+  "version": "0.1.39",
   "type": "module",
   "description": "MCP server for the Agent Wonderland AI agent marketplace",
   "bin": {
@@ -24,11 +24,10 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.12.1",
     "@solana/spl-token": "^0.4.14",
-    "@solana/web3.js": "^1.98.4",
-    "mppx": "^0.5.10",
+    "@solana/web3.js": "1.95.8",
     "qrcode": "^1.5.4",
     "viem": "^2.47.6",
-    "zod": "^3.24.0"
+    "zod": "^4.3.6"
   },
   "optionalDependencies": {
     "@open-wallet-standard/core": "^1.0.0"

package/src/core/__tests__/api-client.test.ts

@@ -71,6 +71,10 @@ describe("api-client headers", () => {
             "did:pkh:solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp:42W2HfLfveSm1T5et9WTLp2CZ2QXdF2EYCUvyJ2gPpxF",
           "X-AW-Rebate-Principal":
             "did:pkh:eip155:8453:0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
+          "X-AW-Surface": "mcp",
+          "X-AW-MCP-Version": "0.1.37",
+          "X-AW-MCP-Tool": "run_agent",
+          "X-AW-MCP-Action": "execute",
         }),
       }),
     );

package/src/core/__tests__/mpp-client.test.ts

@@ -0,0 +1,53 @@
+import { describe, expect, it, vi } from "vitest";
+import { Credential, Method, Mppx, z } from "../mpp-client.js";
+
+describe("local MPP client", () => {
+  it("handles a 402 challenge and retries with a payment credential", async () => {
+    const challengeRequest = Buffer.from(JSON.stringify({
+      amount: "1000000",
+      currency: "USDC",
+      recipient: "0x0000000000000000000000000000000000000001",
+    })).toString("base64url");
+    const fetchMock = vi
+      .fn<typeof fetch>()
+      .mockResolvedValueOnce(new Response("payment required", {
+        status: 402,
+        headers: {
+          "WWW-Authenticate": `Payment id="test-id", realm="api.test", method="base", intent="charge", request="${challengeRequest}"`,
+        },
+      }))
+      .mockResolvedValueOnce(new Response("ok", { status: 200 }));
+
+    const method = Method.toClient(
+      Method.from({
+        name: "base",
+        intent: "charge",
+        schema: {
+          credential: { payload: z.object({ type: z.literal("hash"), hash: z.string() }) },
+          request: z.object({ amount: z.string() }),
+        },
+      }),
+      {
+        createCredential({ challenge }) {
+          return Credential.serialize({
+            challenge,
+            payload: { type: "hash", hash: "0xabc" },
+            source: "did:pkh:eip155:8453:0x0000000000000000000000000000000000000002",
+          });
+        },
+      },
+    );
+
+    const client = Mppx.create({ fetch: fetchMock, methods: [method], polyfill: false });
+    const response = await client.fetch("https://api.test/agents/example/run", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: "{}",
+    });
+
+    expect(response.status).toBe(200);
+    expect(fetchMock).toHaveBeenCalledTimes(2);
+    const retryInit = fetchMock.mock.calls[1]?.[1];
+    expect(new Headers(retryInit?.headers).get("Authorization")).toMatch(/^Payment\s+/);
+  });
+});

package/src/core/__tests__/payments.test.ts

@@ -28,7 +28,7 @@ vi.mock("../config.js", () => ({
   resolveWalletAndChain: () => currentResolvedMethod,
 }));
 
-vi.mock("mppx/client", () => ({
+vi.mock("../mpp-client.js", () => ({
   Mppx: {
     create: (config: unknown) => mockMppxCreate(config),
   },
@@ -63,28 +63,14 @@ describe("payment method initialization", () => {
       .mockReturnValueOnce({ fetch: createdFetches[3] });
   });
 
-  it("rebuilds the cached card fetch when the card config changes", async () => {
+  it("rejects explicit card payment while card payments are launch-gated", async () => {
     const { getPaymentFetch } = await import("../payments.js");
 
-    const firstFetch = await getPaymentFetch("card");
-    currentCard = {
-      consumerToken: "consumer_two",
-      paymentMethodId: "pm_two",
-      last4: "2222",
-      brand: "mastercard",
-    };
-    const secondFetch = await getPaymentFetch("card");
-
-    expect(firstFetch).not.toBe(secondFetch);
-    expect(mockMppxCreate).toHaveBeenCalledTimes(2);
-    expect(mockMppxCreate).toHaveBeenNthCalledWith(
-      1,
-      expect.objectContaining({ polyfill: false }),
-    );
-    expect(mockMppxCreate).toHaveBeenNthCalledWith(
-      2,
-      expect.objectContaining({ polyfill: false }),
+    await expect(getPaymentFetch("card")).rejects.toThrow(
+      "Card payments are temporarily unavailable",
     );
+    expect(mockMppxCreate).not.toHaveBeenCalled();
+    expect(mockStripe).not.toHaveBeenCalled();
   });
 
   it("initializes only the Base method when base is requested", async () => {

package/src/core/api-client.ts

@@ -29,10 +29,34 @@ interface RequestOptions {
   extraHeaders?: Record<string, string>;
 }
 
-async function buildHeaders(options?: RequestOptions): Promise<Record<string, string>> {
+const MCP_VERSION = "0.1.37";
+
+function inferToolHeaders(path: string, method: string): Record<string, string> {
+  if (path === "/solve") {
+    return { "X-AW-MCP-Tool": "solve", "X-AW-MCP-Action": method === "POST" ? "execute" : "view" };
+  }
+  if (/^\/agents\/[^/]+\/run$/.test(path)) {
+    return { "X-AW-MCP-Tool": "run_agent", "X-AW-MCP-Action": method === "POST" ? "execute" : "view" };
+  }
+  if (path.startsWith("/agents?") || path === "/agents" || path === "/agents/search") {
+    return { "X-AW-MCP-Tool": "search_agents", "X-AW-MCP-Action": "search" };
+  }
+  if (/^\/agents\/[^/]+$/.test(path)) {
+    return { "X-AW-MCP-Tool": "get_agent", "X-AW-MCP-Action": "view" };
+  }
+  if (path.startsWith("/jobs")) {
+    return { "X-AW-MCP-Tool": "get_job", "X-AW-MCP-Action": "poll" };
+  }
+  return {};
+}
+
+async function buildHeaders(path: string, method: string, options?: RequestOptions): Promise<Record<string, string>> {
   const headers: Record<string, string> = {
     "Content-Type": "application/json",
     Accept: "application/json",
+    "X-AW-Surface": "mcp",
+    "X-AW-MCP-Version": MCP_VERSION,
+    ...inferToolHeaders(path, method),
   };
 
   const apiKey = getApiKey();
@@ -119,7 +143,7 @@ export async function apiGet<T>(path: string, options?: RequestOptions): Promise
   const url = `${getApiUrl()}${path}`;
   const response = await fetch(url, {
     method: "GET",
-    headers: await buildHeaders(options),
+    headers: await buildHeaders(path, "GET", options),
   });
   const result = await handleResponse<T>(response);
   return attachResponseMetadata(result, response);
@@ -129,7 +153,7 @@ export async function apiPost<T>(path: string, body: unknown, options?: RequestO
   const url = `${getApiUrl()}${path}`;
   const response = await fetch(url, {
     method: "POST",
-    headers: await buildHeaders(options),
+    headers: await buildHeaders(path, "POST", options),
     body: JSON.stringify(body),
   });
   const result = await handleResponse<T>(response);
@@ -151,7 +175,7 @@ export async function apiPostWithPayment<T>(
   const paymentFetch = await getPaymentFetch(payWith);
   const response = await paymentFetch(url, {
     method: "POST",
-    headers: await buildHeaders({
+    headers: await buildHeaders(path, "POST", {
       ensureConsumerPrincipal: true,
       principalMethod: payWith,
       ...options,
@@ -166,7 +190,7 @@ export async function apiPut<T>(path: string, body: unknown, options?: RequestOp
   const url = `${getApiUrl()}${path}`;
   const response = await fetch(url, {
     method: "PUT",
-    headers: await buildHeaders(options),
+    headers: await buildHeaders(path, "PUT", options),
     body: JSON.stringify(body),
   });
   const result = await handleResponse<T>(response);

package/src/core/base-charge.ts

@@ -4,7 +4,7 @@
  * Signs and sends a standard ERC-20 transfer on Base chain, then returns
  * the tx hash as a credential. Plugs into mppx's compose/dispatch system.
  */
-import { Method, Credential, z } from "mppx";
+import { Method, Credential, z } from "./mpp-client.js";
 import type { LocalAccount } from "viem/accounts";
 import { toAtomicAmount } from "./amount-utils.js";
 

package/src/core/formatters.ts

@@ -53,6 +53,7 @@ interface AgentLike {
   totalExecutions?: number;
   pricePerRunUsd?: string;
   stats?: { completedJobs?: number; avgRating?: number | null };
+  provider?: { name?: string; slug?: string } | null;
   [key: string]: unknown;
 }
 
@@ -62,10 +63,11 @@ export function agentLine(agent: AgentLike): string {
   const rating = agent.avgRating ?? agent.stats?.avgRating ?? null;
   const jobs = agent.stats?.completedJobs ?? agent.totalExecutions ?? 0;
   const price = formatPrice(agent.pricePerRunUsd);
+  const provider = agent.provider?.name ? ` by ${agent.provider.name}` : "";
   const reliability = agent.successRate != null && Number(agent.successRate) < 1
     ? ` • ${(Number(agent.successRate) * 100).toFixed(0)}% reliable`
     : "";
-  return `${name}${slug} ${stars(rating)} ${compactNumber(jobs)} jobs • ${price}${reliability}`;
+  return `${name}${slug}${provider} ${stars(rating)} ${compactNumber(jobs)} jobs • ${price}${reliability}`;
 }
 
 export function formatLastActive(lastActiveAt: string | null | undefined): string | null {

package/src/core/mpp-client.ts

@@ -0,0 +1,286 @@
+import * as z from "zod/mini";
+
+type Challenge = {
+  id: string;
+  realm: string;
+  method: string;
+  intent: string;
+  request: Record<string, unknown>;
+  description?: string;
+  digest?: string;
+  expires?: string;
+  opaque?: Record<string, string>;
+};
+
+type ClientMethod = {
+  name: string;
+  intent: string;
+  context?: { parse(value: unknown): unknown };
+  createCredential(args: { challenge: Challenge; context?: unknown }): Promise<string> | string;
+};
+
+type MethodDefinition = {
+  name: string;
+  intent: string;
+  schema?: unknown;
+};
+
+type CreateConfig = {
+  methods: ClientMethod[];
+  fetch?: typeof fetch;
+  polyfill?: boolean;
+};
+
+type CredentialInput = {
+  challenge: Challenge;
+  payload: unknown;
+  source?: string;
+};
+
+const PAYMENT_FETCH_WRAPPER = Symbol.for("agentwonderland.mpp.fetch.wrapper");
+
+export { z };
+
+export const Method = {
+  from<T extends MethodDefinition>(method: T): T {
+    return method;
+  },
+
+  toClient<T extends MethodDefinition>(
+    method: T,
+    options: {
+      context?: { parse(value: unknown): unknown };
+      createCredential(args: { challenge: Challenge; context?: unknown }): Promise<string> | string;
+    },
+  ): T & ClientMethod {
+    return {
+      ...method,
+      context: options.context,
+      createCredential: options.createCredential,
+    };
+  },
+};
+
+export const Credential = {
+  serialize(credential: CredentialInput): string {
+    const wire = {
+      challenge: {
+        ...credential.challenge,
+        request: serializePaymentRequest(credential.challenge.request),
+      },
+      payload: credential.payload,
+      ...(credential.source ? { source: credential.source } : {}),
+    };
+    return `Payment ${base64UrlEncode(JSON.stringify(wire))}`;
+  },
+};
+
+export const Mppx = {
+  create(config: CreateConfig): { fetch: typeof fetch; methods: ClientMethod[]; rawFetch: typeof fetch } {
+    const rawFetch = unwrapFetch(config.fetch ?? globalThis.fetch);
+    const methods = config.methods.flat();
+    const paymentFetch = createPaymentFetch(rawFetch, methods);
+
+    if (config.polyfill) {
+      globalThis.fetch = paymentFetch;
+    }
+
+    return {
+      fetch: paymentFetch,
+      methods,
+      rawFetch,
+    };
+  },
+};
+
+export function stripe(_parameters?: unknown): ClientMethod {
+  throw new Error("Stripe card payments are temporarily unavailable.");
+}
+
+function createPaymentFetch(baseFetch: typeof fetch, methods: ClientMethod[]): typeof fetch {
+  const wrapped = (async (input: Parameters<typeof fetch>[0], init?: Parameters<typeof fetch>[1]) => {
+    const response = await baseFetch(input, init);
+    if (response.status !== 402) {
+      return response;
+    }
+
+    const challenges = challengesFromResponse(response);
+    const method = methods.find((candidate) =>
+      challenges.some((challenge) => challenge.method === candidate.name && challenge.intent === candidate.intent),
+    );
+    const challenge = method
+      ? challenges.find((candidate) => candidate.method === method.name && candidate.intent === method.intent)
+      : undefined;
+
+    if (!method || !challenge) {
+      throw new Error(
+        `No method found for challenges: ${challenges.map((item) => `${item.method}.${item.intent}`).join(", ")}. ` +
+          `Available: ${methods.map((item) => `${item.name}.${item.intent}`).join(", ")}`,
+      );
+    }
+
+    const context = (init as RequestInit & { context?: unknown } | undefined)?.context;
+    const parsedContext = method.context && context !== undefined ? method.context.parse(context) : undefined;
+    const credential = await method.createCredential(
+      parsedContext !== undefined ? { challenge, context: parsedContext } : { challenge },
+    );
+
+    return baseFetch(input, {
+      ...init,
+      headers: withAuthorizationHeader(init?.headers, credential),
+    });
+  }) as typeof fetch & { [PAYMENT_FETCH_WRAPPER]?: typeof fetch };
+
+  wrapped[PAYMENT_FETCH_WRAPPER] = baseFetch;
+  return wrapped;
+}
+
+function challengesFromResponse(response: Response): Challenge[] {
+  const header = response.headers.get("WWW-Authenticate");
+  if (!header) {
+    throw new Error("Missing WWW-Authenticate header.");
+  }
+
+  const starts = Array.from(header.matchAll(/Payment\s+/gi), (match) => match.index).filter((index) => index !== undefined);
+  if (starts.length === 0) {
+    throw new Error("No Payment schemes found.");
+  }
+
+  return starts.map((start, index) => {
+    const end = index + 1 < starts.length ? starts[index + 1] : header.length;
+    return deserializeChallenge(header.slice(start, end).replace(/,\s*$/, ""));
+  });
+}
+
+function deserializeChallenge(value: string): Challenge {
+  const paramsStart = value.search(/\s/);
+  if (!/^Payment\s+/i.test(value) || paramsStart < 0) {
+    throw new Error("Missing Payment scheme.");
+  }
+
+  const params = parseAuthParams(value.slice(paramsStart + 1));
+  if (!params.request) {
+    throw new Error("Missing request parameter.");
+  }
+  if (!params.id || !params.realm || !params.method || !params.intent) {
+    throw new Error("Malformed payment challenge.");
+  }
+
+  return {
+    id: params.id,
+    realm: params.realm,
+    method: params.method,
+    intent: params.intent,
+    request: deserializePaymentRequest(params.request),
+    ...(params.description ? { description: params.description } : {}),
+    ...(params.digest ? { digest: params.digest } : {}),
+    ...(params.expires ? { expires: params.expires } : {}),
+    ...(params.opaque ? { opaque: deserializePaymentRequest(params.opaque) as Record<string, string> } : {}),
+  };
+}
+
+function parseAuthParams(input: string): Record<string, string> {
+  const result: Record<string, string> = {};
+  let index = 0;
+
+  while (index < input.length) {
+    while (index < input.length && /[\s,]/.test(input[index] ?? "")) index++;
+    if (index >= input.length) break;
+
+    const keyStart = index;
+    while (index < input.length && /[A-Za-z0-9_-]/.test(input[index] ?? "")) index++;
+    const key = input.slice(keyStart, index);
+    if (!key) throw new Error("Malformed auth-param.");
+
+    while (index < input.length && /\s/.test(input[index] ?? "")) index++;
+    if (input[index] !== "=") break;
+    index++;
+    while (index < input.length && /\s/.test(input[index] ?? "")) index++;
+
+    const [value, nextIndex] = readAuthParamValue(input, index);
+    result[key] = value;
+    index = nextIndex;
+  }
+
+  return result;
+}
+
+function readAuthParamValue(input: string, start: number): [string, number] {
+  if (input[start] !== "\"") {
+    let index = start;
+    while (index < input.length && input[index] !== ",") index++;
+    return [input.slice(start, index).trim(), index];
+  }
+
+  let index = start + 1;
+  let value = "";
+  let escaped = false;
+  while (index < input.length) {
+    const char = input[index];
+    index++;
+    if (escaped) {
+      value += char;
+      escaped = false;
+      continue;
+    }
+    if (char === "\\") {
+      escaped = true;
+      continue;
+    }
+    if (char === "\"") {
+      return [value, index];
+    }
+    value += char;
+  }
+  throw new Error("Unterminated quoted-string.");
+}
+
+function withAuthorizationHeader(headers: HeadersInit | undefined, credential: string): HeadersInit {
+  const next = new Headers(headers);
+  next.set("Authorization", credential);
+  return next;
+}
+
+function unwrapFetch(candidate: typeof fetch): typeof fetch {
+  let current = candidate as typeof fetch & { [PAYMENT_FETCH_WRAPPER]?: typeof fetch };
+  while (current[PAYMENT_FETCH_WRAPPER]) {
+    current = current[PAYMENT_FETCH_WRAPPER] as typeof fetch & { [PAYMENT_FETCH_WRAPPER]?: typeof fetch };
+  }
+  return current;
+}
+
+function deserializePaymentRequest(encoded: string): Record<string, unknown> {
+  return JSON.parse(base64UrlDecode(encoded)) as Record<string, unknown>;
+}
+
+function serializePaymentRequest(request: Record<string, unknown>): string {
+  return base64UrlEncode(stableStringify(request));
+}
+
+function stableStringify(value: unknown): string {
+  if (value === null || typeof value !== "object") {
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => stableStringify(item)).join(",")}]`;
+  }
+
+  const record = value as Record<string, unknown>;
+  return `{${Object.keys(record)
+    .sort()
+    .map((key) => `${JSON.stringify(key)}:${stableStringify(record[key])}`)
+    .join(",")}}`;
+}
+
+function base64UrlEncode(value: string): string {
+  return Buffer.from(value, "utf8")
+    .toString("base64")
+    .replace(/=/g, "")
+    .replace(/\+/g, "-")
+    .replace(/\//g, "_");
+}
+
+function base64UrlDecode(value: string): string {
+  const padded = value.replace(/-/g, "+").replace(/_/g, "/").padEnd(Math.ceil(value.length / 4) * 4, "=");
+  return Buffer.from(padded, "base64").toString("utf8");
+}

package/src/core/payments.ts

@@ -77,7 +77,7 @@ async function initEvmMppForChain(
   chain: "tempo" | "base",
 ): Promise<typeof fetch | null> {
   try {
-    const { Mppx } = await import("mppx/client");
+    const { Mppx } = await import("./mpp-client.js");
     let account;
 
     if (wallet.keyType === "ows" && wallet.owsWalletId) {
@@ -112,7 +112,7 @@ async function initSolanaMpp(wallet: WalletEntry): Promise<typeof fetch | null>
       return null;
     }
 
-    const { Mppx } = await import("mppx/client");
+    const { Mppx } = await import("./mpp-client.js");
     const { solanaChargeClient } = await import("./solana-charge.js");
     const mppx = Mppx.create({
       methods: [solanaChargeClient({ wallet })] as any,
@@ -129,7 +129,7 @@ async function initCard(): Promise<typeof fetch | null> {
   if (!cardConfig) return null;
 
   try {
-    const { Mppx, stripe } = await import("mppx/client");
+    const { Mppx, stripe } = await import("./mpp-client.js");
     const apiUrl = getApiUrl();
     const pmId = cardConfig.paymentMethodId ?? undefined;
     const mppx = Mppx.create({