@agentwonderland/mcp 0.1.1

package/src/resources/agents.ts

@@ -0,0 +1,37 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { apiGet } from "../core/api-client.js";
+import { formatPrice, stars, compactNumber } from "../core/formatters.js";
+
+export function registerAgentResources(server: McpServer) {
+  // Agent directory — browsable list of all agents
+  server.resource("agent-directory", "aw://agents", async () => {
+    const agents = await apiGet<any[]>("/agents?limit=50");
+    const lines = agents.map(a => {
+      const rating = stars(a.reputationScore);
+      const jobs = compactNumber(a.totalExecutions);
+      const price = formatPrice(a.pricePer1kTokens);
+      return `${a.name} ${rating} ${jobs} jobs | ${price}/req — ${a.description || ""}`;
+    });
+    return {
+      contents: [{
+        uri: "aw://agents",
+        mimeType: "text/plain",
+        text: `Agent Wonderland Marketplace (${agents.length} agents)\n\n${lines.join("\n")}`,
+      }],
+    };
+  });
+
+  // Agent schema — input schema for a specific agent
+  server.resource("agent-schema", "aw://agents/{id}/schema", async (uri) => {
+    const id = uri.pathname?.split("/").pop() || uri.href.split("/").pop()?.split("?")[0];
+    const agent = await apiGet<any>(`/agents/${id}`);
+    const schema = agent.mcpSchema ? JSON.stringify(agent.mcpSchema, null, 2) : "No schema defined";
+    return {
+      contents: [{
+        uri: uri.href,
+        mimeType: "application/json",
+        text: schema,
+      }],
+    };
+  });
+}

package/src/resources/jobs.ts

@@ -0,0 +1,17 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { apiGet } from "../core/api-client.js";
+import { formatRunResult } from "../core/formatters.js";
+
+export function registerJobResources(server: McpServer) {
+  server.resource("job-result", "aw://jobs/{id}", async (uri) => {
+    const id = uri.pathname?.split("/").pop() || uri.href.split("/").pop()?.split("?")[0];
+    const job = await apiGet<any>(`/jobs/${id}`);
+    return {
+      contents: [{
+        uri: uri.href,
+        mimeType: "text/plain",
+        text: formatRunResult(job),
+      }],
+    };
+  });
+}

package/src/resources/wallet.ts

@@ -0,0 +1,30 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { getWallets, getCardConfig } from "../core/config.js";
+import { getWalletAddress, getConfiguredMethods } from "../core/payments.js";
+
+export function registerWalletResources(server: McpServer) {
+  server.resource("wallet-config", "aw://wallet", async () => {
+    const wallets = getWallets();
+    const card = getCardConfig();
+    const methods = getConfiguredMethods();
+
+    const lines = ["Wallet Configuration", ""];
+    for (const w of wallets) {
+      const addr = await getWalletAddress(w.id);
+      const storage = w.keyType === "ows" ? "[encrypted]" : "[plaintext]";
+      lines.push(`${w.id} ${storage}: ${w.chains.join(", ")} — ${addr}`);
+    }
+    if (card) {
+      lines.push(`Card: ${card.brand} ****${card.last4}`);
+    }
+    lines.push("", `Configured methods: ${methods.join(", ") || "none"}`);
+
+    return {
+      contents: [{
+        uri: "aw://wallet",
+        mimeType: "text/plain",
+        text: lines.join("\n"),
+      }],
+    };
+  });
+}

package/src/tools/_token-cache.ts

@@ -0,0 +1,18 @@
+// Feedback token cache — stores tokens from recent run/solve results
+// Tokens expire after 1 hour on the server, so no need for client-side cleanup
+
+const cache = new Map<string, { token: string; agent_id: string }>();
+
+export function storeFeedbackToken(
+  jobId: string,
+  token: string,
+  agentId: string,
+): void {
+  cache.set(jobId, { token, agent_id: agentId });
+}
+
+export function getFeedbackToken(
+  jobId: string,
+): { token: string; agent_id: string } | undefined {
+  return cache.get(jobId);
+}

package/src/tools/agent-info.ts

@@ -0,0 +1,120 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { apiGet } from "../core/api-client.js";
+import { formatPrice, stars, compactNumber, outputTypeHint, agentWebUrl, formatFeedbackSummary, formatLastActive } from "../core/formatters.js";
+import type { AgentRecord } from "../core/types.js";
+
+function text(t: string) {
+  return { content: [{ type: "text" as const, text: t }] };
+}
+
+export function registerAgentInfoTools(server: McpServer): void {
+  // ── get_agent (renamed from agent_profile) ──────────────────────
+  server.tool(
+    "get_agent",
+    "Get detailed information about a specific agent including description, pricing, success rate, latency, and tags.",
+    {
+      agent_id: z.string().describe("Agent ID (UUID) or slug"),
+    },
+    async ({ agent_id }) => {
+      const a = await apiGet<AgentRecord>(`/agents/${agent_id}`);
+      const s = (a.stats ?? {}) as Record<string, unknown>;
+      const payment = (a.payment ?? {}) as Record<string, unknown>;
+      const _pricing = (payment.pricing ?? {}) as Record<string, unknown>;
+
+      const lines = [
+        `${a.name}`,
+        `${stars(a.avgRating ?? (s.avgRating as number))} (${s.ratingCount ?? 0} reviews) • ${compactNumber((s.completedJobs ?? a.totalExecutions ?? 0) as number)} jobs`,
+        "",
+        (a.description as string) ?? "",
+        "",
+        `Pricing: ${formatPrice(a.pricePer1kTokens, a.pricingModel)}`,
+        `Reliability: ${a.successRate != null ? (Number(a.successRate) * 100).toFixed(0) + "%" : "N/A"}`,
+        `Avg latency: ${(a.avgResponseTimeMs as number) != null ? a.avgResponseTimeMs + "ms" : "N/A"}`,
+        ...(() => {
+          const lastActive = formatLastActive(a.lastActiveAt as string | null);
+          return lastActive ? [lastActive] : [];
+        })(),
+        "",
+        `Tags: ${(a.tags as string[])?.join(", ") ?? "none"}`,
+        ...(() => {
+          const hint = outputTypeHint(a.tags as string[]);
+          return hint ? [`Output: ${hint}`] : [];
+        })(),
+      ];
+
+      // Feedback summary (rating + tips)
+      const feedbackSummary = formatFeedbackSummary(s);
+      if (feedbackSummary) {
+        lines.push("", feedbackSummary);
+      }
+
+      // Fetch recent reviews with comments
+      try {
+        const reviews = await apiGet<{ reviews: Array<{ rating: number; comment: string | null; createdAt: string }>; total: number }>(`/agents/${a.id}/reviews?limit=3&sort=recent`);
+        const withComments = reviews.reviews?.filter((r) => r.comment);
+        if (withComments?.length) {
+          lines.push("", "Recent reviews:");
+          for (const r of withComments) {
+            lines.push(`  ${stars(r.rating)} "${r.comment}"`);
+          }
+        }
+      } catch {
+        // Reviews endpoint may not be available
+      }
+
+      // Input schema — show what fields the agent accepts
+      const schema = (a.schema as Record<string, unknown>)?.input as Record<string, unknown> | undefined;
+      const inputSchema = (schema?.inputSchema ?? (a.mcpSchema as Record<string, unknown>)?.inputSchema) as Record<string, unknown> | undefined;
+      if (inputSchema?.properties) {
+        const props = inputSchema.properties as Record<string, { type?: string; description?: string }>;
+        const required = new Set((inputSchema.required as string[]) ?? []);
+        lines.push("", "Input fields:");
+        for (const [name, def] of Object.entries(props)) {
+          const req = required.has(name) ? " (required)" : "";
+          const desc = def.description ? ` — ${def.description}` : "";
+          lines.push(`  ${name}: ${def.type ?? "string"}${req}${desc}`);
+        }
+      }
+
+      lines.push("", `ID: ${a.id}`, `View: ${agentWebUrl(a.id)}`);
+      return text(lines.join("\n"));
+    },
+  );
+
+  // ── compare_agents ──────────────────────────────────────────────
+  server.tool(
+    "compare_agents",
+    "Compare multiple agents side-by-side on rating, price, success rate, and job count.",
+    {
+      agent_ids: z
+        .array(z.string())
+        .min(2)
+        .max(5)
+        .describe("Agent IDs to compare (2-5)"),
+    },
+    async ({ agent_ids }) => {
+      const agents = await Promise.all(
+        agent_ids.map((id) => apiGet<AgentRecord>(`/agents/${id}`)),
+      );
+
+      const header = "Agent Comparison:\n";
+      const lines = agents.map((a) => {
+        const s = (a.stats ?? {}) as Record<string, unknown>;
+        const rating = a.avgRating ?? (s.avgRating as number);
+        const jobs = (s.completedJobs ?? a.totalExecutions ?? 0) as number;
+        const tipCount = (s.tipCount ?? 0) as number;
+        return [
+          `  ${a.name}`,
+          `  ${stars(rating)} (${s.ratingCount ?? 0} reviews)${tipCount > 0 ? ` • ${tipCount} tips` : ""}`,
+          `  ${compactNumber(jobs)} jobs • ${formatPrice(a.pricePer1kTokens, a.pricingModel)}`,
+          `  Success: ${a.successRate != null ? (Number(a.successRate) * 100).toFixed(0) + "%" : "N/A"}`,
+          `  ${agentWebUrl(a.id)}`,
+          "",
+        ].join("\n");
+      });
+
+      return text(header + lines.join("\n"));
+    },
+  );
+}

package/src/tools/favorites.ts

@@ -0,0 +1,74 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { getFavorites, addFavorite, removeFavorite } from "../core/config.js";
+import { apiGet } from "../core/api-client.js";
+import { formatPrice, stars, compactNumber } from "../core/formatters.js";
+
+function text(t: string) {
+  return { content: [{ type: "text" as const, text: t }] };
+}
+
+export function registerFavoriteTools(server: McpServer) {
+  // favorite_agent — add an agent to favorites
+  server.tool(
+    "favorite_agent",
+    "Save an agent to your favorites for quick access",
+    {
+      agent_id: z.string().describe("Agent ID to favorite"),
+    },
+    async ({ agent_id }) => {
+      // Verify agent exists
+      const agent = await apiGet<Record<string, unknown>>(`/agents/${agent_id}`);
+      addFavorite(agent_id);
+      return text(`★ Added ${agent.name} to favorites`);
+    },
+  );
+
+  // unfavorite_agent — remove from favorites
+  server.tool(
+    "unfavorite_agent",
+    "Remove an agent from your favorites",
+    {
+      agent_id: z.string().describe("Agent ID to remove"),
+    },
+    async ({ agent_id }) => {
+      removeFavorite(agent_id);
+      return text("Removed from favorites");
+    },
+  );
+
+  // list_favorites — show all favorited agents with details
+  server.tool(
+    "list_favorites",
+    "List your favorite agents",
+    {},
+    async () => {
+      const ids = getFavorites();
+      if (ids.length === 0) {
+        return text("No favorites yet. Use favorite_agent to save agents you like.");
+      }
+
+      const lines = ["Your favorite agents:", ""];
+      for (const id of ids) {
+        try {
+          const agent = await apiGet<Record<string, unknown>>(`/agents/${id}`);
+          const rating = stars(agent.avgRating as number | null | undefined);
+          const jobs = compactNumber(agent.totalExecutions as number | null | undefined);
+          const price = formatPrice(
+            agent.pricePer1kTokens as string | null | undefined,
+            agent.pricingModel as string | null | undefined,
+          );
+          lines.push(`${agent.name} ${rating} ${jobs} jobs | ${price}`);
+          lines.push(`  ID: ${id}`);
+          if (agent.description) lines.push(`  ${agent.description}`);
+          lines.push("");
+        } catch {
+          lines.push(`${id} (not found — may have been removed)`);
+          lines.push("");
+        }
+      }
+
+      return text(lines.join("\n"));
+    },
+  );
+}

package/src/tools/index.ts

@@ -0,0 +1,9 @@
+export { registerSearchTools } from "./search.js";
+export { registerRunTools } from "./run.js";
+export { registerSolveTools } from "./solve.js";
+export { registerAgentInfoTools } from "./agent-info.js";
+export { registerJobTools } from "./jobs.js";
+export { registerRateTools } from "./rate.js";
+export { registerWalletTools } from "./wallet.js";
+export { registerFavoriteTools } from "./favorites.js";
+export { registerTipTools } from "./tip.js";

package/src/tools/jobs.ts

@@ -0,0 +1,69 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { apiGet } from "../core/api-client.js";
+import { isAuthenticated } from "../core/config.js";
+import { hasWalletConfigured, getWalletAddress } from "../core/payments.js";
+import { formatRunResult } from "../core/formatters.js";
+
+function text(t: string) {
+  return { content: [{ type: "text" as const, text: t }] };
+}
+
+export function registerJobTools(server: McpServer): void {
+  // ── get_job ─────────────────────────────────────────────────────
+  server.tool(
+    "get_job",
+    "Get the status and output of a job by ID. Use to poll async jobs until they complete.",
+    {
+      job_id: z.string().describe("Job ID (UUID)"),
+    },
+    async ({ job_id }) => {
+      const result = await apiGet<Record<string, unknown>>(`/jobs/${job_id}`);
+      if (result.status === "processing") {
+        return text(`Job ${job_id} is still processing...`);
+      }
+      return text(formatRunResult(result));
+    },
+  );
+
+  // ── list_jobs (renamed from list_my_jobs) ───────────────────────
+  server.tool(
+    "list_jobs",
+    "List your recent jobs with status, cost, and agent info.",
+    {
+      limit: z.coerce.number().optional().default(10).describe("Max results (1-50)"),
+    },
+    async ({ limit }) => {
+      let url = `/jobs?limit=${limit ?? 10}`;
+
+      // If not authenticated via API key, use wallet address for lookup
+      if (!isAuthenticated() && hasWalletConfigured()) {
+        const address = await getWalletAddress();
+        if (address) {
+          url += `&wallet=${encodeURIComponent(address)}`;
+        }
+      }
+
+      const jobs = await apiGet<Array<Record<string, unknown>>>(url);
+      if (jobs.length === 0) return text("No jobs found.");
+
+      const lines = [`Recent jobs (${jobs.length}):`];
+      for (const j of jobs) {
+        const status =
+          j.status === "completed"
+            ? "\u2713"
+            : j.status === "processing"
+              ? "\u2026"
+              : "\u2717";
+        const cost =
+          j.estimated_cost != null
+            ? `$${Number(j.estimated_cost).toFixed(4)}`
+            : "";
+        lines.push(
+          `  ${status} ${(j.job_id as string)?.slice(0, 8)}\u2026 ${j.agent_id ? String(j.agent_id).slice(0, 8) + "\u2026" : ""} ${cost}`,
+        );
+      }
+      return text(lines.join("\n"));
+    },
+  );
+}

package/src/tools/rate.ts

@@ -0,0 +1,62 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { apiPost } from "../core/api-client.js";
+import { stars } from "../core/formatters.js";
+import { getFeedbackToken } from "./_token-cache.js";
+
+function text(t: string) {
+  return { content: [{ type: "text" as const, text: t }] };
+}
+
+export function registerRateTools(server: McpServer): void {
+  server.tool(
+    "rate_agent",
+    "Rate an agent after running it. Provide the job ID from the run result. Must be used within 1 hour of running the agent.",
+    {
+      job_id: z.string().describe("Job ID from the run result"),
+      rating: z.number().min(1).max(5).describe("Rating 1-5 stars"),
+      comment: z.string().optional().describe("Optional feedback comment"),
+    },
+    async ({ job_id, rating, comment }) => {
+      const tokenData = getFeedbackToken(job_id);
+      if (!tokenData) {
+        return text(
+          "No feedback token found for this job. You can only rate agents immediately after running them.",
+        );
+      }
+
+      try {
+        await apiPost("/feedback", {
+          job_id,
+          feedback_token: tokenData.token,
+          rating,
+          thumb: rating >= 3 ? "up" : "down",
+          ...(comment ? { comment } : {}),
+        });
+        const starStr = stars(rating);
+        return text(
+          `${starStr} Rating submitted for job ${job_id}${comment ? ` \u2014 "${comment}"` : ""}`,
+        );
+      } catch (err: unknown) {
+        const apiErr = err as {
+          status?: number;
+          body?: { error?: string };
+          message?: string;
+        };
+        if (apiErr?.status === 401) {
+          return text(
+            "Feedback token expired. Ratings must be submitted within 1 hour of running the agent.",
+          );
+        }
+        if (apiErr?.status === 409) {
+          return text("You've already rated this job.");
+        }
+        if (apiErr?.status === 429) {
+          return text("You can only rate this agent once every 30 days.");
+        }
+        const msg = apiErr?.body?.error || apiErr?.message || "Rating failed";
+        return text(`Could not submit rating: ${msg}`);
+      }
+    },
+  );
+}

package/src/tools/run.ts

@@ -0,0 +1,97 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { apiGet, apiPostWithPayment } from "../core/api-client.js";
+import { getConfiguredMethods, hasWalletConfigured } from "../core/payments.js";
+import { formatRunResult } from "../core/formatters.js";
+import { storeFeedbackToken } from "./_token-cache.js";
+
+function text(t: string) {
+  return { content: [{ type: "text" as const, text: t }] };
+}
+
+export function registerRunTools(server: McpServer): void {
+  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.",
+    {
+      agent_id: z.string().describe("Agent ID (UUID or slug)"),
+      input: z.record(z.unknown()).describe("Input payload for the agent"),
+      pay_with: z.string().optional().describe("Payment method — wallet ID, chain name (tempo, base, etc.), or 'card'. Auto-detected if omitted."),
+    },
+    async ({ agent_id, input, 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."
+        );
+      }
+
+      // Resolve slug to UUID if needed (slugs don't contain hyphens in UUID positions)
+      let resolvedId = agent_id;
+      const isUuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(agent_id);
+      if (!isUuid) {
+        try {
+          const agent = await apiGet<{ id: string }>(`/agents/${agent_id}`);
+          resolvedId = agent.id;
+        } catch {
+          return text(`Agent "${agent_id}" not found. Use search_agents to find available agents.`);
+        }
+      }
+
+      const method = pay_with;
+      let result: Record<string, unknown>;
+      try {
+        result = await apiPostWithPayment<Record<string, unknown>>(
+          `/agents/${resolvedId}/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."
+          );
+        }
+        const msg = apiErr?.message ?? "Failed to run agent";
+        if (msg.includes("Missing required field") || msg.includes("validation failed")) {
+          return text(`Error: ${msg}\n\nUse get_agent("${agent_id}") to see the required input fields.`);
+        }
+        return text(`Error: ${msg}`);
+      }
+      const formatted = formatRunResult(result, {
+        paymentMethod: method ?? getConfiguredMethods()[0],
+      });
+      const jobId = (result.job_id as string) ?? "";
+      const agentId = (result.agent_id as string) ?? agent_id;
+
+      if (result.feedback_token) {
+        storeFeedbackToken(jobId, result.feedback_token as string, agentId);
+      }
+
+      const status = result.status as string;
+      let prompt: string;
+      if (status === "success") {
+        prompt = [
+          "",
+          "---",
+          "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");
+      } else {
+        prompt = [
+          "",
+          "---",
+          "The agent execution failed. A refund has been initiated automatically",
+          "and will be returned to your wallet.",
+        ].join("\n");
+      }
+      return text(formatted + prompt);
+    },
+  );
+}

package/src/tools/search.ts

@@ -0,0 +1,96 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+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";
+import type { AgentRecord } from "../core/types.js";
+
+function text(t: string) {
+  return { content: [{ type: "text" as const, text: t }] };
+}
+
+export function registerSearchTools(server: McpServer): void {
+  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: Record<string, string> = {
+          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<AgentRecord[]>(`/agents?${params}`);
+
+      // Client-side min_rating filter
+      if (min_rating) {
+        agents = agents.filter((a: any) => {
+          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: string[] = [];
+      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"));
+    },
+  );
+}