@hivemind-os/collective-mcp-server 0.2.0

package/tests/discover.test.ts

@@ -0,0 +1,207 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import { PaymentRail, type AgentCard } from '@hivemind-os/collective-types';
+
+import type { MeshToolContext } from '../src/context.js';
+import { runMeshDiscover } from '../src/tools/discover.js';
+
+function createAgent(overrides: Partial<AgentCard> = {}): AgentCard {
+  return {
+    id: '0xagent-1',
+    owner: '0xowner-1',
+    did: 'did:mesh:agent-1' as AgentCard['did'],
+    name: 'Summarizer',
+    description: 'Summarizes text',
+    capabilities: [
+      {
+        name: 'summarize',
+        description: 'Summarize documents',
+        version: '1.0.0',
+        pricing: {
+          rail: PaymentRail.SUI_ESCROW,
+          amount: 100n,
+          currency: 'MIST',
+        },
+      },
+    ],
+    endpoint: 'mesh://agent/did:mesh:agent-1',
+    active: true,
+    version: 1,
+    registeredAt: 1_000,
+    updatedAt: 1_000,
+    ...overrides,
+  };
+}
+
+function createContext(overrides: Partial<MeshToolContext> = {}): MeshToolContext {
+  return {
+    did: 'did:mesh:test' as MeshToolContext['did'],
+    keypair: {} as MeshToolContext['keypair'],
+    suiClient: {
+      getBalance: vi.fn(),
+      queryEvents: vi.fn(),
+    } as unknown as MeshToolContext['suiClient'],
+    registryClient: {
+      discoverByCapability: vi.fn().mockResolvedValue([]),
+      getAgentCard: vi.fn(),
+    } as unknown as MeshToolContext['registryClient'],
+    taskClient: {} as MeshToolContext['taskClient'],
+    agentCache: {
+      searchByCapability: vi.fn().mockReturnValue([]),
+      getAgentByDID: vi.fn(),
+      getAllActive: vi.fn().mockReturnValue([]),
+      upsertAgent: vi.fn(),
+      removeAgent: vi.fn(),
+    } as unknown as MeshToolContext['agentCache'],
+    blobStore: {} as MeshToolContext['blobStore'],
+    spendingPolicy: {} as MeshToolContext['spendingPolicy'],
+    networkConfig: {
+      rpcUrl: 'http://127.0.0.1:9000',
+      faucetUrl: 'http://127.0.0.1:9123',
+      packageId: '0x1',
+      registryId: '0x2',
+    },
+    ...overrides,
+  };
+}
+
+describe('runMeshDiscover', () => {
+  it('returns matching agents from cache', async () => {
+    const agent = createAgent();
+    const context = createContext({
+      agentCache: {
+        searchByCapability: vi.fn().mockReturnValue([agent]),
+        getAgentByDID: vi.fn(),
+        getAllActive: vi.fn().mockReturnValue([agent]),
+        upsertAgent: vi.fn(),
+        removeAgent: vi.fn(),
+      } as unknown as MeshToolContext['agentCache'],
+    });
+
+    const result = await runMeshDiscover({ capability: 'summarize' }, context);
+
+    expect(result.source).toBe('cache');
+    expect(result.agents).toHaveLength(1);
+    expect(result.agents[0]).toMatchObject({ name: 'Summarizer', did: 'did:mesh:agent-1' });
+    expect(result.agents[0].reputation.total_tasks).toBe(0);
+    expect(context.registryClient.discoverByCapability).not.toHaveBeenCalled();
+  });
+
+  it('uses the indexer when configured', async () => {
+    const context = createContext({
+      indexer: {
+        graphqlUrl: 'http://localhost:4000/graphql',
+        fetch: vi.fn().mockResolvedValue({
+          ok: true,
+          json: async () => ({
+            data: {
+              agents: {
+                nodes: [
+                  {
+                    id: '0xagent-1',
+                    owner: '0xowner-1',
+                    did: 'did:mesh:agent-1',
+                    name: 'Summarizer',
+                    description: 'Summarizes text',
+                    endpoint: 'mesh://agent/did:mesh:agent-1',
+                    active: true,
+                    version: 1,
+                    registeredAt: '1000',
+                    updatedAt: '1000',
+                    totalTasksCompleted: 5,
+                    totalTasksFailed: 1,
+                    totalTasksDisputed: 0,
+                    totalEarningsMist: '1000',
+                    hasStake: true,
+                    stakeMist: '100',
+                    stakeType: 'agent',
+                    capabilities: [
+                      {
+                        name: 'summarize',
+                        description: 'Summarize documents',
+                        version: '1.0.0',
+                        executionMode: 'sync',
+                        paymentRails: ['sui-escrow'],
+                        pricing: { rail: 'sui-escrow', amount: '100', currency: 'MIST' },
+                      },
+                    ],
+                  },
+                ],
+              },
+            },
+          }),
+        }) as unknown as typeof fetch,
+      },
+    });
+
+    const result = await runMeshDiscover({ capability: 'summarize' }, context);
+
+    expect(result.source).toBe('indexer');
+    expect(result.agents[0]?.reputation.total_tasks).toBe(6);
+    expect(context.registryClient.discoverByCapability).not.toHaveBeenCalled();
+  });
+
+  it('falls back to sui discovery when cache is empty', async () => {
+    const agent = createAgent();
+    const context = createContext({
+      registryClient: {
+        discoverByCapability: vi.fn().mockResolvedValue([agent]),
+        getAgentCard: vi.fn(),
+      } as unknown as MeshToolContext['registryClient'],
+    });
+
+    const result = await runMeshDiscover({ capability: 'summarize' }, context);
+
+    expect(result.source).toBe('registry');
+    expect(result.agents).toHaveLength(1);
+    expect(context.registryClient.discoverByCapability).toHaveBeenCalledWith('summarize', 10, { sortByReputation: false });
+    expect(context.agentCache.upsertAgent).toHaveBeenCalledWith(agent);
+  });
+
+  it('sorts by reputation when requested', async () => {
+    const stronger = createAgent({ totalTasksCompleted: 10, totalTasksFailed: 1 });
+    const weaker = createAgent({ id: '0xagent-2', did: 'did:mesh:agent-2' as AgentCard['did'], totalTasksCompleted: 1, totalTasksFailed: 3 });
+    const context = createContext({
+      agentCache: {
+        searchByCapability: vi.fn().mockImplementation((_capability, _limit, options?: { sortByReputation?: boolean }) => (
+          options?.sortByReputation ? [stronger, weaker] : [weaker, stronger]
+        )),
+        getAgentByDID: vi.fn(),
+        getAllActive: vi.fn().mockReturnValue([weaker, stronger]),
+        upsertAgent: vi.fn(),
+        removeAgent: vi.fn(),
+      } as unknown as MeshToolContext['agentCache'],
+    });
+
+    const result = await runMeshDiscover({ capability: 'summarize', sort_by: 'reputation' }, context);
+
+    expect(result.agents.map((agent) => agent.did)).toEqual([stronger.did, weaker.did]);
+  });
+
+  it('respects the limit parameter', async () => {
+    const context = createContext({
+      agentCache: {
+        searchByCapability: vi.fn().mockReturnValue([
+          createAgent(),
+          createAgent({ id: '0xagent-2', did: 'did:mesh:agent-2' as AgentCard['did'] }),
+        ]),
+        getAgentByDID: vi.fn(),
+        getAllActive: vi.fn().mockReturnValue([]),
+        upsertAgent: vi.fn(),
+        removeAgent: vi.fn(),
+      } as unknown as MeshToolContext['agentCache'],
+    });
+
+    const result = await runMeshDiscover({ capability: 'summarize', limit: 1 }, context);
+
+    expect(result.agents).toHaveLength(1);
+  });
+
+  it('returns an empty array when no matches exist', async () => {
+    const context = createContext();
+
+    const result = await runMeshDiscover({ capability: 'summarize' }, context);
+
+    expect(result.agents).toEqual([]);
+  });
+});

package/tests/dispute.test.ts

@@ -0,0 +1,140 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import { DisputeStatus } from '@hivemind-os/collective-types';
+
+import type { MeshToolContext } from '../src/context.js';
+import { runMeshDispute } from '../src/tools/dispute.js';
+
+function createContext(overrides: Partial<MeshToolContext> = {}): MeshToolContext {
+  return {
+    did: 'did:mesh:test' as MeshToolContext['did'],
+    keypair: {
+      getPublicKey: () => ({
+        toSuiAddress: () => '0xabc',
+      }),
+    } as MeshToolContext['keypair'],
+    suiClient: {
+      getBalance: vi.fn(),
+      queryEvents: vi.fn(),
+    } as unknown as MeshToolContext['suiClient'],
+    registryClient: {} as MeshToolContext['registryClient'],
+    taskClient: {} as MeshToolContext['taskClient'],
+    agentCache: {} as MeshToolContext['agentCache'],
+    blobStore: {
+      store: vi.fn(async () => ({ blobId: 'walrus:evidence' })),
+      fetch: vi.fn(),
+      exists: vi.fn(),
+      delete: vi.fn(),
+    } as unknown as MeshToolContext['blobStore'],
+    spendingPolicy: {} as MeshToolContext['spendingPolicy'],
+    networkConfig: {
+      rpcUrl: 'http://127.0.0.1:9000',
+      faucetUrl: 'http://127.0.0.1:9123',
+      packageId: '0x1',
+      registryId: '0x2',
+    },
+    disputeClient: {
+      openDispute: vi.fn(),
+      respondToDispute: vi.fn(),
+      acceptResolution: vi.fn(),
+      getDispute: vi.fn(),
+      getDisputeByTask: vi.fn(),
+    } as unknown as MeshToolContext['disputeClient'],
+    ...overrides,
+  };
+}
+
+describe('runMeshDispute', () => {
+  it('opens disputes and stores evidence first', async () => {
+    const context = createContext();
+    vi.mocked(context.disputeClient?.openDispute as never).mockResolvedValue({ disputeId: '0xdispute', txDigest: '0xtx' });
+
+    const result = await runMeshDispute({
+      action: 'open',
+      task_id: '0x3',
+      evidence: '{"reason":"bad output"}',
+      proposed_split_mist: '500',
+    }, context);
+
+    expect(context.blobStore.store).toHaveBeenCalledOnce();
+    expect(context.disputeClient?.openDispute).toHaveBeenCalledWith({
+      taskId: '0x3',
+      evidenceBlobId: 'walrus:evidence',
+      proposedSplitMist: 500n,
+      arbitratorAddress: undefined,
+      signer: context.keypair,
+    });
+    expect(result).toMatchObject({ action: 'open', dispute_id: '0xdispute', tx_digest: '0xtx' });
+  });
+
+  it('responds and accepts disputes', async () => {
+    const context = createContext();
+    vi.mocked(context.disputeClient?.respondToDispute as never).mockResolvedValue({ txDigest: '0xrespond' });
+    vi.mocked(context.disputeClient?.acceptResolution as never).mockResolvedValue({
+      requesterAmount: 250n,
+      providerAmount: 750n,
+      txDigest: '0xaccept',
+    });
+
+    await expect(runMeshDispute({
+      action: 'respond',
+      dispute_id: '0x4',
+      evidence_blob_id: 'walrus:reply',
+      proposed_split_mist: '250',
+    }, context)).resolves.toMatchObject({ action: 'respond', tx_digest: '0xrespond' });
+
+    await expect(runMeshDispute({
+      action: 'accept',
+      dispute_id: '0x4',
+      task_id: '0x3',
+    }, context)).resolves.toMatchObject({
+      action: 'accept',
+      requester_amount_mist: '250',
+      provider_amount_mist: '750',
+      tx_digest: '0xaccept',
+    });
+  });
+
+  it('rejects ambiguous status requests and conflicting evidence sources', async () => {
+    const context = createContext();
+
+    await expect(runMeshDispute({ action: 'status' }, context)).rejects.toThrow(
+      'Provide exactly one of dispute_id or task_id when action=status',
+    );
+
+    await expect(runMeshDispute({
+      action: 'open',
+      task_id: '0x3',
+      evidence: 'inline',
+      evidence_blob_id: 'walrus:evidence',
+      proposed_split_mist: '500',
+    }, context)).rejects.toThrow('Provide exactly one of evidence or evidence_blob_id for dispute open/respond actions');
+  });
+
+  it('returns dispute status by task id', async () => {
+    const context = createContext();
+    vi.mocked(context.disputeClient?.getDisputeByTask as never).mockResolvedValue({
+      id: '0xdispute',
+      taskId: '0x3',
+      requester: '0xrequester',
+      provider: '0xprovider',
+      escrowAmount: 1_000n,
+      status: DisputeStatus.OPEN,
+      requesterEvidenceBlob: 'walrus:req',
+      providerEvidenceBlob: undefined,
+      requesterProposedSplit: 500n,
+      providerProposedSplit: 0n,
+      arbitrator: undefined,
+      rulingSplit: 0n,
+      openedAt: 100,
+      respondedAt: undefined,
+      resolvedAt: undefined,
+      resolutionDeadline: 200,
+    });
+
+    const result = await runMeshDispute({ action: 'status', task_id: '0x3' }, context);
+
+    expect(context.disputeClient?.getDisputeByTask).toHaveBeenCalledWith('0x3');
+    expect(result).toMatchObject({ action: 'status', dispute: { id: '0xdispute', taskId: '0x3' } });
+  });
+});

package/tests/execute.test.ts

@@ -0,0 +1,150 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import { PaymentRail, TaskStatus, type AgentCard } from '@hivemind-os/collective-types';
+
+const relayExecuteMock = vi.fn();
+
+vi.mock('@hivemind-os/collective-core', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('@hivemind-os/collective-core')>();
+  return {
+    ...actual,
+    PaymentRailSelector: class {
+      selectRail() {
+        return 'x402-base';
+      }
+    },
+    RelayConsumerClient: class {
+      async executeSync(...args: unknown[]) {
+        return relayExecuteMock(...args);
+      }
+    },
+  };
+});
+
+import { runMeshExecute } from '../src/tools/execute.js';
+
+function createAgent(): AgentCard {
+  return {
+    id: 'agent-1',
+    owner: 'owner',
+    did: 'did:mesh:provider' as AgentCard['did'],
+    name: 'Provider',
+    description: 'Test provider',
+    active: true,
+    version: 1,
+    registeredAt: Date.now(),
+    updatedAt: Date.now(),
+    endpoint: 'mesh://agent/provider',
+    relayEndpoints: [{ endpoint: 'https://relay.example', modes: ['sync', 'fallback'] }],
+    capabilities: [
+      {
+        name: 'echo',
+        description: 'Echo capability',
+        version: '1.0.0',
+        pricing: {
+          rail: PaymentRail.SUI_ESCROW,
+          amount: 5n,
+          currency: 'MIST',
+        },
+        executionMode: 'sync',
+        paymentRails: [PaymentRail.X402_BASE, PaymentRail.SUI_TRANSFER, PaymentRail.SUI_ESCROW],
+      },
+    ],
+  };
+}
+
+function createContext(agent: AgentCard) {
+  return {
+    keypair: {} as never,
+    blobStore: {
+      store: vi.fn(async () => ({ blobId: 'blob-in' })),
+      fetch: vi.fn(async () => new TextEncoder().encode('async-result')),
+    },
+    taskClient: {
+      postTask: vi.fn(async () => ({ taskId: 'task-1' })),
+      getTask: vi.fn(async () => ({ status: TaskStatus.COMPLETED, resultBlobId: 'blob-out' })),
+      releasePayment: vi.fn(async () => undefined),
+    },
+    agentCache: {
+      searchByCapability: vi.fn(() => [agent]),
+      getAgentByDID: vi.fn((did: string) => (did === agent.did ? agent : undefined)),
+      upsertAgent: vi.fn(),
+    },
+    registryClient: {
+      discoverByCapability: vi.fn(async () => []),
+      getAgentCardByOwner: vi.fn(async () => null),
+    },
+    meshClient: {} as never,
+    spendingPolicy: {
+      evaluate: vi.fn(() => ({ approved: true })),
+      record: vi.fn(),
+    },
+    networkConfig: {} as never,
+    encryption: undefined as { enabled: boolean; requireEncryption: boolean; publicKey?: string } | undefined,
+    relayAuthProvider: {} as never,
+    x402Client: {} as never,
+    logger: {
+      warn: vi.fn(),
+    },
+  };
+}
+
+describe('runMeshExecute', () => {
+  it('returns relay sync results when relay execution succeeds', async () => {
+    relayExecuteMock.mockResolvedValueOnce({
+      result: { ok: true },
+      paymentReceipt: 'receipt-1',
+      latencyMs: 12,
+      taskId: 'relay-task-1',
+      providerDid: 'did:mesh:provider',
+    });
+    const agent = createAgent();
+    const context = createContext(agent);
+
+    const result = await runMeshExecute({ capability: 'echo', input: 'hello', mode: 'sync' }, context as never);
+
+    expect(result.execution_mode).toBe('sync');
+    expect(result.task_id).toBe('relay-task-1');
+    expect(result.result).toBe(JSON.stringify({ ok: true }));
+    expect(result.payment_rail).toBe(PaymentRail.X402_BASE);
+    expect(context.taskClient.postTask).not.toHaveBeenCalled();
+  });
+
+  it('falls back to async execution when relay sync is unavailable', async () => {
+    relayExecuteMock.mockRejectedValueOnce(new Error('fetch failed'));
+    const agent = createAgent();
+    const context = createContext(agent);
+
+    const result = await runMeshExecute({ capability: 'echo', input: 'hello' }, context as never);
+
+    expect(result.execution_mode).toBe('async');
+    expect(result.task_id).toBe('task-1');
+    expect(result.result).toBe('async-result');
+    expect(result.payment_rail).toBe(PaymentRail.SUI_ESCROW);
+    expect(context.taskClient.postTask).toHaveBeenCalledOnce();
+    expect(context.taskClient.releasePayment).toHaveBeenCalledOnce();
+    expect(context.logger.warn).toHaveBeenCalledOnce();
+  });
+
+  it('stores encrypted input blobs when the provider publishes an encryption key', async () => {
+    relayExecuteMock.mockRejectedValueOnce(new Error('fetch failed'));
+    const agent = {
+      ...createAgent(),
+      encryptionPublicKey: '000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f',
+    };
+    const context = createContext(agent);
+    const storeEncrypted = vi.fn(async () => ({ blobId: 'encrypted-blob', hash: 'hash-1' }));
+    const fetchDecrypted = vi.fn(async () => new TextEncoder().encode('async-result'));
+    context.blobStore = {
+      ...context.blobStore,
+      storeEncrypted,
+      fetchDecrypted,
+    };
+    context.encryption = { enabled: true, requireEncryption: false };
+
+    await runMeshExecute({ capability: 'echo', input: 'hello' }, context as never);
+
+    expect(storeEncrypted).toHaveBeenCalledOnce();
+    expect(context.taskClient.postTask).toHaveBeenCalledWith(expect.objectContaining({ inputBlobId: 'encrypted-blob' }));
+  });
+});

package/tests/marketplace.test.ts

@@ -0,0 +1,117 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import type { MeshToolContext } from '../src/context.js';
+import { runMeshMarketplaceAcceptBid } from '../src/tools/marketplace-accept-bid.js';
+import { runMeshMarketplaceBid } from '../src/tools/marketplace-bid.js';
+import { runMeshMarketplaceBrowse } from '../src/tools/marketplace-browse.js';
+import { runMeshMarketplacePost } from '../src/tools/marketplace-post.js';
+
+function createContext(overrides: Partial<MeshToolContext> = {}): MeshToolContext {
+  return {
+    did: 'did:mesh:test' as MeshToolContext['did'],
+    keypair: {
+      getPublicKey: () => ({
+        toSuiAddress: () => '0xabc',
+      }),
+    } as MeshToolContext['keypair'],
+    suiClient: {
+      getBalance: vi.fn(),
+      queryEvents: vi.fn(),
+    } as unknown as MeshToolContext['suiClient'],
+    registryClient: {} as MeshToolContext['registryClient'],
+    taskClient: {} as MeshToolContext['taskClient'],
+    agentCache: {} as MeshToolContext['agentCache'],
+    blobStore: {
+      store: vi.fn(async () => ({ blobId: 'walrus:input' })),
+      fetch: vi.fn(),
+      exists: vi.fn(),
+      delete: vi.fn(),
+    } as unknown as MeshToolContext['blobStore'],
+    spendingPolicy: {} as MeshToolContext['spendingPolicy'],
+    networkConfig: {
+      rpcUrl: 'http://127.0.0.1:9000',
+      faucetUrl: 'http://127.0.0.1:9123',
+      packageId: '0x1',
+      registryId: '0x2',
+    },
+    marketplaceClient: {
+      postOpenTask: vi.fn(),
+      browseOpenTasks: vi.fn(),
+      placeBid: vi.fn(),
+      acceptBid: vi.fn(),
+    } as unknown as MeshToolContext['marketplaceClient'],
+    ...overrides,
+  };
+}
+
+describe('marketplace MCP tools', () => {
+  it('posts marketplace tasks and uploads inline input', async () => {
+    const context = createContext();
+    vi.mocked(context.marketplaceClient?.postOpenTask as never).mockResolvedValue({ taskId: '0xtask', txDigest: '0xtx' });
+
+    const result = await runMeshMarketplacePost({
+      capability: 'summarize',
+      category: 'analysis',
+      price_mist: '500',
+      input: 'hello world',
+    }, context);
+
+    expect(context.blobStore.store).toHaveBeenCalledOnce();
+    expect(context.marketplaceClient?.postOpenTask).toHaveBeenCalledWith({
+      capability: 'summarize',
+      category: 'analysis',
+      inputBlobId: 'walrus:input',
+      agreementHash: undefined,
+      priceMist: 500n,
+      disputeWindowMs: 60_000,
+      expiryHours: 24,
+      signer: context.keypair,
+    });
+    expect(result).toMatchObject({ task_id: '0xtask', tx_digest: '0xtx' });
+  });
+
+  it('browses marketplace tasks with filters', async () => {
+    const context = createContext();
+    vi.mocked(context.marketplaceClient?.browseOpenTasks as never).mockResolvedValue([{ id: '0xtask', category: 'analysis' }]);
+
+    const result = await runMeshMarketplaceBrowse({ category: 'analysis', max_price_mist: '750', limit: 5 }, context);
+
+    expect(context.marketplaceClient?.browseOpenTasks).toHaveBeenCalledWith({
+      category: 'analysis',
+      minPriceMist: undefined,
+      maxPriceMist: 750n,
+      limit: 5,
+    });
+    expect(result).toMatchObject({ count: 1 });
+  });
+
+  it('rejects conflicting marketplace input sources', async () => {
+    const context = createContext();
+
+    await expect(runMeshMarketplacePost({
+      capability: 'summarize',
+      category: 'analysis',
+      price_mist: '500',
+      input: 'hello world',
+      input_blob_id: 'walrus:input',
+    }, context)).rejects.toThrow('Provide exactly one of input or input_blob_id when posting a marketplace task');
+  });
+
+  it('places and accepts bids', async () => {
+    const context = createContext();
+    vi.mocked(context.marketplaceClient?.placeBid as never).mockResolvedValue({ bidId: '0xbid', txDigest: '0xbidtx', reputationScore: 99n });
+    vi.mocked(context.marketplaceClient?.acceptBid as never).mockResolvedValue({ txDigest: '0xaccept', rejectedBidIds: ['0xbid-2'] });
+
+    await expect(runMeshMarketplaceBid({ task_id: '0xtask', bid_price_mist: '400', evidence: 'proposal' }, context)).resolves.toMatchObject({
+      bid_id: '0xbid',
+      tx_digest: '0xbidtx',
+      reputation_score: '99',
+    });
+
+    await expect(runMeshMarketplaceAcceptBid({ task_id: '0xtask', bid_id: '0xbid' }, context)).resolves.toMatchObject({
+      bid_id: '0xbid',
+      rejected_bid_ids: ['0xbid-2'],
+      tx_digest: '0xaccept',
+    });
+  });
+});