/**
* Tool Registry
* Central registry for all MCP tools
*/
import type { CallToolResult, Tool } from '@modelcontextprotocol/sdk/types.js';
/**
* Tool handler function type
*/
export type ToolHandler = (
args: Record<string, unknown>
) => Promise<CallToolResult>;
/**
* Tool definition with handler
*/
export interface ToolDefinition {
definition: Tool;
handler: ToolHandler;
}
/**
* Registry of all available tools
*/
const tools = new Map<string, ToolDefinition>();
/**
* Register a new tool
*/
export function registerTool(tool: ToolDefinition): void {
tools.set(tool.definition.name, tool);
}
/**
* Get all registered tools
*/
export function getAllTools(): Tool[] {
return Array.from(tools.values()).map((t) => t.definition);
}
/**
* Get a tool handler by name
*/
export function getToolHandler(name: string): ToolHandler | undefined {
return tools.get(name)?.handler;
}
/**
* Check if a tool exists
*/
export function hasTool(name: string): boolean {
return tools.has(name);
}
/**
* Import and register all tools
*/
import {
searchCompaniesTool,
handleSearchCompanies,
} from './search-companies.js';
import { searchPeopleTool, handleSearchPeople } from './search-people.js';
import { getCompanyTool, handleGetCompany } from './get-company.js';
import { getPersonTool, handleGetPerson } from './get-person.js';
import { createCompanyTool, handleCreateCompany } from './create-company.js';
import { updateCompanyTool, handleUpdateCompany } from './update-company.js';
import { createPersonTool, handleCreatePerson } from './create-person.js';
import { updatePersonTool, handleUpdatePerson } from './update-person.js';
import {
manageCompanyDomainsTool,
handleManageCompanyDomains,
} from './manage-company-domains.js';
import {
managePersonEmailsTool,
handleManagePersonEmails,
} from './manage-person-emails.js';
import {
getWorkspaceSchemaTool,
handleGetWorkspaceSchema,
} from './get-workspace-schema.js';
import {
managePersonTagsTool,
handleManagePersonTags,
} from './manage-person-tags.js';
import { createNoteTool, handleCreateNote } from './create-note.js';
import { getNoteTool, handleGetNote } from './get-note.js';
// Register workspace schema tool
registerTool({
definition: getWorkspaceSchemaTool,
handler: async (args) =>
handleGetWorkspaceSchema(
args as {
scope?: string;
object_slug?: string;
list_slug?: string;
force_reload?: boolean;
}
),
});
// Register Attio search tools
registerTool({
definition: searchCompaniesTool,
handler: async (args) =>
handleSearchCompanies(args as { query: string; limit?: number }),
});
registerTool({
definition: searchPeopleTool,
handler: async (args) =>
handleSearchPeople(args as { query: string; limit?: number }),
});
// Register Attio get tools
registerTool({
definition: getCompanyTool,
handler: async (args) => handleGetCompany(args as { record_id: string }),
});
registerTool({
definition: getPersonTool,
handler: async (args) => handleGetPerson(args as { record_id: string }),
});
// Register Company create/update tools
registerTool({
definition: createCompanyTool,
handler: async (args) =>
handleCreateCompany(
args as {
name: string;
domains?: string[];
description?: string;
linkedin?: string;
}
),
});
registerTool({
definition: updateCompanyTool,
handler: async (args) =>
handleUpdateCompany(
args as {
record_id: string;
name?: string;
description?: string;
linkedin?: string;
}
),
});
// Register Person create/update tools
registerTool({
definition: createPersonTool,
handler: async (args) =>
handleCreatePerson(
args as {
first_name?: string;
last_name?: string;
full_name?: string;
email_addresses?: string[];
description?: string;
linkedin?: string;
}
),
});
registerTool({
definition: updatePersonTool,
handler: async (args) =>
handleUpdatePerson(
args as {
record_id: string;
first_name?: string;
last_name?: string;
full_name?: string;
description?: string;
linkedin?: string;
}
),
});
// Register Company domain management tool
registerTool({
definition: manageCompanyDomainsTool,
handler: async (args) =>
handleManageCompanyDomains(
args as {
record_id: string;
operation: string;
domains?: string[];
}
),
});
// Register Person email management tool
registerTool({
definition: managePersonEmailsTool,
handler: async (args) =>
handleManagePersonEmails(
args as {
record_id: string;
operation: string;
email_addresses?: string[];
}
),
});
// Register Person tag management tool
registerTool({
definition: managePersonTagsTool,
handler: async (args) =>
handleManagePersonTags(
args as {
record_id: string;
operation: string;
tags?: string[];
}
),
});
// Register Notes tools
registerTool({
definition: createNoteTool,
handler: async (args) =>
handleCreateNote(
args as {
parent_object: string;
parent_record_id: string;
title: string;
content: string;
format?: string;
}
),
});
registerTool({
definition: getNoteTool,
handler: async (args) => handleGetNote(args as { note_id: string }),
});
