@blocks-network/mcp-server 0.1.62 → 0.1.65

package/tests/registry-list.test.ts

@@ -1,9 +1,12 @@
 import { describe, it, expect, vi } from 'vitest';
 import {
   listAgentsAuthenticated,
+  listAllAgentsAuthenticated,
+} from '../src/registry-list.js';
+import {
   PROTOCOL_VERSION_HEADER,
   CURRENT_PROTOCOL_VERSION,
-} from '../src/registry-list.js';
+} from '../src/protocol-headers.js';
 
 function mockResponse(body: unknown, ok = true, status = 200): Response {
   return {
@@ -57,7 +60,7 @@ describe('listAgentsAuthenticated', () => {
     await listAgentsAuthenticated({
       baseUrl: 'http://api.test/',
       listing: 'private',
-      skill: 'translate',
+      tag: 'translate',
       limit: 50,
       fetchImpl: fetchImpl as unknown as typeof fetch,
     });
@@ -68,7 +71,7 @@ describe('listAgentsAuthenticated', () => {
     expect(parsed.searchParams.get('include')).toBe('full');
     expect(parsed.searchParams.get('listing')).toBe('private');
     expect(parsed.searchParams.get('scope')).toBe('owned');
-    expect(parsed.searchParams.get('skill')).toBe('translate');
+    expect(parsed.searchParams.get('tag')).toBe('translate');
     expect(parsed.searchParams.get('limit')).toBe('50');
   });
 
@@ -104,7 +107,7 @@ describe('listAgentsAuthenticated', () => {
 
   it('returns parsed JSON body on success', async () => {
     const body = {
-      agents: [{ agentName: 'alice', skills: [] }],
+      agents: [{ agentName: 'alice', tags: [] }],
       totalCount: 1,
     };
     const fetchImpl = vi
@@ -117,4 +120,125 @@ describe('listAgentsAuthenticated', () => {
     });
     expect(result).toEqual(body);
   });
+
+  it('forwards the cursor query param when provided', async () => {
+    const fetchImpl = vi.fn().mockResolvedValue(
+      mockResponse({ agents: [], totalCount: 0 }),
+    );
+
+    await listAgentsAuthenticated({
+      baseUrl: 'http://api.test',
+      cursor: 'abc123',
+      fetchImpl: fetchImpl as unknown as typeof fetch,
+    });
+
+    const [url] = fetchImpl.mock.calls[0];
+    expect(new URL(String(url)).searchParams.get('cursor')).toBe('abc123');
+  });
+});
+
+describe('listAllAgentsAuthenticated', () => {
+  function agent(name: string) {
+    return { agentName: name, tags: [] };
+  }
+
+  it('follows the next cursor across pages and aggregates results', async () => {
+    const fetchImpl = vi
+      .fn()
+      .mockResolvedValueOnce(
+        mockResponse({
+          agents: [agent('a'), agent('b')],
+          next: 'c1',
+          totalCount: 5,
+          totalOnlineCount: 3,
+        }),
+      )
+      .mockResolvedValueOnce(
+        mockResponse({ agents: [agent('c'), agent('d')], next: 'c2' }),
+      )
+      .mockResolvedValueOnce(
+        mockResponse({ agents: [agent('e')], next: null }),
+      );
+
+    const result = await listAllAgentsAuthenticated({
+      baseUrl: 'http://api.test',
+      fetchImpl: fetchImpl as unknown as typeof fetch,
+    });
+
+    expect(result.agents.map((a) => a.agentName)).toEqual(['a', 'b', 'c', 'd', 'e']);
+    expect(result.totalCount).toBe(5);
+    expect(result.totalOnlineCount).toBe(3);
+    expect(fetchImpl).toHaveBeenCalledTimes(3);
+
+    // First request carries no cursor; follow-ups carry the prior page's next.
+    expect(new URL(String(fetchImpl.mock.calls[0][0])).searchParams.get('cursor')).toBeNull();
+    expect(new URL(String(fetchImpl.mock.calls[1][0])).searchParams.get('cursor')).toBe('c1');
+    expect(new URL(String(fetchImpl.mock.calls[2][0])).searchParams.get('cursor')).toBe('c2');
+  });
+
+  it('stops after a single page when next is absent', async () => {
+    const fetchImpl = vi.fn().mockResolvedValue(
+      mockResponse({ agents: [agent('a')], totalCount: 1 }),
+    );
+
+    const result = await listAllAgentsAuthenticated({
+      baseUrl: 'http://api.test',
+      fetchImpl: fetchImpl as unknown as typeof fetch,
+    });
+
+    expect(fetchImpl).toHaveBeenCalledOnce();
+    expect(result.agents.map((a) => a.agentName)).toEqual(['a']);
+  });
+
+  it('requests the max page size (limit=100) by default', async () => {
+    const fetchImpl = vi.fn().mockResolvedValue(
+      mockResponse({ agents: [], next: null }),
+    );
+
+    await listAllAgentsAuthenticated({
+      baseUrl: 'http://api.test',
+      fetchImpl: fetchImpl as unknown as typeof fetch,
+    });
+
+    expect(new URL(String(fetchImpl.mock.calls[0][0])).searchParams.get('limit')).toBe('100');
+  });
+
+  it('caps the total agents and shrinks the final page request', async () => {
+    const fetchImpl = vi
+      .fn()
+      .mockResolvedValueOnce(
+        mockResponse({ agents: [agent('a'), agent('b')], next: 'c1' }),
+      )
+      .mockResolvedValueOnce(
+        mockResponse({ agents: [agent('c'), agent('d')], next: 'c2' }),
+      );
+
+    const result = await listAllAgentsAuthenticated({
+      baseUrl: 'http://api.test',
+      maxAgents: 3,
+      fetchImpl: fetchImpl as unknown as typeof fetch,
+    });
+
+    expect(result.agents.map((a) => a.agentName)).toEqual(['a', 'b', 'c']);
+    // Two requests only. The cap bounds each page size: first page asks for
+    // min(100, 3)=3; after 2 returned, the second asks for the remaining 1.
+    expect(fetchImpl).toHaveBeenCalledTimes(2);
+    expect(new URL(String(fetchImpl.mock.calls[0][0])).searchParams.get('limit')).toBe('3');
+    expect(new URL(String(fetchImpl.mock.calls[1][0])).searchParams.get('limit')).toBe('1');
+  });
+
+  it('terminates when a backend returns a stuck non-null cursor', async () => {
+    const fetchImpl = vi.fn().mockResolvedValue(
+      mockResponse({ agents: [agent('a')], next: 'always' }),
+    );
+
+    const result = await listAllAgentsAuthenticated({
+      baseUrl: 'http://api.test',
+      fetchImpl: fetchImpl as unknown as typeof fetch,
+    });
+
+    // Bounded by the internal page guard rather than looping forever.
+    expect(fetchImpl).toHaveBeenCalledTimes(1000);
+    expect(result.agents).toHaveLength(1000);
+  });
 });

package/tests/search-agent.test.ts

@@ -0,0 +1,119 @@
+import { describe, it, expect } from 'vitest';
+import { searchAgents } from '../src/tools.js';
+import { makeFakeDeps } from './helpers.js';
+
+// A status response where every named agent has one online instance, so the
+// default online-only filter is a no-op for these agents.
+function allOnline(...names: string[]) {
+  const agents: Record<string, unknown> = {};
+  for (const name of names) {
+    agents[name] = { agentName: name, instances: [], onlineCount: 1, taskCount: 0 };
+  }
+  return { agents };
+}
+
+describe('search_agent', () => {
+  it('forwards the query to the registry helper as `q`', async () => {
+    const { deps, mocks } = makeFakeDeps({
+      apiKey: 'sk-test',
+      baseUrl: 'http://api.test',
+    });
+
+    await searchAgents(
+      { query: 'translate', tag: 'language', listing: 'private', limit: 25 },
+      deps,
+    );
+
+    expect(mocks.listAgents).toHaveBeenCalledWith({
+      baseUrl: 'http://api.test',
+      apiKey: 'sk-test',
+      q: 'translate',
+      tag: 'language',
+      listing: 'private',
+      maxAgents: 25,
+    });
+  });
+
+  it('renders matching agents with the query in the header', async () => {
+    const { deps } = makeFakeDeps({
+      listAgentsResult: {
+        agents: [
+          {
+            agentName: 'alice',
+            name: 'Alice',
+            listing: 'public',
+            tags: [{ id: 'translate', name: 'Translate' }],
+          },
+        ],
+        totalCount: 1,
+      },
+      agentStatusResult: allOnline('alice'),
+    });
+
+    const res = await searchAgents({ query: 'trans' }, deps);
+    const lines = res.content[0].text.split('\n');
+    expect(lines).toEqual([
+      'Agents matching "trans" (1 online of 1 total):',
+      'alice | Alice | public | Translate',
+    ]);
+  });
+
+  it('trims whitespace from the query before sending it', async () => {
+    const { deps, mocks } = makeFakeDeps();
+
+    await searchAgents({ query: '  hello  ' }, deps);
+
+    expect(mocks.listAgents).toHaveBeenCalledWith(
+      expect.objectContaining({ q: 'hello' }),
+    );
+  });
+
+  it('rejects an empty (or whitespace-only) query without calling the registry', async () => {
+    const { deps, mocks } = makeFakeDeps();
+
+    const res = await searchAgents({ query: '   ' }, deps);
+    expect(res.isError).toBe(true);
+    expect(res.content[0].text).toContain('must not be empty');
+    expect(mocks.listAgents).not.toHaveBeenCalled();
+  });
+
+  it('drops offline matches by default, keeping only online ones', async () => {
+    const { deps } = makeFakeDeps({
+      listAgentsResult: {
+        agents: [
+          { agentName: 'online', name: 'Online' },
+          { agentName: 'offline', name: 'Offline' },
+        ],
+        totalCount: 2,
+      },
+      agentStatusResult: {
+        agents: {
+          online: { agentName: 'online', instances: [], onlineCount: 1, taskCount: 0 },
+          offline: { agentName: 'offline', instances: [], onlineCount: 0, taskCount: 0 },
+        },
+      },
+    });
+
+    const res = await searchAgents({ query: 'foo' }, deps);
+    const lines = res.content[0].text.split('\n');
+    expect(lines).toEqual([
+      'Agents matching "foo" (1 online of 2 total):',
+      'online | Online | public | ',
+    ]);
+  });
+
+  it('includes offline matches and skips the status check when includeOffline is true', async () => {
+    const { deps, mocks } = makeFakeDeps({
+      listAgentsResult: {
+        agents: [{ agentName: 'online' }, { agentName: 'offline' }],
+        totalCount: 2,
+      },
+    });
+
+    const res = await searchAgents({ query: 'foo', includeOffline: true }, deps);
+    expect(res.content[0].text.split('\n')[0]).toBe(
+      'Agents matching "foo" (2 of 2 total):',
+    );
+    expect(mocks.fetchAgentStatus).not.toHaveBeenCalled();
+  });
+});

package/tests/task-lifecycle.test.ts

@@ -0,0 +1,64 @@
+import { describe, it, expect } from 'vitest';
+import { pauseTask, resumeTask, retryTask } from '../src/tools.js';
+import { makeFakeDeps, makeFakeClient } from './helpers.js';
+
+describe('pause_task', () => {
+  it('forwards taskId to client.pauseTask and confirms', async () => {
+    const client = makeFakeClient();
+    const { deps } = makeFakeDeps({ client });
+
+    const res = await pauseTask({ taskId: 't_1' }, deps);
+
+    expect(client.pauseTaskMock).toHaveBeenCalledWith('t_1');
+    expect(res.content[0].text).toBe('Task t_1 paused.');
+  });
+
+  it('propagates errors from pauseTask', async () => {
+    const client = makeFakeClient();
+    client.pauseTaskMock.mockRejectedValueOnce(new Error('already terminal'));
+    const { deps } = makeFakeDeps({ client });
+
+    await expect(pauseTask({ taskId: 't_err' }, deps)).rejects.toThrow('already terminal');
+  });
+});
+
+describe('resume_task', () => {
+  it('forwards taskId to client.resumeTask and confirms', async () => {
+    const client = makeFakeClient();
+    const { deps } = makeFakeDeps({ client });
+
+    const res = await resumeTask({ taskId: 't_2' }, deps);
+
+    expect(client.resumeTaskMock).toHaveBeenCalledWith('t_2');
+    expect(res.content[0].text).toBe('Task t_2 resumed.');
+  });
+
+  it('propagates errors from resumeTask', async () => {
+    const client = makeFakeClient();
+    client.resumeTaskMock.mockRejectedValueOnce(new Error('not paused'));
+    const { deps } = makeFakeDeps({ client });
+
+    await expect(resumeTask({ taskId: 't_err' }, deps)).rejects.toThrow('not paused');
+  });
+});
+
+describe('retry_task', () => {
+  it('forwards taskId to client.retryTask and confirms', async () => {
+    const client = makeFakeClient();
+    const { deps } = makeFakeDeps({ client });
+
+    const res = await retryTask({ taskId: 't_3' }, deps);
+
+    expect(client.retryTaskMock).toHaveBeenCalledWith('t_3');
+    expect(res.content[0].text).toBe('Task t_3 retry requested.');
+  });
+
+  it('propagates errors from retryTask', async () => {
+    const client = makeFakeClient();
+    client.retryTaskMock.mockRejectedValueOnce(new Error('not failed'));
+    const { deps } = makeFakeDeps({ client });
+
+    await expect(retryTask({ taskId: 't_err' }, deps)).rejects.toThrow('not failed');
+  });
+});
+