@agentwonderland/mcp 0.1.37 → 0.1.39

package/dist/core/__tests__/api-client.test.js

@@ -45,6 +45,10 @@ describe("api-client headers", () => {
                 Accept: "application/json",
                 "X-AW-Consumer-Principal": "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/dist/core/__tests__/mpp-client.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/__tests__/mpp-client.test.js

@@ -0,0 +1,46 @@
+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()
+            .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/dist/core/__tests__/payments.test.js

@@ -22,7 +22,7 @@ vi.mock("../config.js", () => ({
     getWallets: () => currentWallets,
     resolveWalletAndChain: () => currentResolvedMethod,
 }));
-vi.mock("mppx/client", () => ({
+vi.mock("../mpp-client.js", () => ({
     Mppx: {
         create: (config) => mockMppxCreate(config),
     },
@@ -53,20 +53,11 @@ describe("payment method initialization", () => {
             .mockReturnValueOnce({ fetch: createdFetches[2] })
             .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 () => {
         const wallet = {

package/dist/core/api-client.js

@@ -12,10 +12,32 @@ export class ApiError extends Error {
         this.name = "ApiError";
     }
 }
-async function buildHeaders(options) {
+const MCP_VERSION = "0.1.37";
+function inferToolHeaders(path, method) {
+    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, method, options) {
     const headers = {
         "Content-Type": "application/json",
         Accept: "application/json",
+        "X-AW-Surface": "mcp",
+        "X-AW-MCP-Version": MCP_VERSION,
+        ...inferToolHeaders(path, method),
     };
     const apiKey = getApiKey();
     if (apiKey) {
@@ -86,7 +108,7 @@ export async function apiGet(path, options) {
     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(response);
     return attachResponseMetadata(result, response);
@@ -95,7 +117,7 @@ export async function apiPost(path, body, options) {
     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(response);
@@ -111,7 +133,7 @@ export async function apiPostWithPayment(path, body, payWith, options) {
     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,
@@ -125,7 +147,7 @@ export async function apiPut(path, body, options) {
     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(response);

package/dist/core/base-charge.js

@@ -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 { toAtomicAmount } from "./amount-utils.js";
 // Base USDC (Circle native)
 const BASE_USDC = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";

package/dist/core/formatters.d.ts

@@ -24,6 +24,10 @@ interface AgentLike {
         completedJobs?: number;
         avgRating?: number | null;
     };
+    provider?: {
+        name?: string;
+        slug?: string;
+    } | null;
     [key: string]: unknown;
 }
 export declare function agentLine(agent: AgentLike): string;

package/dist/core/formatters.js

@@ -44,10 +44,11 @@ export function agentLine(agent) {
     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) {
     if (!lastActiveAt)

package/dist/core/mpp-client.d.ts

@@ -0,0 +1,62 @@
+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;
+};
+export { z };
+export declare const Method: {
+    from<T extends MethodDefinition>(method: T): T;
+    toClient<T extends MethodDefinition>(method: T, options: {
+        context?: {
+            parse(value: unknown): unknown;
+        };
+        createCredential(args: {
+            challenge: Challenge;
+            context?: unknown;
+        }): Promise<string> | string;
+    }): T & ClientMethod;
+};
+export declare const Credential: {
+    serialize(credential: CredentialInput): string;
+};
+export declare const Mppx: {
+    create(config: CreateConfig): {
+        fetch: typeof fetch;
+        methods: ClientMethod[];
+        rawFetch: typeof fetch;
+    };
+};
+export declare function stripe(_parameters?: unknown): ClientMethod;

package/dist/core/mpp-client.js

@@ -0,0 +1,208 @@
+import * as z from "zod/mini";
+const PAYMENT_FETCH_WRAPPER = Symbol.for("agentwonderland.mpp.fetch.wrapper");
+export { z };
+export const Method = {
+    from(method) {
+        return method;
+    },
+    toClient(method, options) {
+        return {
+            ...method,
+            context: options.context,
+            createCredential: options.createCredential,
+        };
+    },
+};
+export const Credential = {
+    serialize(credential) {
+        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) {
+        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) {
+    throw new Error("Stripe card payments are temporarily unavailable.");
+}
+function createPaymentFetch(baseFetch, methods) {
+    const wrapped = (async (input, init) => {
+        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?.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),
+        });
+    });
+    wrapped[PAYMENT_FETCH_WRAPPER] = baseFetch;
+    return wrapped;
+}
+function challengesFromResponse(response) {
+    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) {
+    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) } : {}),
+    };
+}
+function parseAuthParams(input) {
+    const result = {};
+    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, start) {
+    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, credential) {
+    const next = new Headers(headers);
+    next.set("Authorization", credential);
+    return next;
+}
+function unwrapFetch(candidate) {
+    let current = candidate;
+    while (current[PAYMENT_FETCH_WRAPPER]) {
+        current = current[PAYMENT_FETCH_WRAPPER];
+    }
+    return current;
+}
+function deserializePaymentRequest(encoded) {
+    return JSON.parse(base64UrlDecode(encoded));
+}
+function serializePaymentRequest(request) {
+    return base64UrlEncode(stableStringify(request));
+}
+function stableStringify(value) {
+    if (value === null || typeof value !== "object") {
+        return JSON.stringify(value);
+    }
+    if (Array.isArray(value)) {
+        return `[${value.map((item) => stableStringify(item)).join(",")}]`;
+    }
+    const record = value;
+    return `{${Object.keys(record)
+        .sort()
+        .map((key) => `${JSON.stringify(key)}:${stableStringify(record[key])}`)
+        .join(",")}}`;
+}
+function base64UrlEncode(value) {
+    return Buffer.from(value, "utf8")
+        .toString("base64")
+        .replace(/=/g, "")
+        .replace(/\+/g, "-")
+        .replace(/\//g, "_");
+}
+function base64UrlDecode(value) {
+    const padded = value.replace(/-/g, "+").replace(/_/g, "/").padEnd(Math.ceil(value.length / 4) * 4, "=");
+    return Buffer.from(padded, "base64").toString("utf8");
+}

package/dist/core/payments.js

@@ -54,7 +54,7 @@ function clearStaleCardCache(activeKey) {
 // ── Per-protocol initializers ───────────────────────────────────
 async function initEvmMppForChain(wallet, chain) {
     try {
-        const { Mppx } = await import("mppx/client");
+        const { Mppx } = await import("./mpp-client.js");
         let account;
         if (wallet.keyType === "ows" && wallet.owsWalletId) {
             const { owsAccountFromWalletId } = await import("./ows-adapter.js");
@@ -88,7 +88,7 @@ async function initSolanaMpp(wallet) {
         if (wallet.keyType !== "ows" && !wallet.key) {
             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 })],
@@ -105,7 +105,7 @@ async function initCard() {
     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({

package/dist/core/solana-charge.d.ts

@@ -2,6 +2,7 @@ import { Connection, PublicKey } from "@solana/web3.js";
 import type { WalletEntry } from "./config.js";
 export declare const SOLANA_USDC_MINT: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v";
 export declare const SOLANA_CHAIN_ID: "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp";
+export declare const SOLANA_CHAIN_ID_DEVNET: "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1wcaWoxPkrZBG";
 interface SolanaChargeClientConfig {
     wallet: WalletEntry;
     rpcUrl?: string;

package/dist/core/solana-charge.js

@@ -4,13 +4,15 @@
  * Sends an SPL Token transfer on Solana mainnet and returns the transaction
  * signature as the payment credential.
  */
-import { Credential, Method, z } from "mppx";
+import { Credential, Method, z } from "./mpp-client.js";
 import { Connection, Keypair, PublicKey, Transaction, sendAndConfirmTransaction } from "@solana/web3.js";
 import { ASSOCIATED_TOKEN_PROGRAM_ID, TOKEN_PROGRAM_ID, createAssociatedTokenAccountInstruction, createTransferCheckedInstruction, getAssociatedTokenAddressSync, } from "@solana/spl-token";
 import { toAtomicAmount } from "./amount-utils.js";
 export const SOLANA_USDC_MINT = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v";
 export const SOLANA_CHAIN_ID = "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp";
+export const SOLANA_CHAIN_ID_DEVNET = "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1wcaWoxPkrZBG";
 const SOLANA_RPC = "https://api.mainnet-beta.solana.com";
+const SOLANA_RPC_DEVNET = "https://api.devnet.solana.com";
 const solanaChargeMethod = Method.from({
     name: "solana",
     intent: "charge",
@@ -83,13 +85,15 @@ export function solanaChargeClient(config) {
     return Method.toClient(solanaChargeMethod, {
         async createCredential({ challenge }) {
             const { request } = challenge;
+            const chainId = request.chainId ?? request.methodDetails?.chainId ?? SOLANA_CHAIN_ID;
+            const rpcUrl = config.rpcUrl ?? (chainId === SOLANA_CHAIN_ID_DEVNET ? SOLANA_RPC_DEVNET : SOLANA_RPC);
             const amount = toAtomicAmount(request.amount, request.decimals ?? 6);
             const decimals = request.decimals ?? 6;
             const mint = new PublicKey(request.currency ?? SOLANA_USDC_MINT);
             const recipient = new PublicKey(request.recipient);
             const keypair = await getKeypair(config.wallet);
             const owner = keypair.publicKey;
-            const connection = new Connection(config.rpcUrl ?? SOLANA_RPC, "confirmed");
+            const connection = new Connection(rpcUrl, "confirmed");
             const sourceTokenAccount = getAssociatedTokenAddressSync(mint, owner, false, TOKEN_PROGRAM_ID, ASSOCIATED_TOKEN_PROGRAM_ID);
             const destination = await resolveRecipientTokenAccount(connection, mint, recipient);
             const instructions = [];
@@ -111,7 +115,7 @@ export function solanaChargeClient(config) {
             return Credential.serialize({
                 challenge,
                 payload: { signature, type: "signature" },
-                source: `did:pkh:${SOLANA_CHAIN_ID}:${owner.toBase58()}`,
+                source: `did:pkh:${chainId}:${owner.toBase58()}`,
             });
         },
     });

package/dist/core/tempo-charge.js

@@ -4,7 +4,7 @@
  * Sends a standard ERC-20 transfer on Tempo and returns the tx hash as the
  * payment credential.
  */
-import { Method, Credential, z } from "mppx";
+import { Method, Credential, z } from "./mpp-client.js";
 import { toAtomicAmount } from "./amount-utils.js";
 const TEMPO_USDC = "0x20c000000000000000000000b9537d11c60e8b50";
 const PATH_USD = "0x20c0000000000000000000000000000000000000";

package/dist/core/types.d.ts

@@ -18,6 +18,19 @@ export interface AgentRecord {
         ratingCount?: number;
         [key: string]: unknown;
     };
+    provider?: {
+        id?: string;
+        name?: string;
+        slug?: string;
+        website_url?: string | null;
+    } | null;
+    urls?: {
+        public_url?: string;
+        normalized_x402_url?: string;
+        mirrored_x402_url?: string | null;
+        agent_card_url?: string;
+        provider_url?: string | null;
+    };
     payment?: {
         pricing?: Record<string, unknown>;
         accepted_payments?: string[];

package/dist/index.js

@@ -14,6 +14,7 @@ import { registerTipTools } from "./tools/tip.js";
 import { registerPassTools } from "./tools/passes.js";
 import { registerUploadTools } from "./tools/upload.js";
 import { registerProbeTools } from "./tools/probe.js";
+import { registerProviderTools } from "./tools/providers.js";
 // ── Resources ────────────────────────────────────────────────────
 import { registerAgentResources } from "./resources/agents.js";
 import { registerWalletResources } from "./resources/wallet.js";
@@ -77,6 +78,7 @@ export async function startMcpServer() {
     registerPassTools(server);
     registerUploadTools(server);
     registerProbeTools(server);
+    registerProviderTools(server);
     // Register resources
     registerAgentResources(server);
     registerWalletResources(server);

package/dist/tools/__tests__/wallet.test.js

@@ -56,6 +56,7 @@ vi.mock("../../core/config.js", () => ({
 }));
 vi.mock("../../core/payments.js", () => ({
     getWalletAddress: async () => null,
+    isCardPaymentEnabled: () => true,
 }));
 vi.mock("../../core/card-setup.js", () => ({
     formatCardSetupBlocks: () => state.cardSetupBlocks,

package/dist/tools/agent-info.js

@@ -15,6 +15,8 @@ export function registerAgentInfoTools(server) {
         const _pricing = (payment.pricing ?? {});
         const creditPacks = payment.credit_packs;
         const totalJobs = (s.completedJobs ?? a.totalExecutions ?? 0);
+        const provider = a.provider ?? null;
+        const urls = a.urls ?? {};
         const acceptedPayments = payment.accepted_payments ?? [];
         const paymentLabelMap = {
             tempo_usdc: "tempo",
@@ -29,6 +31,7 @@ export function registerAgentInfoTools(server) {
             "",
             a.description ?? "",
             "",
+            ...(provider?.name ? [`Provider: ${provider.name}${provider.slug ? ` (${provider.slug})` : ""}`] : []),
             `Pricing: ${formatPrice(a.pricePerRunUsd)}`,
             ...(paymentLabels.length > 0 ? [`Accepted payments: ${paymentLabels.join(", ")}`] : []),
             ...(totalJobs > 0 && a.successRate != null
@@ -91,7 +94,7 @@ export function registerAgentInfoTools(server) {
                 lines.push(`  ${name}: ${def.type ?? "string"}${req}${desc}`);
             }
         }
-        lines.push("", `ID: ${a.id}`, `View: ${agentWebUrl(a.id)}`);
+        lines.push("", `ID: ${a.id}`, `View: ${urls.public_url ?? agentWebUrl(a.id)}`, ...(urls.mirrored_x402_url ? [`Mirrored x402: ${urls.mirrored_x402_url}`] : []), ...(urls.normalized_x402_url ? [`Agent x402: ${urls.normalized_x402_url}`] : []), ...(urls.agent_card_url ? [`AgentCard: ${urls.agent_card_url}`] : []));
         return text(lines.join("\n"));
     });
 }

package/dist/tools/index.d.ts

@@ -10,3 +10,4 @@ export { registerTipTools } from "./tip.js";
 export { registerPassTools } from "./passes.js";
 export { registerUploadTools } from "./upload.js";
 export { registerProbeTools } from "./probe.js";
+export { registerProviderTools } from "./providers.js";

package/dist/tools/index.js

@@ -10,3 +10,4 @@ export { registerTipTools } from "./tip.js";
 export { registerPassTools } from "./passes.js";
 export { registerUploadTools } from "./upload.js";
 export { registerProbeTools } from "./probe.js";
+export { registerProviderTools } from "./providers.js";

package/dist/tools/providers.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerProviderTools(server: McpServer): void;