adoptai-mcp 1.0.0

package/dist/integrations/notion/tools.js

@@ -0,0 +1,586 @@
+import { readFileSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+import { notionRequest } from './api.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+const manifest = JSON.parse(readFileSync(join(__dirname, 'endpoints.json'), 'utf8'));
+const BASE_URL = manifest.baseUrl;
+
+function text(payload) {
+  return {
+    content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }],
+  };
+}
+
+function enrichSchema(schema, method) {
+  const s = structuredClone(schema);
+  s.properties = s.properties || {};
+  if (['POST', 'PUT', 'PATCH'].includes(method)) {
+    s.properties._rawBody = {
+      type: 'object',
+      description:
+        'Optional full JSON body for nested structures (parent, properties, rich_text, etc.). When set, replaces other body fields.',
+    };
+  }
+  return s;
+}
+
+const baseTools = manifest.endpoints.map((endpoint) => ({
+  name: endpoint.name,
+  description: endpoint.description,
+  inputSchema: enrichSchema(endpoint.inputSchema, endpoint.method),
+  handler: async (params) => text(await notionRequest(endpoint, BASE_URL, params)),
+}));
+
+function call(method, path, params = {}) {
+  return notionRequest({ method, path }, BASE_URL, params);
+}
+
+function richText(content) {
+  return [{ type: 'text', text: { content: String(content ?? '') } }];
+}
+
+function blockText(block) {
+  const t = block?.type;
+  const value = block?.[t];
+  if (!value) return '';
+  if (Array.isArray(value.rich_text)) {
+    return value.rich_text.map((x) => x?.plain_text || x?.text?.content || '').join('');
+  }
+  if (Array.isArray(value.title)) {
+    return value.title.map((x) => x?.plain_text || x?.text?.content || '').join('');
+  }
+  return '';
+}
+
+function pageTitle(page) {
+  const props = page?.properties || {};
+  for (const p of Object.values(props)) {
+    if (p?.type === 'title' && Array.isArray(p.title)) {
+      const t = p.title.map((x) => x?.plain_text || x?.text?.content || '').join('');
+      if (t) return t;
+    }
+  }
+  return '';
+}
+
+async function listAllChildren(block_id, max_depth = 5, depth = 1) {
+  let cursor;
+  const items = [];
+  do {
+    const page = await call('GET', '/v1/blocks/{block_id}/children', {
+      block_id,
+      start_cursor: cursor,
+      page_size: 100,
+    });
+    const results = page?.results || [];
+    for (const b of results) {
+      const out = { ...b };
+      if (b.has_children && depth < max_depth) {
+        out.children = await listAllChildren(b.id, max_depth, depth + 1);
+      }
+      items.push(out);
+    }
+    cursor = page?.has_more ? page?.next_cursor : null;
+  } while (cursor);
+  return items;
+}
+
+function markdownToBlocks(content, defaultType = 'paragraph') {
+  const lines = String(content || '')
+    .split('\n')
+    .map((x) => x.replace(/\r$/, ''));
+  const blocks = [];
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    let type = defaultType;
+    let textValue = line;
+    let checked = false;
+    if (line.startsWith('### ')) {
+      type = 'heading_3';
+      textValue = line.slice(4);
+    } else if (line.startsWith('## ')) {
+      type = 'heading_2';
+      textValue = line.slice(3);
+    } else if (line.startsWith('# ')) {
+      type = 'heading_1';
+      textValue = line.slice(2);
+    } else if (line.startsWith('- [ ] ')) {
+      type = 'to_do';
+      textValue = line.slice(6);
+      checked = false;
+    } else if (line.startsWith('- [x] ') || line.startsWith('- [X] ')) {
+      type = 'to_do';
+      textValue = line.slice(6);
+      checked = true;
+    } else if (/^\d+\.\s+/.test(line)) {
+      type = 'numbered_list_item';
+      textValue = line.replace(/^\d+\.\s+/, '');
+    } else if (line.startsWith('- ')) {
+      type = 'bulleted_list_item';
+      textValue = line.slice(2);
+    } else if (line.startsWith('> ')) {
+      type = 'quote';
+      textValue = line.slice(2);
+    } else if (line.startsWith('!! ')) {
+      type = 'callout';
+      textValue = line.slice(3);
+    }
+    const block = { object: 'block', type, [type]: { rich_text: richText(textValue) } };
+    if (type === 'to_do') block[type].checked = checked;
+    if (type === 'callout') block[type].icon = { emoji: '💡' };
+    blocks.push(block);
+  }
+  return blocks;
+}
+
+function buildDatabaseFilter(filter_property, filter_type, filter_value) {
+  const property = String(filter_property || '').trim();
+  const kind = String(filter_type || 'text').trim().toLowerCase();
+  if (!property || filter_value === undefined || filter_value === null || filter_value === '') return null;
+  if (kind === 'number') return { property, number: { equals: Number(filter_value) } };
+  if (kind === 'checkbox') return { property, checkbox: { equals: String(filter_value) === 'true' } };
+  if (kind === 'select') return { property, select: { equals: String(filter_value) } };
+  if (kind === 'date') return { property, date: { equals: String(filter_value) } };
+  if (kind === 'relation') return { property, relation: { contains: String(filter_value) } };
+  return { property, rich_text: { contains: String(filter_value) } };
+}
+
+function propertyToCell(prop) {
+  if (!prop || !prop.type) return '';
+  if (prop.type === 'title') return (prop.title || []).map((x) => x?.plain_text || '').join('');
+  if (prop.type === 'rich_text') return (prop.rich_text || []).map((x) => x?.plain_text || '').join('');
+  if (prop.type === 'number') return prop.number;
+  if (prop.type === 'checkbox') return prop.checkbox;
+  if (prop.type === 'select') return prop.select?.name || '';
+  if (prop.type === 'multi_select') return (prop.multi_select || []).map((x) => x.name).join(', ');
+  if (prop.type === 'date') return prop.date?.start || '';
+  if (prop.type === 'status') return prop.status?.name || '';
+  if (prop.type === 'url') return prop.url || '';
+  if (prop.type === 'email') return prop.email || '';
+  if (prop.type === 'phone_number') return prop.phone_number || '';
+  if (prop.type === 'relation') return (prop.relation || []).map((x) => x.id).join(', ');
+  return '';
+}
+
+/** Smart tools; `publish` is HTTP routing metadata for adopt.ai catalog (see publish-to-adoptai.js). */
+export const smartTools = [
+  {
+    name: 'get_page_full_content',
+    publish: { method: 'GET', path: '/v1/pages/{page_id}' },
+    description:
+      'Retrieves a complete Notion page including all its properties, metadata, and deeply nested block content in a single call by automatically traversing child blocks. Use this instead of get_page when you need the full text content and structure, not just page properties.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        page_id: { type: 'string', description: 'Notion page ID.' },
+        max_depth: { type: 'number', description: 'Maximum recursion depth. Defaults to 3.' },
+      },
+      required: ['page_id'],
+    },
+    handler: async ({ page_id, max_depth = 3 }) => {
+      const page = await call('GET', '/v1/pages/{page_id}', { page_id });
+      const blocks = await listAllChildren(page_id, max_depth);
+      return text({ page, content_blocks: blocks });
+    },
+  },
+  {
+    name: 'create_page_with_content',
+    publish: { method: 'POST', path: '/v1/pages' },
+    description:
+      'Creates a new Notion page with initial content blocks already populated in one operation, accepting both page properties and an array of content blocks. Use this when creating pages that need content immediately rather than creating empty pages and appending content separately.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        parent_page_id: { type: 'string', description: 'Parent page ID.' },
+        parent_database_id: { type: 'string', description: 'Parent database ID.' },
+        title: { type: 'string', description: 'Page title.' },
+        content: { type: 'string', description: 'Markdown-like content text.' },
+      },
+      required: ['title', 'content'],
+    },
+    handler: async ({ parent_page_id, parent_database_id, title, content }) => {
+      if (!parent_page_id && !parent_database_id) {
+        throw new Error('Provide parent_page_id or parent_database_id.');
+      }
+      const children = markdownToBlocks(content, 'paragraph');
+      const parent = parent_database_id ? { database_id: parent_database_id } : { page_id: parent_page_id };
+      const properties = parent_database_id
+        ? { Name: { title: richText(title) } }
+        : { title: { title: richText(title) } };
+      const created = await call('POST', '/v1/pages', { _rawBody: { parent, properties, children } });
+      return text(created);
+    },
+  },
+  {
+    name: 'duplicate_page',
+    publish: { method: 'POST', path: '/v1/pages' },
+    description:
+      'Creates an exact copy of an existing Notion page including all properties and top-level content blocks under a specified parent page or database. Use when you need to replicate a page as a template, but note it only copies top-level blocks, not deeply nested content.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        page_id: { type: 'string', description: 'Source page ID.' },
+        parent_id: { type: 'string', description: 'Destination parent ID.' },
+      },
+      required: ['page_id', 'parent_id'],
+    },
+    handler: async ({ page_id, parent_id }) => {
+      const sourcePage = await call('GET', '/v1/pages/{page_id}', { page_id });
+      const childrenResp = await call('GET', '/v1/blocks/{block_id}/children', { block_id: page_id, page_size: 100 });
+      const children = childrenResp?.results || [];
+      const payload = {
+        parent: { page_id: parent_id },
+        properties: sourcePage.properties || {},
+        children,
+      };
+      const duplicated = await call('POST', '/v1/pages', { _rawBody: payload });
+      return text({ source_page_id: page_id, duplicated_page: duplicated });
+    },
+  },
+  {
+    name: 'query_database_filtered',
+    publish: { method: 'POST', path: '/v1/databases/{database_id}/query' },
+    description:
+      'Queries a Notion database with specific property-based filters supporting text contains/equals, number comparisons, checkbox states, select values, date ranges, and relation matching. Use this for targeted searches when you know what criteria you\'re looking for, rather than retrieving all database rows.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        database_id: { type: 'string', description: 'Database ID.' },
+        filter_property: { type: 'string', description: 'Property name to filter on.' },
+        filter_type: { type: 'string', description: 'text|number|checkbox|select|date|relation' },
+        filter_value: { type: 'string', description: 'Filter value.' },
+        page_size: { type: 'number', description: 'Page size for query.' },
+      },
+      required: ['database_id'],
+    },
+    handler: async ({ database_id, filter_property, filter_type, filter_value, page_size = 20 }) => {
+      const filter = buildDatabaseFilter(filter_property, filter_type, filter_value);
+      const data = await call('POST', '/v1/databases/{id}/query', {
+        id: database_id,
+        _rawBody: { page_size, ...(filter ? { filter } : {}) },
+      });
+      return text(data);
+    },
+  },
+  {
+    name: 'query_database_all',
+    publish: { method: 'POST', path: '/v1/databases/{database_id}/query' },
+    description:
+      'Retrieves every single row from a Notion database by automatically handling all pagination behind the scenes until the complete dataset is fetched. Use when you need comprehensive database contents, but be cautious with large databases as this can be slow and return massive amounts of data.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        database_id: { type: 'string', description: 'Database ID.' },
+        max_pages: { type: 'number', description: 'Safety cap for pagination pages. Defaults to 10.' },
+      },
+      required: ['database_id'],
+    },
+    handler: async ({ database_id, max_pages = 10 }) => {
+      const all = [];
+      let start_cursor;
+      let page = 0;
+      do {
+        const resp = await call('POST', '/v1/databases/{id}/query', {
+          id: database_id,
+          _rawBody: { start_cursor, page_size: 100 },
+        });
+        all.push(...(resp?.results || []));
+        start_cursor = resp?.has_more ? resp?.next_cursor : null;
+        page += 1;
+      } while (start_cursor && page < max_pages);
+      return text({ database_id, total_rows: all.length, results: all, truncated: !!start_cursor });
+    },
+  },
+  {
+    name: 'query_database_sorted',
+    publish: { method: 'POST', path: '/v1/databases/{database_id}/query' },
+    description:
+      'Queries a Notion database with results sorted by any property in ascending or descending order, useful for getting recent entries, alphabetical lists, or priority-ordered items. Use when the order of results matters more than filtering by specific criteria.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        database_id: { type: 'string', description: 'Database ID.' },
+        sort_property: { type: 'string', description: 'Property used for sorting.' },
+        sort_direction: { type: 'string', description: 'ascending or descending' },
+        page_size: { type: 'number', description: 'Page size for query.' },
+      },
+      required: ['database_id', 'sort_property'],
+    },
+    handler: async ({ database_id, sort_property, sort_direction = 'ascending', page_size = 20 }) => {
+      const resp = await call('POST', '/v1/databases/{id}/query', {
+        id: database_id,
+        _rawBody: { page_size, sorts: [{ property: sort_property, direction: sort_direction }] },
+      });
+      return text(resp);
+    },
+  },
+  {
+    name: 'get_database_rows_as_table',
+    publish: { method: 'POST', path: '/v1/databases/{database_id}/query' },
+    description:
+      'Queries a Notion database and transforms the raw API response into a clean, readable table format with extracted column headers and cell values. Use this when you need to present database contents to users in a human-readable format rather than processing raw Notion API objects.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        database_id: { type: 'string', description: 'Database ID.' },
+        page_size: { type: 'number', description: 'Number of rows to retrieve. Defaults to 20.' },
+      },
+      required: ['database_id'],
+    },
+    handler: async ({ database_id, page_size = 20 }) => {
+      const resp = await call('POST', '/v1/databases/{id}/query', {
+        id: database_id,
+        _rawBody: { page_size },
+      });
+      const rows = resp?.results || [];
+      const columns = [...new Set(rows.flatMap((r) => Object.keys(r.properties || {})))];
+      const table = rows.map((row) =>
+        Object.fromEntries(columns.map((c) => [c, propertyToCell(row.properties?.[c])]))
+      );
+      return text({ database_id, columns, rows: table });
+    },
+  },
+  {
+    name: 'append_text_content',
+    publish: { method: 'PATCH', path: '/v1/blocks/{block_id}/children' },
+    description:
+      'Appends simple text content to any Notion page or block, automatically converting plain text or basic markdown into properly formatted Notion paragraph blocks. Use for straightforward text additions; for complex formatting or nested block structures, use append_complex_blocks instead.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        block_id: { type: 'string', description: 'Parent block/page ID.' },
+        content: { type: 'string', description: 'Plain text or markdown content.' },
+        block_type: {
+          type: 'string',
+          description:
+            'paragraph|heading_1|heading_2|heading_3|bulleted_list_item|numbered_list_item|to_do|quote|callout',
+        },
+      },
+      required: ['block_id', 'content'],
+    },
+    handler: async ({ block_id, content, block_type = 'paragraph' }) => {
+      const children = markdownToBlocks(content, block_type);
+      const resp = await call('PATCH', '/v1/blocks/{block_id}/children', { block_id, _rawBody: { children } });
+      return text(resp);
+    },
+  },
+  {
+    name: 'append_code_block',
+    publish: { method: 'PATCH', path: '/v1/blocks/{block_id}/children' },
+    description:
+      'Appends a syntax-highlighted code block to a Notion page with support for all major programming languages and proper code formatting. Use specifically when adding code snippets or technical content that requires syntax highlighting, not for regular text content.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        block_id: { type: 'string', description: 'Parent block/page ID.' },
+        code: { type: 'string', description: 'Code content.' },
+        language: { type: 'string', description: 'Code language. Defaults to plain text.' },
+        caption: { type: 'string', description: 'Optional caption.' },
+      },
+      required: ['block_id', 'code'],
+    },
+    handler: async ({ block_id, code, language = 'plain text', caption }) => {
+      const child = {
+        object: 'block',
+        type: 'code',
+        code: {
+          rich_text: richText(code),
+          language,
+          ...(caption ? { caption: richText(caption) } : {}),
+        },
+      };
+      const resp = await call('PATCH', '/v1/blocks/{block_id}/children', {
+        block_id,
+        _rawBody: { children: [child] },
+      });
+      return text(resp);
+    },
+  },
+  {
+    name: 'append_table_block',
+    publish: { method: 'PATCH', path: '/v1/blocks/{block_id}/children' },
+    description:
+      'Appends a structured table to a Notion page by converting a 2D array of data into proper Notion table blocks with rows and cells. Use when you need to add tabular data with rows and columns, automatically handling the creation of table_row child blocks.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        block_id: { type: 'string', description: 'Parent block/page ID.' },
+        headers: { type: 'array', description: 'Array of column headers.' },
+        rows: { type: 'array', description: '2D array of row values.' },
+      },
+      required: ['block_id', 'headers', 'rows'],
+    },
+    handler: async ({ block_id, headers, rows }) => {
+      const head = Array.isArray(headers) ? headers : [];
+      const bodyRows = Array.isArray(rows) ? rows : [];
+      const toCell = (v) => richText(v == null ? '' : String(v));
+      const tableChildren = [
+        { object: 'block', type: 'table_row', table_row: { cells: head.map((h) => toCell(h)) } },
+        ...bodyRows.map((r) => ({
+          object: 'block',
+          type: 'table_row',
+          table_row: { cells: (Array.isArray(r) ? r : []).map((v) => toCell(v)) },
+        })),
+      ];
+      const table = {
+        object: 'block',
+        type: 'table',
+        table: {
+          table_width: head.length,
+          has_column_header: true,
+          has_row_header: false,
+          children: tableChildren,
+        },
+      };
+      const resp = await call('PATCH', '/v1/blocks/{block_id}/children', {
+        block_id,
+        _rawBody: { children: [table] },
+      });
+      return text(resp);
+    },
+  },
+  {
+    name: 'get_all_block_children_recursive',
+    publish: { method: 'GET', path: '/v1/blocks/{block_id}/children' },
+    description:
+      'Retrieves the complete nested structure of all child blocks within a page or block, automatically traversing the entire content hierarchy to return a full block tree. Use this when you need to access all content within a page rather than just the top-level blocks, as it handles nested blocks like toggle lists, columns, and indented items that have has_children=true.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        block_id: { type: 'string', description: 'Block or page ID.' },
+        max_depth: { type: 'number', description: 'Maximum recursion depth. Defaults to 5.' },
+      },
+      required: ['block_id'],
+    },
+    handler: async ({ block_id, max_depth = 5 }) => text({ block_id, children: await listAllChildren(block_id, max_depth) }),
+  },
+  {
+    name: 'find_page_by_title',
+    publish: { method: 'POST', path: '/v1/search' },
+    description:
+      'Searches your Notion workspace to find pages by matching title text and returns their page IDs, titles, and parent information. Use this as your first step before reading or modifying any page content, and note that for finding databases you should use find_database_by_title instead.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        title_query: { type: 'string', description: 'Title query text.' },
+        page_size: { type: 'number', description: 'Page size. Defaults to 10.' },
+      },
+      required: ['title_query'],
+    },
+    handler: async ({ title_query, page_size = 10 }) => {
+      const resp = await call('POST', '/v1/search', {
+        _rawBody: { query: title_query, page_size, filter: { property: 'object', value: 'page' } },
+      });
+      const out = (resp?.results || []).map((x) => ({ id: x.id, title: pageTitle(x), parent: x.parent }));
+      return text({ results: out, has_more: resp?.has_more, next_cursor: resp?.next_cursor });
+    },
+  },
+  {
+    name: 'find_database_by_title',
+    publish: { method: 'POST', path: '/v1/search' },
+    description:
+      'Searches your Notion workspace to find databases by matching name text and returns their database IDs along with property schema information. Use this to locate database IDs before querying database records, and note that for finding regular pages you should use find_page_by_title instead.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        title_query: { type: 'string', description: 'Database name query.' },
+        page_size: { type: 'number', description: 'Page size. Defaults to 10.' },
+      },
+      required: ['title_query'],
+    },
+    handler: async ({ title_query, page_size = 10 }) => {
+      const resp = await call('POST', '/v1/search', {
+        _rawBody: { query: title_query, page_size, filter: { property: 'object', value: 'database' } },
+      });
+      const out = (resp?.results || []).map((x) => ({ id: x.id, title: (x.title || []).map((t) => t.plain_text).join(''), properties: x.properties }));
+      return text({ results: out, has_more: resp?.has_more, next_cursor: resp?.next_cursor });
+    },
+  },
+  {
+    name: 'list_all_workspace_pages',
+    publish: { method: 'POST', path: '/v1/search' },
+    description:
+      "Lists all pages accessible to this integration in the Notion workspace. Returns page IDs, titles, and parent hierarchy. Use as a discovery tool when you don't know which pages exist.",
+    inputSchema: {
+      type: 'object',
+      properties: {
+        page_size: { type: 'number', description: 'Page size. Defaults to 50.' },
+        start_cursor: { type: 'string', description: 'Pagination cursor.' },
+      },
+      required: [],
+    },
+    handler: async ({ page_size = 50, start_cursor }) => {
+      const resp = await call('POST', '/v1/search', {
+        _rawBody: { page_size, start_cursor, filter: { property: 'object', value: 'page' } },
+      });
+      const out = (resp?.results || []).map((x) => ({ id: x.id, title: pageTitle(x), parent: x.parent }));
+      return text({ results: out, has_more: resp?.has_more, next_cursor: resp?.next_cursor });
+    },
+  },
+  {
+    name: 'list_all_workspace_databases',
+    publish: { method: 'POST', path: '/v1/search' },
+    description:
+      'Returns a comprehensive list of all databases accessible to the integration across your entire Notion workspace, including database IDs, names, and complete property schemas. Use this to discover what databases are available before querying their records or when you need to understand the structure of databases in the workspace.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        page_size: { type: 'number', description: 'Page size. Defaults to 50.' },
+        start_cursor: { type: 'string', description: 'Pagination cursor.' },
+      },
+      required: [],
+    },
+    handler: async ({ page_size = 50, start_cursor }) => {
+      const resp = await call('POST', '/v1/search', {
+        _rawBody: { page_size, start_cursor, filter: { property: 'object', value: 'database' } },
+      });
+      const out = (resp?.results || []).map((x) => ({ id: x.id, title: (x.title || []).map((t) => t.plain_text).join(''), properties: x.properties }));
+      return text({ results: out, has_more: resp?.has_more, next_cursor: resp?.next_cursor });
+    },
+  },
+  {
+    name: 'add_comment_to_page',
+    publish: { method: 'POST', path: '/v1/comments' },
+    description:
+      'Creates a new top-level comment on a Notion page, ideal for adding review feedback, status updates, or general notes to a page. Use this for starting new comment threads, but if you need to respond to an existing discussion use reply_to_comment instead.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        page_id: { type: 'string', description: 'Target page ID.' },
+        comment_text: { type: 'string', description: 'Comment text.' },
+      },
+      required: ['page_id', 'comment_text'],
+    },
+    handler: async ({ page_id, comment_text }) =>
+      text(
+        await call('POST', '/v1/comments', {
+          _rawBody: { parent: { page_id }, rich_text: richText(comment_text) },
+        })
+      ),
+  },
+  {
+    name: 'reply_to_comment',
+    publish: { method: 'POST', path: '/v1/comments' },
+    description:
+      'Adds a reply to an existing comment thread on a Notion page and requires the discussion_id parameter from the original comment you\'re replying to. Use this to continue conversations in existing comment threads rather than creating new top-level comments.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        discussion_id: { type: 'string', description: 'Discussion thread ID.' },
+        reply_text: { type: 'string', description: 'Reply text.' },
+      },
+      required: ['discussion_id', 'reply_text'],
+    },
+    handler: async ({ discussion_id, reply_text }) =>
+      text(
+        await call('POST', '/v1/comments', {
+          _rawBody: { discussion_id, rich_text: richText(reply_text) },
+        })
+      ),
+  },
+];
+
+export const tools = [...baseTools, ...smartTools];