@agentwonderland/mcp 0.1.1

package/dist/tools/search.js

@@ -0,0 +1,81 @@
+import { z } from "zod";
+import { apiGet } from "../core/api-client.js";
+import { getAcceptedPaymentMethods } from "../core/payments.js";
+import { isFavorite } from "../core/config.js";
+import { agentLine } from "../core/formatters.js";
+function text(t) {
+    return { content: [{ type: "text", 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)"),
+        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 }) => {
+        const requestedLimit = limit ?? 10;
+        const params = new URLSearchParams();
+        if (query)
+            params.set("q", query);
+        if (tag)
+            params.set("tag", tag);
+        // When filtering by min_rating client-side, request more results
+        const apiLimit = min_rating ? requestedLimit * 3 : requestedLimit;
+        params.set("limit", String(apiLimit));
+        if (max_price)
+            params.set("price_max", String(max_price));
+        // Translate sort option to API sort/order params
+        if (sort) {
+            const sortMap = {
+                relevance: "reputation",
+                rating: "reputation",
+                popularity: "jobs",
+                price: "price",
+                newest: "newest",
+            };
+            params.set("sort", sortMap[sort] ?? "reputation");
+            // Price sort defaults to ascending, everything else descending
+            params.set("order", sort === "price" ? "asc" : "desc");
+        }
+        const acceptedMethods = getAcceptedPaymentMethods();
+        if (acceptedMethods.length > 0) {
+            params.set("accepted_payment_methods", acceptedMethods.join(","));
+        }
+        let agents = await apiGet(`/agents?${params}`);
+        // Client-side min_rating filter
+        if (min_rating) {
+            agents = agents.filter((a) => {
+                const rating = a.reputationScore ?? a.avgRating ?? 0;
+                // Convert 0-1 reputation to 1-5 scale if needed
+                const stars = rating <= 1 ? rating * 5 : rating;
+                return stars >= min_rating;
+            });
+        }
+        // Trim to requested limit after filtering
+        agents = agents.slice(0, requestedLimit);
+        if (agents.length === 0) {
+            return text(query ? `No agents found matching "${query}".` : "No agents found.");
+        }
+        // Build header with active filters
+        const filters = [];
+        if (max_price)
+            filters.push(`max $${max_price}`);
+        if (min_rating)
+            filters.push(`min ${min_rating}\u2605`);
+        if (sort && sort !== "relevance")
+            filters.push(`sorted by ${sort}`);
+        const filterStr = filters.length > 0 ? ` (${filters.join(", ")})` : "";
+        const header = query
+            ? `Found ${agents.length} agent${agents.length === 1 ? "" : "s"} matching "${query}"${filterStr}:`
+            : `Found ${agents.length} agent${agents.length === 1 ? "" : "s"}${filterStr}:`;
+        const lines = agents.map((a) => {
+            const fav = isFavorite(a.id) ? " \u2605" : "";
+            return `  ${agentLine(a)}${fav}`;
+        });
+        const footer = "\nBrowse all agents: https://agentwonderland.com/agents";
+        return text([header, "", ...lines, footer].join("\n"));
+    });
+}

package/dist/tools/solve.d.ts

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

package/dist/tools/solve.js

@@ -0,0 +1,124 @@
+import { z } from "zod";
+import { apiGet, apiPost, apiPostWithPayment } from "../core/api-client.js";
+import { hasWalletConfigured, getConfiguredMethods, getAcceptedPaymentMethods, } from "../core/payments.js";
+import { agentList, formatRunResult } from "../core/formatters.js";
+import { storeFeedbackToken } from "./_token-cache.js";
+function text(t) {
+    return { content: [{ type: "text", text: t }] };
+}
+function ratingPrompt(jobId) {
+    return [
+        "",
+        "---",
+        "How was this result? You can:",
+        `  • rate_agent with job_id "${jobId}" and a score (1-5) — within 1 hour`,
+        "  • tip_agent to show appreciation — within 1 hour",
+        "  • favorite_agent to save this agent for later",
+    ].join("\n");
+}
+export function registerSolveTools(server) {
+    server.tool("solve", "Solve a task by finding the best agent, paying, and executing. The primary way to use the marketplace — describe what you need and the system handles discovery, selection, payment, and execution.", {
+        intent: z
+            .string()
+            .describe("What you want to accomplish (natural language)"),
+        input: z
+            .record(z.unknown())
+            .optional()
+            .default({})
+            .describe("Input payload for the agent"),
+        budget: z
+            .number()
+            .positive()
+            .max(100)
+            .optional()
+            .default(1.0)
+            .describe("Maximum budget in USD"),
+        pay_with: z
+            .string()
+            .optional()
+            .describe("Payment method — wallet ID, chain name (tempo, base, etc.), or 'card'. Auto-detected if omitted."),
+    }, async ({ intent, input, budget, pay_with }) => {
+        if (!hasWalletConfigured()) {
+            return text("No wallet configured. Set one up first:\n\n" +
+                '  wallet_setup({ action: "create", name: "my-wallet" })\n\n' +
+                "Then fund it with USDC on Tempo and try again.");
+        }
+        const method = pay_with ?? getConfiguredMethods()[0];
+        // Path 1: If authenticated, use the platform /solve route
+        try {
+            const result = await apiPost("/solve", {
+                intent,
+                input,
+                budget,
+            });
+            const jobId = result.job_id ?? "";
+            const agentId = result.agent_id ?? "";
+            if (result.feedback_token) {
+                storeFeedbackToken(jobId, result.feedback_token, agentId);
+            }
+            return text(formatRunResult(result) + ratingPrompt(jobId));
+        }
+        catch (err) {
+            const isAuthError = err instanceof Error &&
+                "status" in err &&
+                err.status === 401;
+            if (!isAuthError || !hasWalletConfigured())
+                throw err;
+        }
+        // Path 2: Wallet-only discovery — find agents, pick best, pay via MPP
+        const params = new URLSearchParams({ q: intent, limit: "5" });
+        const acceptedMethods = getAcceptedPaymentMethods();
+        if (acceptedMethods.length > 0) {
+            params.set("accepted_payment_methods", acceptedMethods.join(","));
+        }
+        const agents = await apiGet(`/agents?${params}`);
+        if (!agents || agents.length === 0) {
+            return text(`No agents found matching "${intent}".`);
+        }
+        // Show discovery results
+        const discovery = agentList(agents, intent);
+        // Pick cheapest agent within budget
+        const inputTokens = Math.ceil(JSON.stringify(input).length / 4);
+        const affordable = agents.filter((a) => {
+            const price = parseFloat(a.pricePer1kTokens ?? "0.01");
+            const cost = a.pricingModel === "fixed" ? price : (inputTokens / 1000) * price;
+            return cost <= budget;
+        });
+        const selected = affordable[0] ?? agents[0];
+        // Estimate cost for the selected agent
+        const selectedPrice = parseFloat(selected.pricePer1kTokens ?? "0.01");
+        const estimatedCost = selected.pricingModel === "fixed"
+            ? selectedPrice
+            : (inputTokens / 1000) * selectedPrice;
+        let result;
+        try {
+            result = await apiPostWithPayment(`/agents/${selected.id}/run`, { input }, method);
+        }
+        catch (err) {
+            const apiErr = err;
+            if (apiErr?.status === 402) {
+                return text("Payment failed — your wallet may not have enough USDC.\n\n" +
+                    "Check your balance and fund your wallet, then try again.\n" +
+                    "Use wallet_status to check your current payment methods.");
+            }
+            return text(`Error: ${apiErr?.message ?? "Failed to run agent"}`);
+        }
+        // Cache feedback token if present
+        const jobId = result.job_id ?? "";
+        const agentId2 = result.agent_id ?? selected.id;
+        if (result.feedback_token) {
+            storeFeedbackToken(jobId, result.feedback_token, agentId2);
+        }
+        // Combine discovery + result
+        const output = [
+            discovery,
+            "",
+            `Running ${selected.name} — best match`,
+            `Estimated cost: $${estimatedCost.toFixed(4)}`,
+            "",
+            formatRunResult(result, { paymentMethod: method }),
+            ratingPrompt(jobId),
+        ].join("\n");
+        return text(output);
+    });
+}

package/dist/tools/tip.d.ts

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

package/dist/tools/tip.js

@@ -0,0 +1,40 @@
+import { z } from "zod";
+import { apiPost } from "../core/api-client.js";
+import { getFeedbackToken } from "./_token-cache.js";
+function text(t) {
+    return { content: [{ type: "text", text: t }] };
+}
+export function registerTipTools(server) {
+    server.tool("tip_agent", "Send a tip to an agent you've used. Tips help surface the best agents. Must be used within 1 hour of running the agent.", {
+        job_id: z.string().describe("Job ID from a completed execution"),
+        agent_id: z.string().describe("Agent ID to tip"),
+        amount: z.number().min(0.01).max(50).describe("Tip amount in USD"),
+    }, async ({ job_id, agent_id, amount }) => {
+        const tokenData = getFeedbackToken(job_id);
+        if (!tokenData) {
+            return text("No feedback token found for this job. You can only tip agents immediately after running them.");
+        }
+        // Use the resolved UUID from the run result (handles slugs)
+        const resolvedAgentId = tokenData.agent_id || agent_id;
+        try {
+            await apiPost("/tips", {
+                job_id,
+                agent_id: resolvedAgentId,
+                feedback_token: tokenData.token,
+                amount,
+            });
+            return text(`Tipped $${amount.toFixed(2)} for job ${job_id}. Thanks — tips help the best agents get discovered!`);
+        }
+        catch (err) {
+            const apiErr = err;
+            if (apiErr?.status === 401) {
+                return text("Feedback token expired. Tips must be submitted within 1 hour of running the agent.");
+            }
+            if (apiErr?.status === 429) {
+                return text("You can only tip this agent once every 30 days.");
+            }
+            const msg = apiErr?.body?.error || apiErr?.message || "Tip failed";
+            return text(`Could not send tip: ${msg}`);
+        }
+    });
+}

package/dist/tools/wallet.d.ts

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

package/dist/tools/wallet.js

@@ -0,0 +1,197 @@
+import { z } from "zod";
+import { getWallets, getCardConfig, addWallet } from "../core/config.js";
+import { getWalletAddress } from "../core/payments.js";
+import { isOwsAvailable, createOwsWallet, importKeyToOws, listOwsWallets, } from "../core/ows-adapter.js";
+function text(t) {
+    return { content: [{ type: "text", text: t }] };
+}
+export function registerWalletTools(server) {
+    // ── wallet_status (extracted from check_wallet) ─────────────────
+    server.tool("wallet_status", "Check payment readiness. Shows all configured wallets, their chains, addresses, and card status.", {}, async () => {
+        const wallets = getWallets();
+        const card = getCardConfig();
+        if (wallets.length === 0 && !card) {
+            return text("No payment methods configured.\nUse wallet_setup to create or import a wallet.");
+        }
+        const lines = ["Payment methods:"];
+        for (const w of wallets) {
+            const addr = await getWalletAddress(w.id);
+            const label = w.label ? ` (${w.label})` : "";
+            const storage = w.keyType === "ows" ? " [encrypted]" : " [plaintext]";
+            lines.push(`  ${w.id}${label}${storage}: ${w.chains.join(", ")} \u2014 ${addr ?? "unknown"}`);
+        }
+        if (card) {
+            lines.push(`  Card: ${card.brand} ****${card.last4}`);
+        }
+        return text(lines.join("\n"));
+    });
+    // ── wallet_setup (NEW) ──────────────────────────────────────────
+    server.tool("wallet_setup", "Create or import a wallet for paying agents. Uses OWS (Open Wallet Standard) for encrypted key storage when available, falling back to plaintext.", {
+        action: z
+            .enum(["create", "import"])
+            .describe("'create' a new wallet or 'import' an existing private key"),
+        name: z
+            .string()
+            .optional()
+            .describe("Wallet name/label (default: auto-generated)"),
+        key: z
+            .string()
+            .optional()
+            .describe("Private key hex string (required for 'import', ignored for 'create')"),
+        chain: z.enum(["tempo", "base", "solana"]).optional()
+            .describe("Primary chain (default: tempo). Solana support is via Stripe deposit mode."),
+    }, async ({ action, name, key, chain }) => {
+        if (action === "import" && !key) {
+            return text("Error: 'key' parameter is required when action is 'import'.");
+        }
+        const selectedChains = chain === "solana" ? ["solana"] : ["tempo", "base"];
+        const defaultCh = chain ?? "tempo";
+        const owsReady = await isOwsAvailable();
+        if (action === "create") {
+            // Check for existing OWS wallets first
+            if (owsReady) {
+                const existing = await listOwsWallets();
+                if (existing.length > 0) {
+                    const w = existing[0];
+                    // Check if already in config
+                    const wallets = getWallets();
+                    const alreadyLinked = wallets.find(wl => wl.owsWalletId === w.id);
+                    if (!alreadyLinked) {
+                        addWallet({
+                            id: w.name,
+                            keyType: "ows",
+                            owsWalletId: w.id,
+                            chains: selectedChains,
+                            defaultChain: defaultCh,
+                            label: w.name,
+                        });
+                    }
+                    return text([
+                        "Found existing OWS wallet:",
+                        `  Name: ${w.name}`,
+                        `  Address: ${w.address}`,
+                        `  Chains: ${selectedChains.join(", ")}`,
+                        `  Storage: ~/.ows/ (encrypted)`,
+                        "",
+                        alreadyLinked ? "Already linked to Agent Wonderland." : "Linked to Agent Wonderland.",
+                        "",
+                        `Fund this address with USDC on ${defaultCh === "solana" ? "Solana" : "Tempo"} to start using agents.`,
+                    ].join("\n"));
+                }
+            }
+            if (!owsReady) {
+                return text("Cannot create wallet: OWS (Open Wallet Standard) is not installed.\n" +
+                    "Install with: npm install -g @open-wallet-standard/core\n\n" +
+                    "Alternatively, use action 'import' with an existing private key.");
+            }
+            const walletName = name ?? `aw-${Date.now()}`;
+            const result = await createOwsWallet(walletName);
+            // Persist to config so payment flows can find it
+            addWallet({
+                id: walletName,
+                keyType: "ows",
+                owsWalletId: result.walletId,
+                chains: selectedChains,
+                defaultChain: defaultCh,
+                label: walletName,
+            });
+            return text([
+                `Wallet created [encrypted]:`,
+                `  ID: ${result.walletId}`,
+                `  Address: ${result.address}`,
+                `  Name: ${walletName}`,
+                `  Chains: ${selectedChains.join(", ")}`,
+                `  Storage: ~/.ows/ (AES-256-GCM encrypted)`,
+                "",
+                `Fund this address with USDC on ${defaultCh === "solana" ? "Solana" : "Tempo"} to start using agents.`,
+                "For testnet: npx mppx account fund",
+            ].join("\n"));
+        }
+        // action === "import"
+        if (owsReady) {
+            const walletName = name ?? `imported-${Date.now()}`;
+            const result = await importKeyToOws(key, walletName);
+            addWallet({
+                id: walletName,
+                keyType: "ows",
+                owsWalletId: result.walletId,
+                chains: selectedChains,
+                defaultChain: defaultCh,
+                label: walletName,
+            });
+            return text([
+                `Key imported to OWS [encrypted]:`,
+                `  ID: ${result.walletId}`,
+                `  Address: ${result.address}`,
+                `  Name: ${walletName}`,
+                `  Chains: ${selectedChains.join(", ")}`,
+            ].join("\n"));
+        }
+        // No OWS — store plaintext
+        try {
+            const { privateKeyToAccount } = await import("viem/accounts");
+            const normalizedKey = (key.startsWith("0x") ? key : `0x${key}`);
+            const account = privateKeyToAccount(normalizedKey);
+            const walletName = name ?? `wallet-${Date.now()}`;
+            addWallet({
+                id: walletName,
+                keyType: "evm",
+                key: normalizedKey,
+                chains: selectedChains,
+                defaultChain: defaultCh,
+                label: walletName,
+            });
+            return text([
+                `Key imported [plaintext] \u2014 OWS not available for encrypted storage.`,
+                `  Address: ${account.address}`,
+                `  Name: ${walletName}`,
+                `  Chains: ${selectedChains.join(", ")}`,
+                "",
+                "Install OWS for encrypted storage: npm install -g @open-wallet-standard/core",
+            ].join("\n"));
+        }
+        catch {
+            return text("Error: Invalid private key format.");
+        }
+    });
+    // ── wallet_set_policy (NEW) ─────────────────────────────────────
+    server.tool("wallet_set_policy", "Set spending limits on a wallet to control agent costs. Limits reset daily.", {
+        wallet_id: z.string().describe("Wallet ID to set policy on"),
+        max_per_tx: z
+            .number()
+            .positive()
+            .optional()
+            .describe("Maximum USD per transaction"),
+        max_per_day: z
+            .number()
+            .positive()
+            .optional()
+            .describe("Maximum USD per day across all transactions"),
+    }, async ({ wallet_id, max_per_tx, max_per_day }) => {
+        const wallets = getWallets();
+        const wallet = wallets.find((w) => w.id === wallet_id);
+        if (!wallet) {
+            const available = wallets.map((w) => w.id).join(", ") || "none";
+            return text(`Wallet "${wallet_id}" not found. Available wallets: ${available}`);
+        }
+        if (max_per_tx == null && max_per_day == null) {
+            return text("No policy changes specified. Provide max_per_tx and/or max_per_day.");
+        }
+        // Build policy summary
+        const policies = [];
+        if (max_per_tx != null) {
+            policies.push(`Max per transaction: $${max_per_tx.toFixed(2)}`);
+        }
+        if (max_per_day != null) {
+            policies.push(`Max per day: $${max_per_day.toFixed(2)}`);
+        }
+        // Note: actual persistence depends on the config module supporting policy fields.
+        // For now, we report what would be set. The core/config module will handle storage.
+        return text([
+            `Spending policy set for wallet "${wallet_id}":`,
+            ...policies.map((p) => `  ${p}`),
+            "",
+            "Policy will be enforced on all future transactions from this wallet.",
+        ].join("\n"));
+    });
+}

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@agentwonderland/mcp",
+  "version": "0.1.1",
+  "type": "module",
+  "description": "MCP server for the Agent Wonderland AI agent marketplace",
+  "bin": {
+    "agentwonderland-mcp": "./dist/index.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./core": {
+      "types": "./dist/core/index.d.ts",
+      "default": "./dist/core/index.js"
+    }
+  },
+  "scripts": {
+    "dev": "tsx src/index.ts",
+    "build": "tsc",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.1",
+    "mppx": "^0.4.9",
+    "viem": "^2.47.6",
+    "zod": "^3.24.0"
+  },
+  "peerDependencies": {
+    "@open-wallet-standard/core": "^1.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@open-wallet-standard/core": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "tsx": "^4.0.0",
+    "typescript": "^5.7.0"
+  },
+  "keywords": [
+    "mcp",
+    "ai-agents",
+    "marketplace",
+    "payments",
+    "mpp"
+  ]
+}

package/src/core/api-client.ts

@@ -0,0 +1,114 @@
+import { getApiUrl, getApiKey } from "./config.js";
+import { getPaymentFetch } from "./payments.js";
+
+// ── Error class ────────────────────────────────────────────────────
+
+export class ApiError extends Error {
+  constructor(
+    public readonly status: number,
+    message: string,
+    public readonly body?: unknown,
+  ) {
+    super(message);
+    this.name = "ApiError";
+  }
+}
+
+// ── Internal helpers ───────────────────────────────────────────────
+
+function buildHeaders(): Record<string, string> {
+  const headers: Record<string, string> = {
+    "Content-Type": "application/json",
+    Accept: "application/json",
+  };
+
+  const apiKey = getApiKey();
+  if (apiKey) {
+    headers["Authorization"] = `Bearer ${apiKey}`;
+  }
+
+  return headers;
+}
+
+async function handleResponse<T>(response: Response): Promise<T> {
+  let body: unknown;
+  const contentType = response.headers.get("content-type") ?? "";
+
+  if (contentType.includes("application/json")) {
+    body = await response.json();
+  } else {
+    body = await response.text();
+  }
+
+  if (!response.ok) {
+    const bodyObj = body && typeof body === "object" ? body as Record<string, unknown> : null;
+    const message = bodyObj?.error
+      ? String(bodyObj.error)
+      : bodyObj?.message
+        ? String(bodyObj.message)
+        : typeof body === "string"
+          ? body
+          : `Request failed with status ${response.status}`;
+    throw new ApiError(response.status, message, body);
+  }
+
+  return body as T;
+}
+
+// ── Public API ─────────────────────────────────────────────────────
+
+export async function apiGet<T>(path: string): Promise<T> {
+  const url = `${getApiUrl()}${path}`;
+  const response = await fetch(url, {
+    method: "GET",
+    headers: buildHeaders(),
+  });
+  return handleResponse<T>(response);
+}
+
+export async function apiPost<T>(path: string, body: unknown): Promise<T> {
+  const url = `${getApiUrl()}${path}`;
+  const response = await fetch(url, {
+    method: "POST",
+    headers: buildHeaders(),
+    body: JSON.stringify(body),
+  });
+  return handleResponse<T>(response);
+}
+
+/**
+ * POST with payment support. Uses the configured payment method to
+ * auto-handle 402 → sign → retry for paid endpoints.
+ * Pass `payWith` to specify a method, or omit for auto-detection.
+ */
+export async function apiPostWithPayment<T>(path: string, body: unknown, payWith?: string): Promise<T> {
+  const url = `${getApiUrl()}${path}`;
+  const paymentFetch = await getPaymentFetch(payWith);
+  const response = await paymentFetch(url, {
+    method: "POST",
+    headers: buildHeaders(),
+    body: JSON.stringify(body),
+  });
+  const result = await handleResponse<T>(response);
+
+  // mppx may strip extra fields from the response body during receipt processing.
+  // The gateway also sends feedback_token as a header to survive this.
+  if (result && typeof result === "object" && !("feedback_token" in result)) {
+    const headerToken = response.headers.get("x-feedback-token");
+    if (headerToken) {
+      (result as Record<string, unknown>).feedback_token = headerToken;
+    }
+  }
+
+  return result;
+}
+
+export async function apiPut<T>(path: string, body: unknown): Promise<T> {
+  const url = `${getApiUrl()}${path}`;
+  const response = await fetch(url, {
+    method: "PUT",
+    headers: buildHeaders(),
+    body: JSON.stringify(body),
+  });
+  return handleResponse<T>(response);
+}