backlog-mcp-server 0.4.0

package/build/tools/getNotificationsCount.js

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import { buildToolSchema } from '../types/tool.js';
+import { NotificationCountSchema } from '../types/zod/backlogOutputDefinition.js';
+const getNotificationsCountSchema = buildToolSchema((t) => ({
+    alreadyRead: z
+        .boolean()
+        .describe(t('TOOL_GET_NOTIFICATIONS_COUNT_ALREADY_READ', 'Whether to include already read notifications')),
+    resourceAlreadyRead: z
+        .boolean()
+        .describe(t('TOOL_GET_NOTIFICATIONS_COUNT_RESOURCE_ALREADY_READ', 'Whether to include notifications for already read resources')),
+}));
+export const getNotificationsCountTool = (backlog, { t }) => {
+    return {
+        name: 'count_notifications',
+        description: t('TOOL_COUNT_NOTIFICATIONS_DESCRIPTION', 'Returns count of notifications'),
+        schema: z.object(getNotificationsCountSchema(t)),
+        outputSchema: NotificationCountSchema,
+        handler: async (params) => backlog.getNotificationsCount(params),
+    };
+};

package/build/tools/getPriorities.js

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+import { buildToolSchema } from '../types/tool.js';
+import { PrioritySchema } from '../types/zod/backlogOutputDefinition.js';
+const getPrioritiesSchema = buildToolSchema((_t) => ({}));
+export const getPrioritiesTool = (backlog, { t }) => {
+    return {
+        name: 'get_priorities',
+        description: t('TOOL_GET_PRIORITIES_DESCRIPTION', 'Returns list of priorities'),
+        schema: z.object(getPrioritiesSchema(t)),
+        outputSchema: PrioritySchema,
+        handler: async () => backlog.getPriorities(),
+    };
+};

package/build/tools/getProject.js

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+import { buildToolSchema } from '../types/tool.js';
+import { ProjectSchema } from '../types/zod/backlogOutputDefinition.js';
+import { resolveIdOrKey } from '../utils/resolveIdOrKey.js';
+const getProjectSchema = buildToolSchema((t) => ({
+    projectId: z
+        .number()
+        .optional()
+        .describe(t('TOOL_GET_PROJECT_PROJECT_ID', 'The numeric ID of the project (e.g., 12345)')),
+    projectKey: z
+        .string()
+        .optional()
+        .describe(t('TOOL_GET_PROJECT_PROJECT_KEY', "The key of the project (e.g., 'PROJECT')")),
+}));
+export const getProjectTool = (backlog, { t }) => {
+    return {
+        name: 'get_project',
+        description: t('TOOL_GET_PROJECT_DESCRIPTION', 'Returns information about a specific project'),
+        schema: z.object(getProjectSchema(t)),
+        outputSchema: ProjectSchema,
+        handler: async ({ projectId, projectKey }) => {
+            const result = resolveIdOrKey('project', { id: projectId, key: projectKey }, t);
+            if (!result.ok) {
+                throw result.error;
+            }
+            return backlog.getProject(result.value);
+        },
+    };
+};

package/build/tools/getProjectList.js

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+import { buildToolSchema } from '../types/tool.js';
+import { ProjectSchema } from '../types/zod/backlogOutputDefinition.js';
+const getProjectListSchema = buildToolSchema((t) => ({
+    archived: z
+        .boolean()
+        .optional()
+        .describe(t('TOOL_GET_PROJECT_LIST_ARCHIVED', 'For unspecified parameters, this form returns all projects. For ‘false’ parameters, it returns unarchived projects. For ‘true’ parameters, it returns archived projects.')),
+    all: z
+        .boolean()
+        .optional()
+        .describe(t('TOOL_GET_PROJECT_LIST_ALL', 'Only applies to administrators. If ‘true,’ it returns all projects. If ‘false,’ it returns only projects they have joined.')),
+}));
+export const getProjectListTool = (backlog, { t }) => {
+    return {
+        name: 'get_project_list',
+        description: t('TOOL_GET_PROJECT_LIST_DESCRIPTION', 'Returns list of projects'),
+        schema: z.object(getProjectListSchema(t)),
+        outputSchema: ProjectSchema,
+        importantFields: ['id', 'projectKey', 'name'],
+        handler: async ({ archived, all }) => backlog.getProjects({ archived, all }),
+    };
+};

package/build/tools/getPullRequest.js

@@ -0,0 +1,44 @@
+import { z } from 'zod';
+import { buildToolSchema } from '../types/tool.js';
+import { PullRequestSchema } from '../types/zod/backlogOutputDefinition.js';
+import { resolveIdOrKey, resolveIdOrName } from '../utils/resolveIdOrKey.js';
+const getPullRequestSchema = buildToolSchema((t) => ({
+    projectId: z
+        .number()
+        .optional()
+        .describe(t('TOOL_GET_PULL_REQUEST_PROJECT_ID', 'The numeric ID of the project (e.g., 12345)')),
+    projectKey: z
+        .string()
+        .optional()
+        .describe(t('TOOL_GET_PULL_REQUEST_PROJECT_KEY', "The key of the project (e.g., 'PROJECT')")),
+    repoId: z
+        .number()
+        .optional()
+        .describe(t('TOOL_GET_PULL_REQUEST_REPO_ID', 'Repository ID')),
+    repoName: z
+        .string()
+        .optional()
+        .describe(t('TOOL_GET_PULL_REQUEST_REPO_NAME', 'Repository name')),
+    number: z
+        .number()
+        .describe(t('TOOL_GET_PULL_REQUEST_NUMBER', 'Pull request number')),
+}));
+export const getPullRequestTool = (backlog, { t }) => {
+    return {
+        name: 'get_pull_request',
+        description: t('TOOL_GET_PULL_REQUEST_DESCRIPTION', 'Returns information about a specific pull request'),
+        schema: z.object(getPullRequestSchema(t)),
+        outputSchema: PullRequestSchema,
+        handler: async ({ projectId, projectKey, repoId, repoName, number }) => {
+            const result = resolveIdOrKey('project', { id: projectId, key: projectKey }, t);
+            if (!result.ok) {
+                throw result.error;
+            }
+            const repoRes = resolveIdOrName('repository', { id: repoId, name: repoName }, t);
+            if (!repoRes.ok) {
+                throw repoRes.error;
+            }
+            return backlog.getPullRequest(result.value, String(repoRes.value), number);
+        },
+    };
+};

package/build/tools/getPullRequestComments.js

@@ -0,0 +1,60 @@
+import { z } from 'zod';
+import { buildToolSchema } from '../types/tool.js';
+import { PullRequestCommentSchema } from '../types/zod/backlogOutputDefinition.js';
+import { resolveIdOrKey, resolveIdOrName } from '../utils/resolveIdOrKey.js';
+const getPullRequestCommentsSchema = buildToolSchema((t) => ({
+    projectId: z
+        .number()
+        .optional()
+        .describe(t('TOOL_GET_PROJECT_PROJECT_ID', 'The numeric ID of the project (e.g., 12345)')),
+    projectKey: z
+        .string()
+        .optional()
+        .describe(t('TOOL_GET_PROJECT_PROJECT_KEY', "The key of the project (e.g., 'PROJECT')")),
+    repoId: z
+        .number()
+        .optional()
+        .describe(t('TOOL_GET_PULL_REQUEST_COMMENTS_REPO_ID_OR_NAME', 'Repository ID')),
+    repoName: z
+        .string()
+        .optional()
+        .describe(t('TOOL_GET_PULL_REQUEST_COMMENTS_REPO_ID_OR_NAME', 'Repository name')),
+    number: z
+        .number()
+        .describe(t('TOOL_GET_PULL_REQUEST_COMMENTS_NUMBER', 'Pull request number')),
+    minId: z
+        .number()
+        .optional()
+        .describe(t('TOOL_GET_PULL_REQUEST_COMMENTS_MIN_ID', 'Minimum comment ID')),
+    maxId: z
+        .number()
+        .optional()
+        .describe(t('TOOL_GET_PULL_REQUEST_COMMENTS_MAX_ID', 'Maximum comment ID')),
+    count: z
+        .number()
+        .optional()
+        .describe(t('TOOL_GET_PULL_REQUEST_COMMENTS_COUNT', 'Number of comments to retrieve')),
+    order: z
+        .enum(['asc', 'desc'])
+        .optional()
+        .describe(t('TOOL_GET_PULL_REQUEST_COMMENTS_ORDER', 'Sort order')),
+}));
+export const getPullRequestCommentsTool = (backlog, { t }) => {
+    return {
+        name: 'get_pull_request_comments',
+        description: t('TOOL_GET_PULL_REQUEST_COMMENTS_DESCRIPTION', 'Returns list of comments for a pull request'),
+        schema: z.object(getPullRequestCommentsSchema(t)),
+        outputSchema: PullRequestCommentSchema,
+        handler: async ({ projectId, projectKey, repoId, repoName, number, ...params }) => {
+            const result = resolveIdOrKey('project', { id: projectId, key: projectKey }, t);
+            if (!result.ok) {
+                throw result.error;
+            }
+            const repoResult = resolveIdOrName('repository', { id: repoId, name: repoName }, t);
+            if (!repoResult.ok) {
+                throw repoResult.error;
+            }
+            return backlog.getPullRequestComments(result.value, String(repoResult.value), number, params);
+        },
+    };
+};

package/build/tools/getPullRequests.js

@@ -0,0 +1,65 @@
+import { z } from 'zod';
+import { buildToolSchema } from '../types/tool.js';
+import { PullRequestSchema } from '../types/zod/backlogOutputDefinition.js';
+import { resolveIdOrKey, resolveIdOrName } from '../utils/resolveIdOrKey.js';
+const getPullRequestsSchema = buildToolSchema((t) => ({
+    projectId: z
+        .number()
+        .optional()
+        .describe(t('TOOL_GET_PULL_REQUESTS_PROJECT_ID', 'The numeric ID of the project (e.g., 12345)')),
+    projectKey: z
+        .string()
+        .optional()
+        .describe(t('TOOL_GET_PULL_REQUESTS_PROJECT_KEY', "The key of the project (e.g., 'PROJECT')")),
+    repoId: z
+        .number()
+        .optional()
+        .describe(t('TOOL_GET_PULL_REQUESTS_REPO_ID', 'Repository ID')),
+    repoName: z
+        .string()
+        .optional()
+        .describe(t('TOOL_GET_PULL_REQUESTS_REPO_NAME', 'Repository name')),
+    statusId: z
+        .array(z.number())
+        .optional()
+        .describe(t('TOOL_GET_PULL_REQUESTS_STATUS_ID', 'Status IDs')),
+    assigneeId: z
+        .array(z.number())
+        .optional()
+        .describe(t('TOOL_GET_PULL_REQUESTS_ASSIGNEE_ID', 'Assignee user IDs')),
+    issueId: z
+        .array(z.number())
+        .optional()
+        .describe(t('TOOL_GET_PULL_REQUESTS_ISSUE_ID', 'Issue IDs')),
+    createdUserId: z
+        .array(z.number())
+        .optional()
+        .describe(t('TOOL_GET_PULL_REQUESTS_CREATED_USER_ID', 'Created user IDs')),
+    offset: z
+        .number()
+        .optional()
+        .describe(t('TOOL_GET_PULL_REQUESTS_OFFSET', 'Offset for pagination')),
+    count: z
+        .number()
+        .optional()
+        .describe(t('TOOL_GET_PULL_REQUESTS_COUNT', 'Number of pull requests to retrieve')),
+}));
+export const getPullRequestsTool = (backlog, { t }) => {
+    return {
+        name: 'get_pull_requests',
+        description: t('TOOL_GET_PULL_REQUESTS_DESCRIPTION', 'Returns list of pull requests for a repository'),
+        schema: z.object(getPullRequestsSchema(t)),
+        outputSchema: PullRequestSchema,
+        handler: async ({ projectId, projectKey, repoId, repoName, ...params }) => {
+            const result = resolveIdOrKey('project', { id: projectId, key: projectKey }, t);
+            if (!result.ok) {
+                throw result.error;
+            }
+            const repoResult = resolveIdOrName('repository', { id: repoId, name: repoName }, t);
+            if (!repoResult.ok) {
+                throw repoResult.error;
+            }
+            return backlog.getPullRequests(result.value, String(repoResult.value), params);
+        },
+    };
+};

package/build/tools/getPullRequestsCount.js

@@ -0,0 +1,57 @@
+import { z } from 'zod';
+import { buildToolSchema } from '../types/tool.js';
+import { PullRequestCountSchema } from '../types/zod/backlogOutputDefinition.js';
+import { resolveIdOrKey, resolveIdOrName } from '../utils/resolveIdOrKey.js';
+const getPullRequestsCountSchema = buildToolSchema((t) => ({
+    projectId: z
+        .number()
+        .optional()
+        .describe(t('TOOL_GET_PULL_REQUESTS_COUNT_PROJECT_ID', 'The numeric ID of the project (e.g., 12345)')),
+    projectKey: z
+        .string()
+        .optional()
+        .describe(t('TOOL_GET_PULL_REQUESTS_COUNT_PROJECT_KEY', "The key of the project (e.g., 'PROJECT')")),
+    repoId: z
+        .number()
+        .optional()
+        .describe(t('TOOL_GET_PULL_REQUESTS_COUNT_REPO_ID', 'Repository ID')),
+    repoName: z
+        .string()
+        .optional()
+        .describe(t('TOOL_GET_PULL_REQUESTS_COUNT_REPO_NAME', 'Repository name')),
+    statusId: z
+        .array(z.number())
+        .optional()
+        .describe(t('TOOL_GET_PULL_REQUESTS_COUNT_STATUS_ID', 'Status IDs')),
+    assigneeId: z
+        .array(z.number())
+        .optional()
+        .describe(t('TOOL_GET_PULL_REQUESTS_COUNT_ASSIGNEE_ID', 'Assignee user IDs')),
+    issueId: z
+        .array(z.number())
+        .optional()
+        .describe(t('TOOL_GET_PULL_REQUESTS_COUNT_ISSUE_ID', 'Issue IDs')),
+    createdUserId: z
+        .array(z.number())
+        .optional()
+        .describe(t('TOOL_GET_PULL_REQUESTS_COUNT_CREATED_USER_ID', 'Created user IDs')),
+}));
+export const getPullRequestsCountTool = (backlog, { t }) => {
+    return {
+        name: 'get_pull_requests_count',
+        description: t('TOOL_GET_PULL_REQUESTS_COUNT_DESCRIPTION', 'Returns count of pull requests for a repository'),
+        schema: z.object(getPullRequestsCountSchema(t)),
+        outputSchema: PullRequestCountSchema,
+        handler: async ({ projectId, projectKey, repoId, repoName, ...params }) => {
+            const result = resolveIdOrKey('project', { id: projectId, key: projectKey }, t);
+            if (!result.ok) {
+                throw result.error;
+            }
+            const repoResult = resolveIdOrName('repository', { id: repoId, name: repoName }, t);
+            if (!repoResult.ok) {
+                throw repoResult.error;
+            }
+            return backlog.getPullRequestsCount(result.value, String(repoResult.value), params);
+        },
+    };
+};

package/build/tools/getResolutions.js

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+import { buildToolSchema } from '../types/tool.js';
+import { ResolutionSchema } from '../types/zod/backlogOutputDefinition.js';
+const getResolutionsSchema = buildToolSchema((_t) => ({}));
+export const getResolutionsTool = (backlog, { t }) => {
+    return {
+        name: 'get_resolutions',
+        description: t('TOOL_GET_RESOLUTIONS_DESCRIPTION', 'Returns list of issue resolutions'),
+        schema: z.object(getResolutionsSchema(t)),
+        outputSchema: ResolutionSchema,
+        handler: async () => backlog.getResolutions(),
+    };
+};

package/build/tools/getSpace.js

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import { buildToolSchema } from '../types/tool.js';
+import { SpaceSchema } from '../types/zod/backlogOutputDefinition.js';
+const getSpaceSchema = buildToolSchema((_t) => ({}));
+export const getSpaceTool = (backlog, { t }) => {
+    return {
+        name: 'get_space',
+        description: t('TOOL_GET_SPACE_DESCRIPTION', 'Returns information about the Backlog space'),
+        schema: z.object(getSpaceSchema(t)),
+        outputSchema: SpaceSchema,
+        importantFields: ['spaceKey', 'name', 'lang', 'timezone'],
+        handler: async () => backlog.getSpace(),
+    };
+};

package/build/tools/getUsers.js

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import { buildToolSchema } from '../types/tool.js';
+import { UserSchema } from '../types/zod/backlogOutputDefinition.js';
+const getUsersSchema = buildToolSchema((_t) => ({}));
+export const getUsersTool = (backlog, { t }) => {
+    return {
+        name: 'get_users',
+        description: t('TOOL_GET_USERS_DESCRIPTION', 'Returns list of users in the Backlog space'),
+        schema: z.object(getUsersSchema(t)),
+        outputSchema: UserSchema,
+        importantFields: ['userId', 'name', 'roleType', 'lang'],
+        handler: async () => backlog.getUsers(),
+    };
+};

package/build/tools/getWatchingListCount.js

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { buildToolSchema } from '../types/tool.js';
+import { WatchingListCountSchema } from '../types/zod/backlogOutputDefinition.js';
+const getWatchingListCountSchema = buildToolSchema((t) => ({
+    userId: z
+        .number()
+        .describe(t('TOOL_GET_WATCHING_LIST_COUNT_USER_ID', 'User ID')),
+}));
+export const getWatchingListCountTool = (backlog, { t }) => {
+    return {
+        name: 'get_watching_list_count',
+        description: t('TOOL_GET_WATCHING_LIST_COUNT_DESCRIPTION', 'Returns count of watching items for a user'),
+        schema: z.object(getWatchingListCountSchema(t)),
+        outputSchema: WatchingListCountSchema,
+        handler: async ({ userId }) => backlog.getWatchingListCount(userId),
+    };
+};

package/build/tools/getWatchingListItems.js

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { buildToolSchema } from '../types/tool.js';
+import { WatchingListItemSchema } from '../types/zod/backlogOutputDefinition.js';
+const getWatchingListItemsSchema = buildToolSchema((t) => ({
+    userId: z
+        .number()
+        .describe(t('TOOL_GET_WATCHING_LIST_ITEMS_USER_ID', 'User ID')),
+}));
+export const getWatchingListItemsTool = (backlog, { t }) => {
+    return {
+        name: 'get_watching_list_items',
+        description: t('TOOL_GET_WATCHING_LIST_ITEMS_DESCRIPTION', 'Returns list of watching items for a user'),
+        schema: z.object(getWatchingListItemsSchema(t)),
+        outputSchema: WatchingListItemSchema,
+        handler: async ({ userId }) => backlog.getWatchingListItems(userId),
+    };
+};

package/build/tools/getWiki.js

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+import { buildToolSchema } from '../types/tool.js';
+import { WikiSchema } from '../types/zod/backlogOutputDefinition.js';
+const getWikiSchema = buildToolSchema((t) => ({
+    wikiId: z
+        .union([z.string(), z.number()])
+        .describe(t('TOOL_GET_WIKI_ID', 'Wiki ID')),
+}));
+export const getWikiTool = (backlog, { t }) => {
+    return {
+        name: 'get_wiki',
+        description: t('TOOL_GET_WIKI_DESCRIPTION', 'Returns information about a specific wiki page'),
+        schema: z.object(getWikiSchema(t)),
+        outputSchema: WikiSchema,
+        importantFields: ['id', 'projectId', 'name', 'content'],
+        handler: async ({ wikiId }) => {
+            const wikiIdNumber = typeof wikiId === 'string' ? parseInt(wikiId, 10) : wikiId;
+            return backlog.getWiki(wikiIdNumber);
+        },
+    };
+};

package/build/tools/getWikiPages.js

@@ -0,0 +1,37 @@
+import { z } from 'zod';
+import { buildToolSchema } from '../types/tool.js';
+import { WikiListItemSchema } from '../types/zod/backlogOutputDefinition.js';
+import { resolveIdOrKey } from '../utils/resolveIdOrKey.js';
+const getWikiPagesSchema = buildToolSchema((t) => ({
+    projectId: z
+        .number()
+        .optional()
+        .describe(t('TOOL_GET_WIKI_PAGES_PROJECT_ID', 'The numeric ID of the project (e.g., 12345)')),
+    projectKey: z
+        .string()
+        .optional()
+        .describe(t('TOOL_GET_WIKI_PAGES_PROJECT_KEY', "The key of the project (e.g., 'PROJECT')")),
+    keyword: z
+        .string()
+        .optional()
+        .describe(t('TOOL_GET_WIKI_PAGES_KEYWORD', 'Keyword to search for in Wiki pages')),
+}));
+export const getWikiPagesTool = (backlog, { t }) => {
+    return {
+        name: 'get_wiki_pages',
+        description: t('TOOL_GET_WIKI_PAGES_DESCRIPTION', 'Returns list of Wiki pages'),
+        schema: z.object(getWikiPagesSchema(t)),
+        outputSchema: WikiListItemSchema,
+        importantFields: ['projectId', 'name', 'tags'],
+        handler: async ({ projectId, projectKey, keyword }) => {
+            const result = resolveIdOrKey('project', { id: projectId, key: projectKey }, t);
+            if (!result.ok) {
+                throw result.error;
+            }
+            return backlog.getWikis({
+                projectIdOrKey: result.value,
+                keyword,
+            });
+        },
+    };
+};

package/build/tools/getWikisCount.js

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+import { buildToolSchema } from '../types/tool.js';
+import { WikiCountSchema } from '../types/zod/backlogOutputDefinition.js';
+import { resolveIdOrKey } from '../utils/resolveIdOrKey.js';
+const getWikisCountSchema = buildToolSchema((t) => ({
+    projectId: z
+        .number()
+        .optional()
+        .describe(t('TOOL_GET_WIKIS_COUNT_PROJECT_ID', 'The numeric ID of the project (e.g., 12345)')),
+    projectKey: z
+        .string()
+        .optional()
+        .describe(t('TOOL_GET_WIKIS_COUNT_PROJECT_KEY', "The key of the project (e.g., 'PROJECT')")),
+}));
+export const getWikisCountTool = (backlog, { t }) => {
+    return {
+        name: 'get_wikis_count',
+        description: t('TOOL_GET_WIKIS_COUNT_DESCRIPTION', 'Returns count of wiki pages in a project'),
+        schema: z.object(getWikisCountSchema(t)),
+        outputSchema: WikiCountSchema,
+        handler: async ({ projectId, projectKey }) => {
+            const result = resolveIdOrKey('project', { id: projectId, key: projectKey }, t);
+            if (!result.ok) {
+                throw result.error;
+            }
+            return backlog.getWikisCount(result.value);
+        },
+    };
+};

package/build/tools/markNotificationAsRead.js

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+import { buildToolSchema } from '../types/tool.js';
+const markNotificationAsReadSchema = buildToolSchema((t) => ({
+    id: z
+        .number()
+        .describe(t('TOOL_MARK_NOTIFICATION_AS_READ_ID', 'Notification ID to mark as read')),
+}));
+export const MarkNotificationAsReadResultSchema = z.object({
+    success: z.boolean(),
+    message: z.string(),
+});
+export const markNotificationAsReadTool = (backlog, { t }) => {
+    return {
+        name: 'mark_notification_as_read',
+        description: t('TOOL_MARK_NOTIFICATION_AS_READ_DESCRIPTION', 'Mark a notification as read'),
+        schema: z.object(markNotificationAsReadSchema(t)),
+        outputSchema: MarkNotificationAsReadResultSchema,
+        handler: async ({ id }) => {
+            await backlog.markAsReadNotification(id);
+            return {
+                success: true,
+                message: `Notification ${id} marked as read`,
+            };
+        },
+    };
+};

package/build/tools/resetUnreadNotificationCount.js

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+import { buildToolSchema } from '../types/tool.js';
+import { NotificationCountSchema } from '../types/zod/backlogOutputDefinition.js';
+const resetUnreadNotificationCountSchema = buildToolSchema((_t) => ({}));
+export const resetUnreadNotificationCountTool = (backlog, { t }) => {
+    return {
+        name: 'reset_unread_notification_count',
+        description: t('TOOL_RESET_UNREAD_NOTIFICATION_COUNT_DESCRIPTION', 'Reset unread notification count'),
+        schema: z.object(resetUnreadNotificationCountSchema(t)),
+        outputSchema: NotificationCountSchema,
+        handler: async () => backlog.resetNotificationsMarkAsRead(),
+    };
+};