@blocks-network/mcp-server 0.1.62 → 0.1.64

package/tests/get-agent-status.test.ts

@@ -0,0 +1,108 @@
+import { describe, it, expect, vi } from 'vitest';
+import { getAgentStatus } from '../src/tools.js';
+import {
+  fetchAgentStatus,
+  type AgentStatusResponse,
+} from '../src/agent-status.js';
+import {
+  PROTOCOL_VERSION_HEADER,
+  CURRENT_PROTOCOL_VERSION,
+} from '../src/protocol-headers.js';
+import { makeFakeDeps } from './helpers.js';
+
+function mockResponse(body: unknown, ok = true, status = 200): Response {
+  return { ok, status, json: async () => body } as Response;
+}
+
+describe('get_agent_status (handler)', () => {
+  it('forwards baseUrl, apiKey and agentNames to fetchAgentStatus and emits JSON', async () => {
+    const result: AgentStatusResponse = {
+      agents: {
+        alice: {
+          agentName: 'alice',
+          instances: [],
+          onlineCount: 2,
+          totalActiveTasks: 1,
+          taskCount: 1,
+        },
+      },
+    };
+    const { deps, mocks } = makeFakeDeps({
+      apiKey: 'bk_test',
+      agentStatusResult: result,
+    });
+
+    const res = await getAgentStatus({ agentNames: ['alice'] }, deps);
+
+    expect(mocks.fetchAgentStatus).toHaveBeenCalledWith({
+      baseUrl: 'http://api.test',
+      apiKey: 'bk_test',
+      agentNames: ['alice'],
+    });
+    const parsed = JSON.parse(res.content[0].text);
+    expect(parsed.agents.alice.onlineCount).toBe(2);
+  });
+});
+
+describe('fetchAgentStatus (HTTP helper)', () => {
+  it('builds /api/v1/agent-status URL with agentNames csv and protocol header', async () => {
+    const fetchImpl = vi
+      .fn()
+      .mockResolvedValue(mockResponse({ agents: {} }));
+
+    await fetchAgentStatus({
+      baseUrl: 'http://api.test/',
+      agentNames: ['alice', 'bob'],
+      apiKey: 'bk_test',
+      fetchImpl: fetchImpl as unknown as typeof fetch,
+    });
+
+    const [url, init] = fetchImpl.mock.calls[0];
+    const parsed = new URL(String(url));
+    expect(parsed.pathname).toBe('/api/v1/agent-status');
+    expect(parsed.searchParams.get('agentNames')).toBe('alice,bob');
+    const headers = init?.headers as Record<string, string>;
+    expect(headers[PROTOCOL_VERSION_HEADER]).toBe(CURRENT_PROTOCOL_VERSION);
+    expect(headers['Authorization']).toBe('Bearer bk_test');
+  });
+
+  it('rejects empty input', async () => {
+    await expect(
+      fetchAgentStatus({
+        baseUrl: 'http://api.test',
+        agentNames: [],
+      }),
+    ).rejects.toThrow(/at least one/);
+  });
+
+  it('rejects more than 50 names', async () => {
+    const names = Array.from({ length: 51 }, (_, i) => `a${i}`);
+    await expect(
+      fetchAgentStatus({
+        baseUrl: 'http://api.test',
+        agentNames: names,
+      }),
+    ).rejects.toThrow(/at most 50/);
+  });
+
+  it('rejects names with invalid characters', async () => {
+    await expect(
+      fetchAgentStatus({
+        baseUrl: 'http://api.test',
+        agentNames: ['has-a-hyphen'],
+      }),
+    ).rejects.toThrow(/Invalid agent name/);
+  });
+
+  it('throws on non-OK responses', async () => {
+    const fetchImpl = vi.fn().mockResolvedValue(mockResponse({}, false, 500));
+
+    await expect(
+      fetchAgentStatus({
+        baseUrl: 'http://api.test',
+        agentNames: ['alice'],
+        fetchImpl: fetchImpl as unknown as typeof fetch,
+      }),
+    ).rejects.toThrow('HTTP 500');
+  });
+});

package/tests/helpers.ts

@@ -89,6 +89,9 @@ export interface FakeClientConfig {
 export function makeFakeClient(cfg: FakeClientConfig = {}): TaskClientLike & {
   sendMessageMock: ReturnType<typeof vi.fn>;
   cancelTaskMock: ReturnType<typeof vi.fn>;
+  pauseTaskMock: ReturnType<typeof vi.fn>;
+  resumeTaskMock: ReturnType<typeof vi.fn>;
+  retryTaskMock: ReturnType<typeof vi.fn>;
   connectMock: ReturnType<typeof vi.fn>;
   listTasksMock: ReturnType<typeof vi.fn>;
   getTaskMock: ReturnType<typeof vi.fn>;
@@ -97,6 +100,9 @@ export function makeFakeClient(cfg: FakeClientConfig = {}): TaskClientLike & {
   const sendMessageMock = vi.fn().mockResolvedValue(session);
   const connectMock = vi.fn().mockResolvedValue(session);
   const cancelTaskMock = vi.fn().mockResolvedValue(undefined);
+  const pauseTaskMock = vi.fn().mockResolvedValue(undefined);
+  const resumeTaskMock = vi.fn().mockResolvedValue(undefined);
+  const retryTaskMock = vi.fn().mockResolvedValue(undefined);
   const listTasksMock = vi.fn().mockResolvedValue(
     cfg.listResult ?? { tasks: [], totalCount: 0 },
   );
@@ -105,11 +111,17 @@ export function makeFakeClient(cfg: FakeClientConfig = {}): TaskClientLike & {
   return {
     sendMessage: sendMessageMock,
     cancelTask: cancelTaskMock,
+    pauseTask: pauseTaskMock,
+    resumeTask: resumeTaskMock,
+    retryTask: retryTaskMock,
     connect: connectMock,
     listTasks: listTasksMock,
     getTask: getTaskMock,
     sendMessageMock,
     cancelTaskMock,
+    pauseTaskMock,
+    resumeTaskMock,
+    retryTaskMock,
     connectMock,
     listTasksMock,
     getTaskMock,
@@ -119,9 +131,13 @@ export function makeFakeClient(cfg: FakeClientConfig = {}): TaskClientLike & {
 export interface FakeDepsOverrides {
   baseUrl?: string;
   apiKey?: string;
+  orgId?: string;
   client?: TaskClientLike;
   agentEntry?: AgentEntryLike | null;
   listAgentsResult?: ListAgentsResult;
+  agentStatusResult?: { agents: Record<string, unknown> };
+  balance?: Record<string, unknown>;
+  topUpSession?: Record<string, unknown>;
   maxUploadBytes?: number;
   fileSize?: number;
 }
@@ -130,36 +146,76 @@ export function makeFakeDeps(overrides: FakeDepsOverrides = {}) {
   const client = overrides.client ?? makeFakeClient();
   const getBaseUrl = vi.fn().mockResolvedValue(overrides.baseUrl ?? 'http://api.test');
   const getApiKey = vi.fn().mockReturnValue(overrides.apiKey);
+  const getOrgId = vi.fn().mockReturnValue(overrides.orgId);
   const getTaskClient = vi.fn().mockResolvedValue(client);
   const getAgentByName = vi.fn().mockResolvedValue(overrides.agentEntry ?? null);
   const listAgents = vi
     .fn()
     .mockResolvedValue(overrides.listAgentsResult ?? { agents: [], totalCount: 0 });
+  const fetchAgentStatus = vi
+    .fn<ToolDeps['fetchAgentStatus']>()
+    .mockResolvedValue(
+      (overrides.agentStatusResult ?? { agents: {} }) as Awaited<
+        ReturnType<ToolDeps['fetchAgentStatus']>
+      >,
+    );
+  const getConsumerBalance = vi
+    .fn<ToolDeps['getConsumerBalance']>()
+    .mockResolvedValue(
+      (overrides.balance ?? {
+        balance: '0',
+        reservedBalance: '0',
+        availableBalance: '0',
+        updatedAt: '2026-05-28T00:00:00Z',
+      }) as Awaited<ReturnType<ToolDeps['getConsumerBalance']>>,
+    );
+  const createConsumerTopUp = vi
+    .fn<ToolDeps['createConsumerTopUp']>()
+    .mockResolvedValue(
+      (overrides.topUpSession ?? {
+        checkoutUrl: 'https://stripe.test/checkout/abc',
+        sessionId: 'cs_test_default',
+      }) as Awaited<ReturnType<ToolDeps['createConsumerTopUp']>>,
+    );
   const validateFilePath = vi.fn((p: string) => p);
+  const resolveSavePath = vi.fn((p: string) => p);
+  const writeFile = vi.fn();
   const fileSize = vi.fn().mockReturnValue(overrides.fileSize ?? 100);
-  const filePartFromPath = vi.fn(async (path: string, opts: { partId?: string; contentType?: string }) => ({
-    type: 'file' as const,
-    partId: opts.partId ?? 'file',
-    file: { id: 'file-id', mimeType: opts.contentType ?? 'application/octet-stream' },
-    _path: path,
-  }));
-  const textPart = vi.fn((text: string, partId: string) => ({
-    type: 'text' as const,
-    partId,
-    text,
-  }));
+  const filePartFromPath = vi.fn<ToolDeps['filePartFromPath']>(
+    async (path, opts) =>
+      ({
+        type: 'file' as const,
+        partId: opts?.partId ?? 'file',
+        file: { id: 'file-id', mimeType: opts?.contentType ?? 'application/octet-stream' },
+        _path: path,
+      }) as Awaited<ReturnType<ToolDeps['filePartFromPath']>>,
+  );
+  const textPart = vi.fn<ToolDeps['textPart']>(
+    (text, partId) =>
+      ({
+        type: 'text' as const,
+        partId,
+        text,
+      }) as ReturnType<ToolDeps['textPart']>,
+  );
 
   const deps: ToolDeps = {
     getBaseUrl,
     getApiKey,
+    getOrgId,
     getTaskClient,
     getAgentByName,
     listAgents,
+    fetchAgentStatus,
+    getConsumerBalance,
+    createConsumerTopUp,
     validateFilePath,
+    resolveSavePath,
+    writeFile,
     fileSize,
     maxUploadBytes: overrides.maxUploadBytes ?? 25 * 1024 * 1024,
-    filePartFromPath: filePartFromPath as unknown as ToolDeps['filePartFromPath'],
-    textPart: textPart as unknown as ToolDeps['textPart'],
+    filePartFromPath,
+    textPart,
   };
 
   return {
@@ -168,10 +224,16 @@ export function makeFakeDeps(overrides: FakeDepsOverrides = {}) {
     mocks: {
       getBaseUrl,
       getApiKey,
+      getOrgId,
       getTaskClient,
       getAgentByName,
       listAgents,
+      fetchAgentStatus,
+      getConsumerBalance,
+      createConsumerTopUp,
       validateFilePath,
+      resolveSavePath,
+      writeFile,
       fileSize,
       filePartFromPath,
       textPart,

package/tests/list-agents.test.ts

@@ -3,7 +3,7 @@ import { listAgents } from '../src/tools.js';
 import { makeFakeDeps } from './helpers.js';
 
 describe('list_agents', () => {
-  it('renders one row per agent with skill names joined by commas', async () => {
+  it('renders one row per agent with tag names joined by commas', async () => {
     const { deps } = makeFakeDeps({
       listAgentsResult: {
         agents: [
@@ -11,7 +11,7 @@ describe('list_agents', () => {
             agentName: 'alice',
             name: 'Alice',
             listing: 'public',
-            skills: [
+            tags: [
               { id: 'translate', name: 'Translate' },
               { id: 'summarize', name: 'Summarize' },
             ],
@@ -31,21 +31,21 @@ describe('list_agents', () => {
     ]);
   });
 
-  it('forwards baseUrl, apiKey, skill, listing, limit to the registry helper', async () => {
+  it('forwards baseUrl, apiKey, tag, listing, limit to the registry helper', async () => {
     const { deps, mocks } = makeFakeDeps({
       apiKey: 'sk-test',
       baseUrl: 'http://api.test',
     });
 
     await listAgents(
-      { skill: 'translate', listing: 'private', limit: 25 },
+      { tag: 'translate', listing: 'private', limit: 25 },
       deps,
     );
 
     expect(mocks.listAgents).toHaveBeenCalledWith({
       baseUrl: 'http://api.test',
       apiKey: 'sk-test',
-      skill: 'translate',
+      tag: 'translate',
       listing: 'private',
       limit: 25,
     });
@@ -54,7 +54,7 @@ describe('list_agents', () => {
   it('defaults to "public" for missing listing and uses agentName when name is absent', async () => {
     const { deps } = makeFakeDeps({
       listAgentsResult: {
-        agents: [{ agentName: 'naked', skills: [] }],
+        agents: [{ agentName: 'naked', tags: [] }],
         totalCount: 1,
       },
     });

package/tests/registry-list.test.ts

@@ -1,9 +1,9 @@
 import { describe, it, expect, vi } from 'vitest';
+import { listAgentsAuthenticated } from '../src/registry-list.js';
 import {
-  listAgentsAuthenticated,
   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 +57,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 +68,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 +104,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

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');
+  });
+});
+