v3/mcp/tools/
├── agent-tools.ts      # Agent lifecycle: spawn, list, terminate, status
├── swarm-tools.ts      # Swarm coordination: init, status, scale
├── memory-tools.ts     # Memory/AgentDB: store, search, list
├── config-tools.ts     # Configuration: load, save, validate
├── index.ts            # Central exports and utility functions
├── README.md           # Comprehensive documentation
└── IMPLEMENTATION.md   # This file (quick reference)

import { agentTools } from './mcp/tools/agent-tools.js';

// agent/spawn - Spawn new agent
await handler({ agentType: 'coder', priority: 'high' })

// agent/list - List agents
await handler({ status: 'active', limit: 10 })

// agent/terminate - Terminate agent
await handler({ agentId: 'agent-123', graceful: true })

// agent/status - Get agent status
await handler({ agentId: 'agent-123', includeMetrics: true })

import { swarmTools } from './mcp/tools/swarm-tools.js';

// swarm/init - Initialize swarm
await handler({ topology: 'hierarchical-mesh', maxAgents: 15 })

// swarm/status - Get swarm status
await handler({ includeAgents: true, includeMetrics: true })

// swarm/scale - Scale swarm
await handler({ targetAgents: 20, scaleStrategy: 'gradual' })

import { memoryTools } from './mcp/tools/memory-tools.js';

// memory/store - Store memory
await handler({ content: '...', type: 'semantic', category: 'code' })

// memory/search - Search memories
await handler({ query: 'auth implementation', searchType: 'hybrid' })

// memory/list - List memories
await handler({ type: 'episodic', sortBy: 'created', limit: 50 })

import { configTools } from './mcp/tools/config-tools.js';

// config/load - Load configuration
await handler({ path: './config.json', merge: true })

// config/save - Save configuration
await handler({ config: {...}, createBackup: true })

// config/validate - Validate configuration
await handler({ config: {...}, strict: true, fixIssues: true })

import { getAllTools } from './mcp/tools/index.js';

const server = createMCPServer(config, logger);
const tools = getAllTools();

const result = server.registerTools(tools);
console.log(`Registered ${result.registered} tools`);

import { spawnAgentTool } from './mcp/tools/agent-tools.js';

const result = await spawnAgentTool.handler({
  agentType: 'coder',
  config: { maxConcurrentTasks: 5 },
  priority: 'high',
});

console.log(`Agent spawned: ${result.agentId}`);

import { getToolsByCategory } from './mcp/tools/index.js';

const agentTools = getToolsByCategory('agent');    // 4 tools
const swarmTools = getToolsByCategory('swarm');    // 3 tools
const memoryTools = getToolsByCategory('memory');  // 3 tools
const configTools = getToolsByCategory('config');  // 3 tools

import { getToolStats } from './mcp/tools/index.js';

const stats = getToolStats();
console.log(`Total tools: ${stats.total}`);              // 13
console.log(`Cacheable: ${stats.cacheable}`);            // 10
console.log(`Categories: ${stats.categories.join(', ')}`); // agent, swarm, memory, config

// DON'T: Implement business logic in CLI
async function cliSpawnAgent(type: string, config: any) {
  const agent = new Agent(type);
  await agent.initialize(config);
  return agent;
}

// DO: Call MCP tool from CLI
async function cliSpawnAgent(type: string, config: any) {
  const { spawnAgentTool } = await import('./mcp/tools/agent-tools.js');

  return await spawnAgentTool.handler({
    agentType: type,
    config: config,
    priority: 'normal',
  });
}

import { z } from 'zod';

const schema = z.object({
  agentType: z.string().describe('Type of agent'),
  priority: z.enum(['low', 'normal', 'high', 'critical']).default('normal'),
});

// Validation happens automatically in handler
const result = await handler({ agentType: 'coder' }); // ✅ valid
const result = await handler({ agentType: '' });      // ❌ throws error

// Tools with caching enabled (cacheable: true)
- agent/list (2s TTL)
- agent/status (1s TTL)
- swarm/status (2s TTL)
- memory/search (5s TTL)
- memory/list (3s TTL)
- config/load (10s TTL)
- system/health (2s TTL)
- system/metrics (1s TTL)
- tools/list-detailed

// Default timeout: 30s
// Override per tool:
export const myTool: MCPTool = {
  // ...
  timeout: 60000, // 60 seconds
};

async function handleSpawnAgent(input, context) {
  // TODO: Integrate with actual agent manager when available
  // const agentManager = context?.agentManager as AgentManager;
  // if (agentManager) {
  //   return await agentManager.spawnAgent(input);
  // }

  // Stub implementation (works now, replace later)
  return {
    agentId: generateId(),
    agentType: input.agentType,
    status: 'active',
    createdAt: new Date().toISOString(),
  };
}

import { describe, it, expect } from 'vitest';
import { spawnAgentTool } from './agent-tools.js';

describe('agent/spawn', () => {
  it('should spawn agent with valid input', async () => {
    const result = await spawnAgentTool.handler({
      agentType: 'coder',
    });

    expect(result.agentId).toBeDefined();
    expect(result.status).toBe('active');
  });

  it('should validate input schema', async () => {
    await expect(
      spawnAgentTool.handler({ agentType: '' })
    ).rejects.toThrow();
  });
});

// List with pagination
await handler({
  limit: 50,
  offset: 0,
});

// Filter by status and type
await handler({
  status: 'active',
  agentType: 'coder',
});

// Include metrics and history
await handler({
  agentId: 'agent-123',
  includeMetrics: true,
  includeHistory: true,
});

# View all tool files
ls -lh v3/mcp/tools/

# Count total lines
wc -l v3/mcp/tools/*.ts

# Search for a specific tool
grep -r "agent/spawn" v3/mcp/tools/

# View tool documentation
cat v3/mcp/tools/README.md