@agentwonderland/mcp 0.1.1

package/src/tools/solve.ts

@@ -0,0 +1,162 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+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 type { AgentRecord } from "../core/types.js";
+import { storeFeedbackToken } from "./_token-cache.js";
+
+function text(t: string) {
+  return { content: [{ type: "text" as const, text: t }] };
+}
+
+function ratingPrompt(jobId: string): string {
+  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: McpServer): void {
+  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<Record<string, unknown>>("/solve", {
+          intent,
+          input,
+          budget,
+        });
+        const jobId = (result as Record<string, unknown>).job_id as string ?? "";
+        const agentId = (result as Record<string, unknown>).agent_id as string ?? "";
+
+        if (result.feedback_token) {
+          storeFeedbackToken(jobId, result.feedback_token as string, agentId);
+        }
+
+        return text(formatRunResult(result) + ratingPrompt(jobId));
+      } catch (err: unknown) {
+        const isAuthError =
+          err instanceof Error &&
+          "status" in err &&
+          (err as { status: number }).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<AgentRecord[]>(`/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: Record<string, unknown>;
+      try {
+        result = await apiPostWithPayment<Record<string, unknown>>(
+          `/agents/${selected.id}/run`,
+          { input },
+          method,
+        );
+      } catch (err: unknown) {
+        const apiErr = err as { status?: number; message?: string };
+        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 as Record<string, unknown>).job_id as string ?? "";
+      const agentId2 = (result as Record<string, unknown>).agent_id as string ?? selected.id;
+
+      if (result.feedback_token) {
+        storeFeedbackToken(jobId, result.feedback_token as string, 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/src/tools/tip.ts

@@ -0,0 +1,59 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { apiPost } from "../core/api-client.js";
+import { getFeedbackToken } from "./_token-cache.js";
+
+function text(t: string) {
+  return { content: [{ type: "text" as const, text: t }] };
+}
+
+export function registerTipTools(server: McpServer) {
+  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: unknown) {
+        const apiErr = err as {
+          status?: number;
+          body?: { error?: string };
+          message?: string;
+        };
+        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/src/tools/wallet.ts

@@ -0,0 +1,268 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+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: string) {
+  return { content: [{ type: "text" as const, text: t }] };
+}
+
+export function registerWalletTools(server: McpServer): void {
+  // ── 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!}`
+        ) as `0x${string}`;
+        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: string[] = [];
+      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/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "declaration": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["src/__tests__"]
+}