@imboard.ai/mcp-server 0.1.0

package/src/tools/boards.tools.ts

@@ -0,0 +1,172 @@
+import { z } from 'zod';
+import { boardIdParam, resourceIdParam, paginationParams, buildQueryParams, formatResult, handleToolError, RegisterToolsFn } from './shared.js';
+
+export const registerBoardsTools: RegisterToolsFn = (server, client) => {
+  server.tool(
+    'list_boards',
+    'Lists all boards the authenticated user has access to. Returns board name, billing state, and the user\'s role on each board.',
+    {
+      ...paginationParams,
+      sort: z.enum(['updatedAt', 'createdAt']).optional().describe('Sort field (default: updatedAt)'),
+    },
+    async ({ ...rest }) => {
+      try {
+        const params = buildQueryParams(rest, []);
+        const response = await client.getCollection('/api/boards', params);
+        return formatResult({ data: response.data, meta: response.meta });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    },
+  );
+
+  server.tool(
+    'get_board',
+    'Returns details for a specific board including name, description, billing state, and the authenticated user\'s role.',
+    {
+      boardId: boardIdParam,
+    },
+    async ({ boardId }) => {
+      try {
+        const response = await client.get(`/api/boards/${boardId}`);
+        return formatResult({ data: response.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    },
+  );
+
+  server.tool(
+    'create_board',
+    'Creates a new board. Returns the created board details.',
+    {
+      name: z.string().describe('Board name'),
+      description: z.string().optional().describe('Board description (BlockNote JSON or plain text)'),
+    },
+    async ({ name, description }) => {
+      try {
+        const body: Record<string, unknown> = { name };
+        if (description !== undefined) body.description = description;
+        const response = await client.post('/api/board', body);
+        return formatResult({ data: response.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    },
+  );
+
+  server.tool(
+    'update_board',
+    'Updates board details (name, description, settings). Requires admin access.',
+    {
+      boardId: boardIdParam,
+      name: z.string().describe('Board name'),
+      description: z.string().optional().describe('Board description (BlockNote JSON or plain text)'),
+      companyType: z.string().optional().describe('Company type'),
+      boardType: z.string().optional().describe('Board type'),
+      companyWebsiteUrl: z.string().optional().describe('Company website URL (must include protocol)'),
+      defaultTimezone: z.string().optional().describe('Default timezone (IANA format)'),
+    },
+    async ({ boardId, name, description, companyType, boardType, companyWebsiteUrl, defaultTimezone }) => {
+      try {
+        const body: Record<string, unknown> = { name };
+        if (description !== undefined) body.description = description;
+        if (companyType !== undefined) body.companyType = companyType;
+        if (boardType !== undefined) body.boardType = boardType;
+        if (companyWebsiteUrl !== undefined) body.companyWebsiteUrl = companyWebsiteUrl;
+        if (defaultTimezone !== undefined) body.defaultTimezone = defaultTimezone;
+        const response = await client.put(`/api/board/${boardId}`, body);
+        return formatResult({ data: response.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    },
+  );
+
+  server.tool(
+    'assign_member_roles',
+    'Assigns roles, positions, and access types to a board member.',
+    {
+      boardId: boardIdParam,
+      userId: resourceIdParam.describe('The user ID of the board member'),
+      set_admin_role: z.enum(['admin', 'guest']).optional().describe('Admin role to assign'),
+      set_access_type: z.enum(['collaborator', 'viewer']).optional().describe('Access type to assign'),
+      board_position: z.array(z.string()).optional().describe('Board positions to assign'),
+      appointingParty: z.string().optional().describe('Name of the appointing party'),
+    },
+    async ({ boardId, userId, ...fields }) => {
+      try {
+        const body: Record<string, unknown> = {};
+        if (fields.set_admin_role !== undefined) body.set_admin_role = fields.set_admin_role;
+        if (fields.set_access_type !== undefined) body.set_access_type = fields.set_access_type;
+        if (fields.board_position !== undefined) body.board_position = fields.board_position;
+        if (fields.appointingParty !== undefined) body.appointingParty = fields.appointingParty;
+        const response = await client.put(`/api/board/${boardId}/members/${userId}/roles`, body);
+        return formatResult({ data: response.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    },
+  );
+
+  server.tool(
+    'search_board_documents',
+    'Semantic search across all documents in a board. Returns matching document snippets ranked by relevance.',
+    {
+      boardId: boardIdParam,
+      query: z.string().describe('Search query (max 1000 characters)'),
+      limit: z.number().int().min(1).max(50).optional().describe('Max results (1-50, default 10)'),
+      minScore: z.number().min(0).max(1).optional().describe('Minimum relevance score (0-1)'),
+    },
+    async ({ boardId, query, limit, minScore }) => {
+      try {
+        const body: Record<string, unknown> = { query };
+        if (limit !== undefined) body.limit = limit;
+        if (minScore !== undefined) body.minScore = minScore;
+        const response = await client.post(`/api/board/${boardId}/search`, body);
+        return formatResult({ data: response.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    },
+  );
+
+  server.tool(
+    'list_board_action_items',
+    'Lists action items for a board. Returns open/in-progress items by default.',
+    {
+      boardId: boardIdParam,
+      includeCompleted: z.enum(['true', 'false']).optional().describe('Include completed items (default: false)'),
+      status: z.string().optional().describe('Filter by status (open, in_progress, completed, cancelled)'),
+    },
+    async ({ boardId, includeCompleted, status }) => {
+      try {
+        const params: Record<string, string> = {};
+        if (includeCompleted !== undefined) params.includeCompleted = includeCompleted;
+        if (status !== undefined) params.status = status;
+        const response = await client.get(`/api/board/${boardId}/action-items`, params);
+        return formatResult({ data: response.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    },
+  );
+
+  server.tool(
+    'update_board_action_item',
+    'Updates an action item status (in_progress, completed, cancelled).',
+    {
+      boardId: boardIdParam,
+      actionItemId: resourceIdParam.describe('The action item ID'),
+      status: z.string().describe('New status (open, in_progress, completed, cancelled)'),
+    },
+    async ({ boardId, actionItemId, status }) => {
+      try {
+        const response = await client.patch(`/api/board/${boardId}/action-items/${actionItemId}`, { status });
+        return formatResult({ data: response.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    },
+  );
+};

package/src/tools/dashboards.tools.ts

@@ -0,0 +1,45 @@
+import { boardIdParam, resourceIdParam, paginationParams, buildQueryParams, formatResult, handleToolError, RegisterToolsFn } from './shared.js';
+
+export const registerDashboardTools: RegisterToolsFn = (server, client) => {
+  server.tool(
+    'list_report_dashboards',
+    'Lists dashboards under a specific report. Dashboards are nested under reports in imboard\'s domain model.',
+    {
+      boardId: boardIdParam,
+      reportId: resourceIdParam.describe('The report ID (required — dashboards are nested under reports)'),
+      ...paginationParams,
+    },
+    async ({ boardId, reportId, ...rest }) => {
+      try {
+        const params = buildQueryParams(rest, []);
+        const result = await client.getCollection(
+          `/api/boards/${boardId}/reports/${reportId}/dashboards`,
+          params,
+        );
+        return formatResult({ data: result.data, meta: result.meta });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    },
+  );
+
+  server.tool(
+    'get_dashboard',
+    'Returns details for a specific dashboard including type, title, and associated report.',
+    {
+      boardId: boardIdParam,
+      reportId: resourceIdParam.describe('The report ID'),
+      dashboardId: resourceIdParam.describe('The dashboard ID'),
+    },
+    async ({ boardId, reportId, dashboardId }) => {
+      try {
+        const result = await client.get(
+          `/api/boards/${boardId}/reports/${reportId}/dashboards/${dashboardId}`,
+        );
+        return formatResult({ data: result.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    },
+  );
+};

package/src/tools/documents-write.tools.ts

@@ -0,0 +1,110 @@
+import { z } from 'zod';
+import { boardIdParam, resourceIdParam, formatResult, handleToolError, RegisterToolsFn } from './shared.js';
+
+export const registerDocumentWriteTools: RegisterToolsFn = (server, client) => {
+  server.tool(
+    'create_document',
+    'Creates a new document with an initial version. Requires a title and optionally a document type and external file link.',
+    {
+      boardId: boardIdParam,
+      title: z.string().describe('Document title'),
+      documentType: z.string().optional().describe('Document type (e.g. boardResolutions, minutesOfMeetings, capTable)'),
+      externalFileLink: z.string().optional().describe('HTTPS URL to an external file'),
+      meetingIds: z.array(z.string()).optional().describe('Array of meeting IDs to associate with'),
+    },
+    async ({ boardId, title, documentType, externalFileLink, meetingIds }) => {
+      try {
+        const body: Record<string, unknown> = { title };
+        if (documentType !== undefined) body.documentType = documentType;
+        if (externalFileLink !== undefined) body.externalFileLink = externalFileLink;
+        if (meetingIds !== undefined) body.meetingIds = meetingIds;
+        const response = await client.post(`/api/documents/${boardId}/`, body);
+        return formatResult({ data: response.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    },
+  );
+
+  server.tool(
+    'update_document',
+    'Updates document details (title, meeting associations, working copy link).',
+    {
+      boardId: boardIdParam,
+      documentId: resourceIdParam.describe('The document ID'),
+      title: z.string().optional().describe('New document title'),
+      documentType: z.string().optional().describe('Document type'),
+      workingCopyLink: z.string().optional().describe('URL to working copy'),
+      meetingIds: z.array(z.string()).optional().describe('Array of meeting IDs to associate with'),
+    },
+    async ({ boardId, documentId, title, documentType, workingCopyLink, meetingIds }) => {
+      try {
+        const body: Record<string, unknown> = {};
+        if (title !== undefined) body.title = title;
+        if (documentType !== undefined) body.documentType = documentType;
+        if (workingCopyLink !== undefined) body.workingCopyLink = workingCopyLink;
+        if (meetingIds !== undefined) body.meetingIds = meetingIds;
+        const response = await client.put(`/api/documents/${boardId}/${documentId}/`, body);
+        return formatResult({ data: response.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    },
+  );
+
+  server.tool(
+    'update_document_status',
+    'Changes document status (draft, review, approved, etc.).',
+    {
+      boardId: boardIdParam,
+      documentId: resourceIdParam.describe('The document ID'),
+      documentStatus: z.string().describe('New document status'),
+    },
+    async ({ boardId, documentId, documentStatus }) => {
+      try {
+        const response = await client.put(`/api/documents/${boardId}/${documentId}/status`, { documentStatus });
+        return formatResult({ data: response.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    },
+  );
+
+  server.tool(
+    'delete_document',
+    'Deletes a document from a board.',
+    {
+      boardId: boardIdParam,
+      documentId: resourceIdParam.describe('The document ID'),
+    },
+    async ({ boardId, documentId }) => {
+      try {
+        const response = await client.delete(`/api/documents/${boardId}/${documentId}/`);
+        return formatResult({ data: response.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    },
+  );
+
+  server.tool(
+    'create_document_version',
+    'Creates a new version of a document. Requires an external file link (file upload not supported via MCP).',
+    {
+      boardId: boardIdParam,
+      documentId: resourceIdParam.describe('The document ID'),
+      externalFileLink: z.string().describe('HTTPS URL to the new version file'),
+      notes: z.string().optional().describe('Version notes'),
+    },
+    async ({ boardId, documentId, externalFileLink, notes }) => {
+      try {
+        const body: Record<string, unknown> = { externalFileLink };
+        if (notes !== undefined) body.notes = notes;
+        const response = await client.post(`/api/documents/${boardId}/${documentId}/version`, body);
+        return formatResult({ data: response.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    },
+  );
+};

package/src/tools/documents.tools.ts

@@ -0,0 +1,46 @@
+import { z } from 'zod';
+import { boardIdParam, resourceIdParam, paginationParams, buildQueryParams, formatResult, handleToolError, RegisterToolsFn } from './shared.js';
+
+export const registerDocumentTools: RegisterToolsFn = (server, client) => {
+  server.tool(
+    'list_board_documents',
+    'Lists document metadata for a board. Supports filtering by meeting or document type. Does not provide file download in V1.',
+    {
+      boardId: boardIdParam,
+      ...paginationParams,
+      meetingId: z.string().optional().describe('Filter by meeting ID'),
+      documentType: z.string().optional().describe('Filter by document type (e.g. boardResolutions, minutesOfMeetings, capTable)'),
+    },
+    async ({ boardId, ...rest }) => {
+      try {
+        const params = buildQueryParams(rest, ['meetingId', 'documentType']);
+        const result = await client.getCollection(
+          `/api/boards/${boardId}/documents`,
+          params,
+        );
+        return formatResult({ data: result.data, meta: result.meta });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    },
+  );
+
+  server.tool(
+    'get_document',
+    'Returns metadata for a specific document including title, type, and associated meeting. Does not provide file download in V1.',
+    {
+      boardId: boardIdParam,
+      documentId: resourceIdParam.describe('The document ID'),
+    },
+    async ({ boardId, documentId }) => {
+      try {
+        const result = await client.get(
+          `/api/boards/${boardId}/documents/${documentId}`,
+        );
+        return formatResult({ data: result.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    },
+  );
+};

package/src/tools/getMe.tool.ts

@@ -0,0 +1,17 @@
+import { formatResult, handleToolError, RegisterToolsFn } from './shared.js';
+
+export const registerGetMeTool: RegisterToolsFn = (server, client) => {
+  server.tool(
+    'get_me',
+    'Returns the currently authenticated imboard user\'s profile including name, email, and timezone.',
+    {},
+    async () => {
+      try {
+        const response = await client.get('/api/me');
+        return formatResult({ data: response.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    },
+  );
+};

package/src/tools/invites.tools.ts

@@ -0,0 +1,90 @@
+import { z } from 'zod';
+import { boardIdParam, resourceIdParam, formatResult, handleToolError, RegisterToolsFn } from './shared.js';
+
+export const registerInviteTools: RegisterToolsFn = (server, client) => {
+  server.tool(
+    'list_board_invites',
+    'Lists pending invites for a board.',
+    {
+      boardId: boardIdParam,
+    },
+    async ({ boardId }) => {
+      try {
+        const response = await client.get(`/api/invite/${boardId}/invites`);
+        return formatResult({ data: response.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    },
+  );
+
+  server.tool(
+    'create_invite',
+    'Invites a user to a board by email. Optionally include a personal message and board positions.',
+    {
+      boardId: boardIdParam,
+      inviteeEmail: z.string().email().describe('Email address of the person to invite'),
+      message: z.string().optional().describe('Optional personal message included in the invite email'),
+      boardPositions: z.array(z.string()).optional().describe('Board positions to assign to the invitee'),
+    },
+    async ({ boardId, inviteeEmail, message, boardPositions }) => {
+      try {
+        const body: Record<string, unknown> = { inviteeEmail };
+        if (message !== undefined) body.message = message;
+        if (boardPositions !== undefined) body.boardPositions = boardPositions;
+        const response = await client.post(`/api/invite/${boardId}`, body);
+        return formatResult({ data: response.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    },
+  );
+
+  server.tool(
+    'accept_invite',
+    'Accepts a board invite.',
+    {
+      boardInviteId: resourceIdParam.describe('The invite ID'),
+    },
+    async ({ boardInviteId }) => {
+      try {
+        const response = await client.put(`/api/invite/accept/${boardInviteId}`);
+        return formatResult({ data: response.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    },
+  );
+
+  server.tool(
+    'decline_invite',
+    'Declines a board invite.',
+    {
+      boardInviteId: resourceIdParam.describe('The invite ID'),
+    },
+    async ({ boardInviteId }) => {
+      try {
+        const response = await client.put(`/api/invite/decline/${boardInviteId}`);
+        return formatResult({ data: response.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    },
+  );
+
+  server.tool(
+    'retract_invite',
+    'Retracts a sent board invite.',
+    {
+      boardInviteId: resourceIdParam.describe('The invite ID'),
+    },
+    async ({ boardInviteId }) => {
+      try {
+        const response = await client.put(`/api/invite/retract/${boardInviteId}`);
+        return formatResult({ data: response.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    },
+  );
+};

package/src/tools/meetings.tools.ts

@@ -0,0 +1,160 @@
+import { z } from 'zod';
+import { boardIdParam, resourceIdParam, paginationParams, buildQueryParams, formatResult, handleToolError, RegisterToolsFn } from './shared.js';
+
+export const registerMeetingTools: RegisterToolsFn = (server, client) => {
+  server.tool(
+    'list_board_meetings',
+    'Lists meetings for a board. Supports filtering by status and date range, and sorting by start time.',
+    {
+      boardId: boardIdParam,
+      ...paginationParams,
+      sort: z.enum(['updatedAt', 'startTime']).optional().describe('Sort field (default: startTime)'),
+      status: z.string().optional().describe('Filter by meeting status'),
+      startAfter: z.string().optional().describe('ISO-8601 date — only meetings starting after this'),
+      startBefore: z.string().optional().describe('ISO-8601 date — only meetings starting before this'),
+    },
+    async ({ boardId, ...rest }) => {
+      try {
+        const params = buildQueryParams(rest, ['status', 'startAfter', 'startBefore']);
+        const result = await client.getCollection(
+          `/api/boards/${boardId}/meetings`,
+          params,
+        );
+        return formatResult({ data: result.data, meta: result.meta });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    },
+  );
+
+  server.tool(
+    'get_meeting',
+    'Returns details for a specific meeting including title, status, location, and scheduled time.',
+    {
+      boardId: boardIdParam,
+      meetingId: resourceIdParam.describe('The meeting ID'),
+    },
+    async ({ boardId, meetingId }) => {
+      try {
+        const result = await client.get(
+          `/api/boards/${boardId}/meetings/${meetingId}`,
+        );
+        return formatResult({ data: result.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    },
+  );
+
+  server.tool(
+    'create_meeting',
+    'Creates a new meeting on a board. Requires write access. The authenticated user is set as the creator.',
+    {
+      boardId: boardIdParam,
+      title: z.string().describe('Meeting title (max 200 characters)'),
+      status: z.string().describe('Meeting status: draft, planned, scheduled, completed, or finalized'),
+      locationType: z.string().describe('Location type: physical, virtual, or hybrid'),
+      startTime: z.string().describe('Meeting start time as ISO-8601 date string'),
+      endTime: z.string().describe('Meeting end time as ISO-8601 date string'),
+      location: z.string().optional().describe('Physical location (max 255 characters)'),
+      virtualMeetingUrl: z.string().optional().describe('Virtual meeting URL (max 255 characters)'),
+    },
+    async ({ boardId, title, status, locationType, startTime, endTime, location, virtualMeetingUrl }) => {
+      try {
+        const body: Record<string, string> = {
+          title,
+          status,
+          locationType,
+          startTime,
+          endTime,
+        };
+        if (location !== undefined) body.location = location;
+        if (virtualMeetingUrl !== undefined) body.virtualMeetingUrl = virtualMeetingUrl;
+
+        const result = await client.post(
+          `/api/boards/${boardId}/meetings`,
+          body,
+        );
+        return formatResult({ data: result.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    },
+  );
+
+  server.tool(
+    'update_meeting',
+    'Updates an existing meeting. Only the provided fields are changed. Requires write access to the board.',
+    {
+      boardId: boardIdParam,
+      meetingId: resourceIdParam.describe('The meeting ID'),
+      title: z.string().optional().describe('Meeting title (max 200 characters)'),
+      status: z.string().optional().describe('Meeting status: draft, planned, scheduled, completed, or finalized'),
+      locationType: z.string().optional().describe('Location type: physical, virtual, or hybrid'),
+      location: z.string().optional().describe('Physical location (max 255 characters)'),
+      virtualMeetingUrl: z.string().optional().describe('Virtual meeting URL (max 255 characters)'),
+      startTime: z.string().optional().describe('Meeting start time as ISO-8601 date string'),
+      endTime: z.string().optional().describe('Meeting end time as ISO-8601 date string'),
+    },
+    async ({ boardId, meetingId, title, status, locationType, location, virtualMeetingUrl, startTime, endTime }) => {
+      try {
+        const body: Record<string, string> = {};
+        if (title !== undefined) body.title = title;
+        if (status !== undefined) body.status = status;
+        if (locationType !== undefined) body.locationType = locationType;
+        if (location !== undefined) body.location = location;
+        if (virtualMeetingUrl !== undefined) body.virtualMeetingUrl = virtualMeetingUrl;
+        if (startTime !== undefined) body.startTime = startTime;
+        if (endTime !== undefined) body.endTime = endTime;
+
+        const result = await client.patch(
+          `/api/boards/${boardId}/meetings/${meetingId}`,
+          body,
+        );
+        return formatResult({ data: result.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    },
+  );
+
+  server.tool(
+    'delete_meeting',
+    'Deletes a meeting from a board.',
+    {
+      boardId: boardIdParam,
+      meetingId: resourceIdParam.describe('The meeting ID'),
+    },
+    async ({ boardId, meetingId }) => {
+      try {
+        const result = await client.delete(
+          `/api/meetings/${boardId}/${meetingId}/`,
+        );
+        return formatResult({ data: result.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    },
+  );
+
+  server.tool(
+    'change_meeting_status',
+    'Changes meeting status (draft, planned, scheduled, completed, finalized).',
+    {
+      boardId: boardIdParam,
+      meetingId: resourceIdParam.describe('The meeting ID'),
+      meetingStatus: z.string().describe('New meeting status: draft, planned, scheduled, completed, or finalized'),
+    },
+    async ({ boardId, meetingId, meetingStatus }) => {
+      try {
+        const result = await client.put(
+          `/api/meetings/${boardId}/${meetingId}/status`,
+          { meetingStatus },
+        );
+        return formatResult({ data: result.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    },
+  );
+};

package/src/tools/members.tools.ts

@@ -0,0 +1,43 @@
+import { boardIdParam, resourceIdParam, paginationParams, buildQueryParams, formatResult, handleToolError, RegisterToolsFn } from './shared.js';
+
+export const registerMemberTools: RegisterToolsFn = (server, client) => {
+  server.tool(
+    'list_board_members',
+    'Lists members of a board including their roles, access types, and board positions.',
+    {
+      boardId: boardIdParam,
+      ...paginationParams,
+    },
+    async ({ boardId, ...rest }) => {
+      try {
+        const params = buildQueryParams(rest, []);
+        const result = await client.getCollection(
+          `/api/boards/${boardId}/members`,
+          params,
+        );
+        return formatResult({ data: result.data, meta: result.meta });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    },
+  );
+
+  server.tool(
+    'get_board_member',
+    'Returns details for a specific board member including their role, access type, and board positions.',
+    {
+      boardId: boardIdParam,
+      memberId: resourceIdParam.describe('The member ID'),
+    },
+    async ({ boardId, memberId }) => {
+      try {
+        const result = await client.get(
+          `/api/boards/${boardId}/members/${memberId}`,
+        );
+        return formatResult({ data: result.data });
+      } catch (error) {
+        return handleToolError(error);
+      }
+    },
+  );
+};