@rickydata/agent0-mcp 0.1.0

package/tests/discovery.test.ts

@@ -0,0 +1,455 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { discoveryTools, handleDiscoveryTool } from "../src/tools/discovery.js";
+
+// Mock agent0-sdk so tests don't hit the real API
+vi.mock("agent0-sdk", () => {
+  const mockSearchAgents = vi.fn();
+  const mockGetAgent = vi.fn();
+  const mockGetReputationSummary = vi.fn();
+  const mockSearchFeedback = vi.fn();
+
+  return {
+    SDK: vi.fn().mockImplementation(() => ({
+      searchAgents: mockSearchAgents,
+      getAgent: mockGetAgent,
+      getReputationSummary: mockGetReputationSummary,
+      searchFeedback: mockSearchFeedback,
+    })),
+    __mocks: {
+      mockSearchAgents,
+      mockGetAgent,
+      mockGetReputationSummary,
+      mockSearchFeedback,
+    },
+  };
+});
+
+// Access mock functions
+async function getMocks() {
+  const mod = await import("agent0-sdk");
+  return (mod as unknown as { __mocks: Record<string, ReturnType<typeof vi.fn>> }).__mocks;
+}
+
+function makeAgent(overrides: Record<string, unknown> = {}) {
+  return {
+    agentId: "11155111:42",
+    chainId: 11155111,
+    name: "Test Agent",
+    description: "A test agent",
+    image: "https://example.com/img.png",
+    active: true,
+    x402support: false,
+    owners: ["0x1234567890abcdef1234567890abcdef12345678"],
+    walletAddress: "0x1234567890abcdef1234567890abcdef12345678",
+    mcp: null,
+    a2a: null,
+    web: null,
+    ens: null,
+    mcpTools: [],
+    a2aSkills: [],
+    oasfSkills: [],
+    oasfDomains: [],
+    supportedTrusts: [],
+    feedbackCount: 0,
+    averageValue: 0,
+    updatedAt: 1700000000,
+    ...overrides,
+  };
+}
+
+describe("discovery tools", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  // ===========================================================================
+  // Tool registration
+  // ===========================================================================
+  describe("tool registration", () => {
+    it("registers 6 discovery tools", () => {
+      expect(discoveryTools).toHaveLength(6);
+    });
+
+    const expectedTools = [
+      "search_agents",
+      "get_agent",
+      "get_supported_chains",
+      "get_platform_stats",
+      "get_reputation_summary",
+      "search_feedback",
+    ];
+
+    for (const toolName of expectedTools) {
+      it(`registers ${toolName}`, () => {
+        const tool = discoveryTools.find((t) => t.name === toolName);
+        expect(tool).toBeDefined();
+        expect(tool!.description).toBeTypeOf("string");
+        expect(tool!.description.length).toBeGreaterThan(10);
+        expect(tool!.inputSchema).toBeDefined();
+      });
+    }
+  });
+
+  // ===========================================================================
+  // search_agents
+  // ===========================================================================
+  describe("search_agents", () => {
+    it("returns formatted agents with trust labels", async () => {
+      const mocks = await getMocks();
+      mocks.mockSearchAgents.mockResolvedValue([
+        makeAgent({ feedbackCount: 25, averageValue: 90 }),
+      ]);
+
+      const result = (await handleDiscoveryTool("search_agents", {})) as {
+        count: number;
+        agents: Array<{ trust: string }>;
+      };
+
+      expect(result.count).toBe(1);
+      expect(result.agents[0].trust).toContain("Highly Trusted");
+    });
+
+    it("respects limit parameter", async () => {
+      const mocks = await getMocks();
+      const manyAgents = Array.from({ length: 50 }, (_, i) =>
+        makeAgent({ agentId: `11155111:${i}` }),
+      );
+      mocks.mockSearchAgents.mockResolvedValue(manyAgents);
+
+      const result = (await handleDiscoveryTool("search_agents", {
+        limit: 5,
+      })) as { count: number; totalAvailable: number };
+
+      expect(result.count).toBe(5);
+      expect(result.totalAvailable).toBe(50);
+    });
+
+    it("caps limit at 100", async () => {
+      const mocks = await getMocks();
+      const agents = Array.from({ length: 150 }, (_, i) =>
+        makeAgent({ agentId: `11155111:${i}` }),
+      );
+      mocks.mockSearchAgents.mockResolvedValue(agents);
+
+      const result = (await handleDiscoveryTool("search_agents", {
+        limit: 200,
+      })) as { count: number };
+
+      expect(result.count).toBe(100);
+    });
+
+    it("handles empty results", async () => {
+      const mocks = await getMocks();
+      mocks.mockSearchAgents.mockResolvedValue([]);
+
+      const result = (await handleDiscoveryTool("search_agents", {
+        name: "nonexistent",
+      })) as { count: number; agents: unknown[] };
+
+      expect(result.count).toBe(0);
+      expect(result.agents).toEqual([]);
+    });
+
+    it("passes filter parameters to SDK", async () => {
+      const mocks = await getMocks();
+      mocks.mockSearchAgents.mockResolvedValue([]);
+
+      await handleDiscoveryTool("search_agents", {
+        name: "defi",
+        active: true,
+        x402support: true,
+        hasMCP: true,
+      });
+
+      expect(mocks.mockSearchAgents).toHaveBeenCalledWith(
+        expect.objectContaining({
+          name: "defi",
+          active: true,
+          x402support: true,
+          hasMCP: true,
+        }),
+        expect.any(Object),
+      );
+    });
+  });
+
+  // ===========================================================================
+  // get_agent
+  // ===========================================================================
+  describe("get_agent", () => {
+    it("returns full agent profile with reputation", async () => {
+      const mocks = await getMocks();
+      mocks.mockGetAgent.mockResolvedValue(
+        makeAgent({ name: "DeFi Bot", feedbackCount: 10, averageValue: 75 }),
+      );
+      mocks.mockGetReputationSummary.mockResolvedValue({
+        count: 10,
+        averageValue: 75,
+      });
+
+      const result = (await handleDiscoveryTool("get_agent", {
+        agentId: "11155111:42",
+      })) as { name: string; reputation: { trustLabel: string }; chain: string };
+
+      expect(result.name).toBe("DeFi Bot");
+      expect(result.reputation.trustLabel).toBe("Trusted");
+      expect(result.chain).toContain("Chain"); // getChainName for 11155111 returns fallback
+    });
+
+    it("returns error for missing agentId", async () => {
+      const result = (await handleDiscoveryTool("get_agent", {})) as {
+        error: string;
+      };
+      expect(result.error).toContain("agentId is required");
+    });
+
+    it("returns error for invalid agentId format", async () => {
+      const result = (await handleDiscoveryTool("get_agent", {
+        agentId: "invalid",
+      })) as { error: string };
+      expect(result.error).toContain("Invalid agentId format");
+    });
+
+    it("returns error when agent not found", async () => {
+      const mocks = await getMocks();
+      mocks.mockGetAgent.mockResolvedValue(null);
+
+      const result = (await handleDiscoveryTool("get_agent", {
+        agentId: "11155111:99999",
+      })) as { error: string };
+      expect(result.error).toContain("not found");
+    });
+
+    it("handles reputation fetch failure gracefully", async () => {
+      const mocks = await getMocks();
+      mocks.mockGetAgent.mockResolvedValue(makeAgent());
+      mocks.mockGetReputationSummary.mockRejectedValue(
+        new Error("Reputation unavailable"),
+      );
+
+      const result = (await handleDiscoveryTool("get_agent", {
+        agentId: "11155111:42",
+      })) as { reputation: { count: number; averageValue: number } };
+
+      // Should still return agent with default reputation
+      expect(result.reputation.count).toBe(0);
+      expect(result.reputation.averageValue).toBe(0);
+    });
+  });
+
+  // ===========================================================================
+  // get_supported_chains
+  // ===========================================================================
+  describe("get_supported_chains", () => {
+    it("returns chain list with count", async () => {
+      const result = (await handleDiscoveryTool(
+        "get_supported_chains",
+        {},
+      )) as { count: number; chains: Array<{ chainId: number; name: string }> };
+
+      expect(result.count).toBeGreaterThan(0);
+      expect(result.chains.length).toBe(result.count);
+    });
+
+    it("includes Ethereum Mainnet and Base", async () => {
+      const result = (await handleDiscoveryTool(
+        "get_supported_chains",
+        {},
+      )) as { chains: Array<{ chainId: number }> };
+
+      const chainIds = result.chains.map((c) => c.chainId);
+      expect(chainIds).toContain(1);
+      expect(chainIds).toContain(8453);
+    });
+
+    it("each chain has required fields", async () => {
+      const result = (await handleDiscoveryTool(
+        "get_supported_chains",
+        {},
+      )) as {
+        chains: Array<{
+          chainId: number;
+          name: string;
+          identity: string;
+          reputation: string;
+          hasSubgraph: boolean;
+        }>;
+      };
+
+      for (const chain of result.chains) {
+        expect(chain.chainId).toBeTypeOf("number");
+        expect(chain.name).toBeTypeOf("string");
+        expect(chain.identity).toMatch(/^0x/);
+        expect(chain.reputation).toMatch(/^0x/);
+        expect(chain.hasSubgraph).toBeTypeOf("boolean");
+      }
+    });
+  });
+
+  // ===========================================================================
+  // get_platform_stats
+  // ===========================================================================
+  describe("get_platform_stats", () => {
+    it("returns aggregate stats", async () => {
+      const mocks = await getMocks();
+      mocks.mockSearchAgents.mockResolvedValue([
+        makeAgent({ active: true, mcp: "https://mcp.test", x402support: true }),
+        makeAgent({ active: false, a2a: "https://a2a.test", feedbackCount: 5 }),
+        makeAgent({ active: true }),
+      ]);
+
+      const result = (await handleDiscoveryTool("get_platform_stats", {})) as {
+        totalAgents: number;
+        activeAgents: number;
+        agentsWithMCP: number;
+        agentsWithA2A: number;
+        agentsWithX402: number;
+        agentsWithFeedback: number;
+      };
+
+      expect(result.totalAgents).toBe(3);
+      expect(result.activeAgents).toBe(2);
+      expect(result.agentsWithMCP).toBe(1);
+      expect(result.agentsWithA2A).toBe(1);
+      expect(result.agentsWithX402).toBe(1);
+      expect(result.agentsWithFeedback).toBe(1);
+    });
+
+    it("uses provided chainId", async () => {
+      const mocks = await getMocks();
+      mocks.mockSearchAgents.mockResolvedValue([]);
+      const { SDK } = await import("agent0-sdk");
+
+      await handleDiscoveryTool("get_platform_stats", { chainId: 8453 });
+
+      expect(SDK).toHaveBeenCalledWith(
+        expect.objectContaining({ chainId: 8453 }),
+      );
+    });
+  });
+
+  // ===========================================================================
+  // get_reputation_summary
+  // ===========================================================================
+  describe("get_reputation_summary", () => {
+    it("returns reputation with trust label", async () => {
+      const mocks = await getMocks();
+      mocks.mockGetReputationSummary.mockResolvedValue({
+        count: 15,
+        averageValue: 72,
+      });
+
+      const result = (await handleDiscoveryTool("get_reputation_summary", {
+        agentId: "11155111:42",
+      })) as { trustLabel: string; count: number; averageValue: number };
+
+      expect(result.count).toBe(15);
+      expect(result.averageValue).toBe(72);
+      expect(result.trustLabel).toBe("Trusted");
+    });
+
+    it("returns error for missing agentId", async () => {
+      const result = (await handleDiscoveryTool(
+        "get_reputation_summary",
+        {},
+      )) as { error: string };
+      expect(result.error).toContain("agentId is required");
+    });
+
+    it("returns error for invalid format", async () => {
+      const result = (await handleDiscoveryTool("get_reputation_summary", {
+        agentId: "bad-format",
+      })) as { error: string };
+      expect(result.error).toContain("Invalid agentId format");
+    });
+
+    it("passes tag to SDK", async () => {
+      const mocks = await getMocks();
+      mocks.mockGetReputationSummary.mockResolvedValue({
+        count: 0,
+        averageValue: 0,
+      });
+
+      await handleDiscoveryTool("get_reputation_summary", {
+        agentId: "11155111:42",
+        tag: "quality",
+      });
+
+      expect(mocks.mockGetReputationSummary).toHaveBeenCalledWith(
+        "11155111:42",
+        "quality",
+      );
+    });
+  });
+
+  // ===========================================================================
+  // search_feedback
+  // ===========================================================================
+  describe("search_feedback", () => {
+    it("returns formatted feedback entries", async () => {
+      const mocks = await getMocks();
+      mocks.mockSearchFeedback.mockResolvedValue([
+        {
+          agentId: "11155111:42",
+          reviewer: "0xabc",
+          value: 85,
+          tags: ["quality"],
+          text: "Great agent",
+          endpoint: "mcp",
+          isRevoked: false,
+          createdAt: 1700000000,
+          mcpTool: "search",
+          a2aSkills: [],
+        },
+      ]);
+
+      const result = (await handleDiscoveryTool("search_feedback", {
+        agentId: "11155111:42",
+      })) as { count: number; feedbacks: Array<{ value: number }> };
+
+      expect(result.count).toBe(1);
+      expect(result.feedbacks[0].value).toBe(85);
+    });
+
+    it("returns error when no agent specified", async () => {
+      const result = (await handleDiscoveryTool("search_feedback", {})) as {
+        error: string;
+      };
+      expect(result.error).toContain("Provide agentId or agents[]");
+    });
+
+    it("caps results at 50", async () => {
+      const mocks = await getMocks();
+      const manyFeedbacks = Array.from({ length: 60 }, (_, i) => ({
+        agentId: "11155111:42",
+        reviewer: `0x${i}`,
+        value: 50,
+        tags: [],
+        text: "",
+        endpoint: null,
+        isRevoked: false,
+        createdAt: 1700000000,
+        mcpTool: null,
+        a2aSkills: [],
+      }));
+      mocks.mockSearchFeedback.mockResolvedValue(manyFeedbacks);
+
+      const result = (await handleDiscoveryTool("search_feedback", {
+        agentId: "11155111:42",
+      })) as { count: number; feedbacks: unknown[] };
+
+      expect(result.count).toBe(60);
+      expect(result.feedbacks).toHaveLength(50);
+    });
+  });
+
+  // ===========================================================================
+  // Unknown tool
+  // ===========================================================================
+  it("returns error for unknown tool name", async () => {
+    const result = (await handleDiscoveryTool("nonexistent", {})) as {
+      error: string;
+    };
+    expect(result.error).toContain("Unknown discovery tool");
+  });
+});

package/tests/e2e.test.ts

@@ -0,0 +1,234 @@
+/**
+ * Integration tests against live 8004scan / agent0-sdk API.
+ *
+ * Run with: LIVE_TESTS=1 npx vitest run tests/e2e.test.ts
+ *
+ * These tests call the real agent0-sdk which hits the 8004scan subgraph.
+ * They are slow (~5-15s each) and require network access.
+ * Set EIGHTSCAN_API_KEY to avoid rate limits.
+ */
+import { describe, it, expect } from "vitest";
+import { handleDiscoveryTool } from "../src/tools/discovery.js";
+
+const LIVE = !!process.env.LIVE_TESTS;
+
+describe.skipIf(!LIVE)("e2e: live agent0-sdk via discovery tools", () => {
+  it(
+    "search_agents: returns agents on default chain (Sepolia)",
+    async () => {
+      const result = (await handleDiscoveryTool("search_agents", {
+        limit: 5,
+      })) as {
+        count: number;
+        totalAvailable: number;
+        chainId: number;
+        agents: Array<{
+          agentId: string;
+          name: string;
+          trust: string;
+        }>;
+      };
+
+      expect(result.count).toBeGreaterThan(0);
+      expect(result.count).toBeLessThanOrEqual(5);
+      expect(result.totalAvailable).toBeGreaterThan(0);
+
+      // Each agent should have required fields
+      for (const agent of result.agents) {
+        expect(agent.agentId).toBeTypeOf("string");
+        expect(agent.agentId).toContain(":");
+        expect(agent.name).toBeTypeOf("string");
+        expect(agent.trust).toBeTypeOf("string");
+      }
+    },
+    30_000,
+  );
+
+  it(
+    "search_agents: name filter returns matching results",
+    async () => {
+      const result = (await handleDiscoveryTool("search_agents", {
+        name: "test",
+        limit: 10,
+      })) as {
+        count: number;
+        agents: Array<{ name: string }>;
+      };
+
+      // May return 0 if no agents match, but should not error
+      expect(result.count).toBeGreaterThanOrEqual(0);
+      expect(Array.isArray(result.agents)).toBe(true);
+    },
+    30_000,
+  );
+
+  it(
+    "get_agent: returns a known agent profile",
+    async () => {
+      // First search to find a real agent ID
+      const searchResult = (await handleDiscoveryTool("search_agents", {
+        limit: 1,
+      })) as {
+        agents: Array<{ agentId: string }>;
+      };
+
+      expect(searchResult.agents.length).toBeGreaterThan(0);
+      const agentId = searchResult.agents[0].agentId;
+
+      const result = (await handleDiscoveryTool("get_agent", {
+        agentId,
+      })) as {
+        agentId: string;
+        name: string;
+        reputation: {
+          count: number;
+          averageValue: number;
+          trustLabel: string;
+          trustDisplay: string;
+        };
+        chain: string;
+      };
+
+      expect(result.agentId).toBe(agentId);
+      expect(result.name).toBeTypeOf("string");
+      expect(result.reputation).toBeDefined();
+      expect(result.reputation.trustLabel).toBeTypeOf("string");
+      expect(result.chain).toBeTypeOf("string");
+    },
+    30_000,
+  );
+
+  it(
+    "get_agent: returns error for nonexistent agent",
+    async () => {
+      const result = (await handleDiscoveryTool("get_agent", {
+        agentId: "11155111:999999999",
+      })) as { error?: string };
+
+      expect(result.error).toBeDefined();
+      expect(result.error).toContain("not found");
+    },
+    30_000,
+  );
+
+  it(
+    "get_supported_chains: returns chain list with contract addresses",
+    async () => {
+      const result = (await handleDiscoveryTool(
+        "get_supported_chains",
+        {},
+      )) as {
+        count: number;
+        chains: Array<{
+          chainId: number;
+          name: string;
+          identity: string;
+          reputation: string;
+          hasSubgraph: boolean;
+        }>;
+        note: string;
+      };
+
+      expect(result.count).toBeGreaterThanOrEqual(3);
+      expect(result.chains.length).toBe(result.count);
+
+      // Verify known chains are present
+      const chainIds = result.chains.map((c) => c.chainId);
+      expect(chainIds).toContain(1); // Ethereum
+      expect(chainIds).toContain(8453); // Base
+      expect(chainIds).toContain(11155111); // Sepolia
+
+      // Each chain has contract addresses
+      for (const chain of result.chains) {
+        expect(chain.identity).toMatch(/^0x[0-9a-fA-F]{40}$/);
+        expect(chain.reputation).toMatch(/^0x[0-9a-fA-F]{40}$/);
+      }
+    },
+    15_000,
+  );
+
+  it(
+    "get_platform_stats: returns aggregate stats for Sepolia",
+    async () => {
+      const result = (await handleDiscoveryTool("get_platform_stats", {
+        chainId: 11155111,
+      })) as {
+        chainId: number;
+        chain: string;
+        totalAgents: number;
+        activeAgents: number;
+        agentsWithMCP: number;
+        agentsWithA2A: number;
+        agentsWithX402: number;
+        totalMCPTools: number;
+      };
+
+      expect(result.chainId).toBe(11155111);
+      expect(result.totalAgents).toBeGreaterThan(0);
+      expect(result.activeAgents).toBeGreaterThanOrEqual(0);
+      expect(result.activeAgents).toBeLessThanOrEqual(result.totalAgents);
+    },
+    30_000,
+  );
+
+  it(
+    "get_reputation_summary: returns trust label for an agent",
+    async () => {
+      // Find a real agent first
+      const searchResult = (await handleDiscoveryTool("search_agents", {
+        limit: 1,
+      })) as { agents: Array<{ agentId: string }> };
+      const agentId = searchResult.agents[0].agentId;
+
+      const result = (await handleDiscoveryTool("get_reputation_summary", {
+        agentId,
+      })) as {
+        agentId: string;
+        count: number;
+        averageValue: number;
+        trustLabel: string;
+        trustEmoji: string;
+        trustDisplay: string;
+      };
+
+      expect(result.agentId).toBe(agentId);
+      expect(result.count).toBeGreaterThanOrEqual(0);
+      expect(result.trustLabel).toBeTypeOf("string");
+      expect(result.trustEmoji).toBeTypeOf("string");
+    },
+    30_000,
+  );
+
+  it(
+    "search_feedback: returns feedback entries (may be empty)",
+    async () => {
+      // Find a real agent first
+      const searchResult = (await handleDiscoveryTool("search_agents", {
+        limit: 1,
+      })) as { agents: Array<{ agentId: string }> };
+      const agentId = searchResult.agents[0].agentId;
+
+      const result = (await handleDiscoveryTool("search_feedback", {
+        agentId,
+      })) as {
+        count: number;
+        feedbacks: Array<{
+          agentId: string;
+          reviewer: string;
+          value: number;
+        }>;
+      };
+
+      expect(result.count).toBeGreaterThanOrEqual(0);
+      expect(Array.isArray(result.feedbacks)).toBe(true);
+
+      // If any feedback exists, verify shape
+      if (result.feedbacks.length > 0) {
+        const fb = result.feedbacks[0];
+        expect(fb.agentId).toBeTypeOf("string");
+        expect(fb.value).toBeTypeOf("number");
+      }
+    },
+    30_000,
+  );
+});