backlog-mcp-server 0.17.0 → 0.18.1

package/build/tools/getWikiPages.js

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { buildToolSchema } from '../types/tool.js';
-import { WikiListItemSchema } from '../types/zod/backlogOutputDefinition.js';
+import { outputFields } from '../types/outputFields.js';
 import { resolveIdOrKey } from '../utils/resolveIdOrKey.js';
 const getWikiPagesSchema = buildToolSchema((t) => ({
     projectId: z
@@ -21,7 +21,17 @@ export const getWikiPagesTool = (backlog, { t }) => {
         name: 'get_wiki_pages',
         description: t('TOOL_GET_WIKI_PAGES_DESCRIPTION', 'Returns list of Wiki pages'),
         schema: z.object(getWikiPagesSchema(t)),
-        outputSchema: WikiListItemSchema,
+        returnsList: true,
+        outputFields: outputFields()([
+            'id',
+            'projectId',
+            'name',
+            'tags',
+            'createdUser',
+            'created',
+            'updatedUser',
+            'updated',
+        ]),
         importantFields: ['projectId', 'name', 'tags'],
         handler: async ({ projectId, projectKey, keyword }) => {
             const result = resolveIdOrKey('project', { id: projectId, key: projectKey }, t);

package/build/tools/getWikisCount.d.ts

@@ -1,11 +1,11 @@
 import { z } from 'zod';
+import type { Entity } from 'backlog-js';
 import { Backlog } from 'backlog-js';
 import { ToolDefinition } from '../types/tool.js';
 import { DescriptionHelper } from '../createDescriptionHelper.js';
-import { WikiCountSchema } from '../types/zod/backlogOutputDefinition.js';
-declare const getWikisCountSchema: (t: DescriptionHelper["t"]) => {
+declare const getWikisCountSchema: (t: DescriptionHelper['t']) => {
     projectId: z.ZodOptional<z.ZodNumber>;
     projectKey: z.ZodOptional<z.ZodString>;
 };
-export declare const getWikisCountTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof getWikisCountSchema>, (typeof WikiCountSchema)["shape"]>;
+export declare const getWikisCountTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof getWikisCountSchema>, Entity.Wiki.WikiCount>;
 export {};

package/build/tools/getWikisCount.js

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { buildToolSchema } from '../types/tool.js';
-import { WikiCountSchema } from '../types/zod/backlogOutputDefinition.js';
+import { outputFields } from '../types/outputFields.js';
 import { resolveIdOrKey } from '../utils/resolveIdOrKey.js';
 const getWikisCountSchema = buildToolSchema((t) => ({
     projectId: z
@@ -17,7 +17,8 @@ export const getWikisCountTool = (backlog, { t }) => {
         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,
+        returnsList: false,
+        outputFields: outputFields()(['count']),
         handler: async ({ projectId, projectKey }) => {
             const result = resolveIdOrKey('project', { id: projectId, key: projectKey }, t);
             if (!result.ok) {

package/build/tools/markNotificationAsRead.d.ts

@@ -1,13 +1,18 @@
 import { z } from 'zod';
 import { Backlog } from 'backlog-js';
 import { ToolDefinition } from '../types/tool.js';
+/** This tool reports its own outcome; the Backlog call returns nothing. */
+type MarkNotificationAsReadResult = {
+    success: boolean;
+    message: string;
+};
 import { DescriptionHelper } from '../createDescriptionHelper.js';
-declare const markNotificationAsReadSchema: (t: DescriptionHelper["t"]) => {
+declare const markNotificationAsReadSchema: (t: DescriptionHelper['t']) => {
     id: z.ZodNumber;
 };
 export declare const MarkNotificationAsReadResultSchema: z.ZodObject<{
     success: z.ZodBoolean;
     message: z.ZodString;
 }, z.core.$strip>;
-export declare const markNotificationAsReadTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof markNotificationAsReadSchema>, (typeof MarkNotificationAsReadResultSchema)["shape"]>;
+export declare const markNotificationAsReadTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof markNotificationAsReadSchema>, MarkNotificationAsReadResult>;
 export {};

package/build/tools/markNotificationAsRead.js

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { buildToolSchema } from '../types/tool.js';
+import { outputFields } from '../types/outputFields.js';
 const markNotificationAsReadSchema = buildToolSchema((t) => ({
     id: z
         .number()
@@ -14,7 +15,11 @@ export const markNotificationAsReadTool = (backlog, { t }) => {
         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,
+        returnsList: false,
+        outputFields: outputFields()([
+            'success',
+            'message',
+        ]),
         handler: async ({ id }) => {
             await backlog.markAsReadNotification(id);
             return {

package/build/tools/markWatchingAsRead.d.ts

@@ -1,13 +1,18 @@
 import { z } from 'zod';
 import { Backlog } from 'backlog-js';
 import { ToolDefinition } from '../types/tool.js';
+/** This tool reports its own outcome; the Backlog call returns nothing. */
+type MarkWatchingAsReadResult = {
+    success: boolean;
+    message: string;
+};
 import { DescriptionHelper } from '../createDescriptionHelper.js';
-declare const markWatchingAsReadSchema: (t: DescriptionHelper["t"]) => {
+declare const markWatchingAsReadSchema: (t: DescriptionHelper['t']) => {
     watchId: z.ZodNumber;
 };
 export declare const MarkWatchingAsReadResultSchema: z.ZodObject<{
     success: z.ZodBoolean;
     message: z.ZodString;
 }, z.core.$strip>;
-export declare const markWatchingAsReadTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof markWatchingAsReadSchema>, (typeof MarkWatchingAsReadResultSchema)["shape"]>;
+export declare const markWatchingAsReadTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof markWatchingAsReadSchema>, MarkWatchingAsReadResult>;
 export {};

package/build/tools/markWatchingAsRead.js

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { buildToolSchema } from '../types/tool.js';
+import { outputFields } from '../types/outputFields.js';
 const markWatchingAsReadSchema = buildToolSchema((t) => ({
     watchId: z
         .number()
@@ -14,7 +15,11 @@ export const markWatchingAsReadTool = (backlog, { t }) => {
         name: 'mark_watching_as_read',
         description: t('TOOL_MARK_WATCHING_AS_READ_DESCRIPTION', 'Mark a watch as read'),
         schema: z.object(markWatchingAsReadSchema(t)),
-        outputSchema: MarkWatchingAsReadResultSchema,
+        returnsList: false,
+        outputFields: outputFields()([
+            'success',
+            'message',
+        ]),
         handler: async ({ watchId }) => {
             await backlog.resetWatchingListItemAsRead(watchId);
             return {

package/build/tools/removeRelatedIssue.d.ts

@@ -1,12 +1,12 @@
 import { z } from 'zod';
+import type { Entity } from 'backlog-js';
 import { Backlog } from 'backlog-js';
 import { ToolDefinition } from '../types/tool.js';
 import { DescriptionHelper } from '../createDescriptionHelper.js';
-import { RelatedIssueSchema } from '../types/zod/backlogOutputDefinition.js';
-declare const removeRelatedIssueSchema: (t: DescriptionHelper["t"]) => {
+declare const removeRelatedIssueSchema: (t: DescriptionHelper['t']) => {
     issueId: z.ZodOptional<z.ZodNumber>;
     issueKey: z.ZodOptional<z.ZodString>;
     relatedIssueId: z.ZodNumber;
 };
-export declare const removeRelatedIssueTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof removeRelatedIssueSchema>, (typeof RelatedIssueSchema)["shape"]>;
+export declare const removeRelatedIssueTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof removeRelatedIssueSchema>, Entity.Issue.RelatedIssue>;
 export {};

package/build/tools/removeRelatedIssue.js

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { buildToolSchema } from '../types/tool.js';
-import { RelatedIssueSchema } from '../types/zod/backlogOutputDefinition.js';
+import { outputFields } from '../types/outputFields.js';
 import { resolveIdOrKey } from '../utils/resolveIdOrKey.js';
 const removeRelatedIssueSchema = buildToolSchema((t) => ({
     issueId: z
@@ -20,7 +20,38 @@ export const removeRelatedIssueTool = (backlog, { t }) => {
         name: 'remove_related_issue',
         description: t('TOOL_REMOVE_RELATED_ISSUE_DESCRIPTION', 'Removes the relation between an issue and a related issue'),
         schema: z.object(removeRelatedIssueSchema(t)),
-        outputSchema: RelatedIssueSchema,
+        returnsList: false,
+        outputFields: outputFields()([
+            'id',
+            'projectId',
+            'issueKey',
+            'keyId',
+            'issueType',
+            'summary',
+            'description',
+            'resolution',
+            'priority',
+            'status',
+            'assignee',
+            'category',
+            'versions',
+            'milestone',
+            'startDate',
+            'dueDate',
+            'estimatedHours',
+            'actualHours',
+            'parentIssueId',
+            'createdUser',
+            'created',
+            'updatedUser',
+            'updated',
+            'customFields',
+            'attachments',
+            'sharedFiles',
+            'stars',
+            'childIssueSummary',
+            'type',
+        ]),
         handler: async ({ issueId, issueKey, relatedIssueId }) => {
             const result = resolveIdOrKey('issue', { id: issueId, key: issueKey }, t);
             if (!result.ok) {

package/build/tools/resetUnreadNotificationCount.d.ts

@@ -1,7 +1,7 @@
+import type { Entity } from 'backlog-js';
 import { Backlog } from 'backlog-js';
 import { ToolDefinition } from '../types/tool.js';
 import { DescriptionHelper } from '../createDescriptionHelper.js';
-import { NotificationCountSchema } from '../types/zod/backlogOutputDefinition.js';
-declare const resetUnreadNotificationCountSchema: (t: DescriptionHelper["t"]) => {};
-export declare const resetUnreadNotificationCountTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof resetUnreadNotificationCountSchema>, (typeof NotificationCountSchema)["shape"]>;
+declare const resetUnreadNotificationCountSchema: (t: DescriptionHelper['t']) => {};
+export declare const resetUnreadNotificationCountTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof resetUnreadNotificationCountSchema>, Entity.Notification.NotificationCount>;
 export {};

package/build/tools/resetUnreadNotificationCount.js

@@ -1,13 +1,16 @@
 import { z } from 'zod';
 import { buildToolSchema } from '../types/tool.js';
-import { NotificationCountSchema } from '../types/zod/backlogOutputDefinition.js';
+import { outputFields } from '../types/outputFields.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,
+        returnsList: false,
+        outputFields: outputFields()([
+            'count',
+        ]),
         handler: async () => backlog.resetNotificationsMarkAsRead(),
     };
 };

package/build/tools/shared/customFieldFiltersSchema.d.ts

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { DescriptionHelper } from '../../createDescriptionHelper.js';
-export declare const buildCustomFieldFilterSchema: (t: DescriptionHelper["t"]) => z.ZodDiscriminatedUnion<[z.ZodObject<{
+export declare const buildCustomFieldFilterSchema: (t: DescriptionHelper['t']) => z.ZodDiscriminatedUnion<[z.ZodObject<{
     type: z.ZodLiteral<"text">;
     id: z.ZodNumber;
     value: z.ZodString;

package/build/tools/updateIssue.d.ts

@@ -1,9 +1,9 @@
 import { z } from 'zod';
 import { Backlog } from 'backlog-js';
+import type { Entity } from 'backlog-js';
 import { ToolDefinition } from '../types/tool.js';
 import { DescriptionHelper } from '../createDescriptionHelper.js';
-import { IssueSchema } from '../types/zod/backlogOutputDefinition.js';
-declare const updateIssueSchema: (t: DescriptionHelper["t"]) => {
+declare const updateIssueSchema: (t: DescriptionHelper['t']) => {
     issueId: z.ZodOptional<z.ZodNumber>;
     issueKey: z.ZodOptional<z.ZodString>;
     summary: z.ZodOptional<z.ZodString>;
@@ -30,5 +30,5 @@ declare const updateIssueSchema: (t: DescriptionHelper["t"]) => {
         otherValue: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>>;
 };
-export declare const updateIssueTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof updateIssueSchema>, (typeof IssueSchema)["shape"]>;
+export declare const updateIssueTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof updateIssueSchema>, Entity.Issue.Issue>;
 export {};

package/build/tools/updateIssue.js

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { buildToolSchema } from '../types/tool.js';
-import { IssueSchema } from '../types/zod/backlogOutputDefinition.js';
+import { outputFields } from '../types/outputFields.js';
 import { resolveIdOrKey } from '../utils/resolveIdOrKey.js';
 import { customFieldsToPayload } from '../backlog/customFields.js';
 const updateIssueSchema = buildToolSchema((t) => ({
@@ -135,7 +135,37 @@ export const updateIssueTool = (backlog, { t }) => {
         name: 'update_issue',
         description: t('TOOL_UPDATE_ISSUE_DESCRIPTION', 'Updates an existing issue'),
         schema: z.object(updateIssueSchema(t)),
-        outputSchema: IssueSchema,
+        returnsList: false,
+        outputFields: outputFields()([
+            'id',
+            'projectId',
+            'issueKey',
+            'keyId',
+            'issueType',
+            'summary',
+            'description',
+            'resolution',
+            'priority',
+            'status',
+            'assignee',
+            'category',
+            'versions',
+            'milestone',
+            'startDate',
+            'dueDate',
+            'estimatedHours',
+            'actualHours',
+            'parentIssueId',
+            'createdUser',
+            'created',
+            'updatedUser',
+            'updated',
+            'customFields',
+            'attachments',
+            'sharedFiles',
+            'stars',
+            'childIssueSummary',
+        ]),
         handler: async ({ issueId, issueKey, customFields, ...params }) => {
             const result = resolveIdOrKey('issue', { id: issueId, key: issueKey }, t);
             if (!result.ok) {

package/build/tools/updateIssueComment.d.ts

@@ -1,13 +1,13 @@
 import { z } from 'zod';
+import type { Entity } from 'backlog-js';
 import { Backlog } from 'backlog-js';
 import { ToolDefinition } from '../types/tool.js';
 import { DescriptionHelper } from '../createDescriptionHelper.js';
-import { IssueCommentSchema } from '../types/zod/backlogOutputDefinition.js';
-declare const updateIssueCommentSchema: (t: DescriptionHelper["t"]) => {
+declare const updateIssueCommentSchema: (t: DescriptionHelper['t']) => {
     issueId: z.ZodOptional<z.ZodNumber>;
     issueKey: z.ZodOptional<z.ZodString>;
     commentId: z.ZodNumber;
     content: z.ZodString;
 };
-export declare const updateIssueCommentTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof updateIssueCommentSchema>, (typeof IssueCommentSchema)["shape"]>;
+export declare const updateIssueCommentTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof updateIssueCommentSchema>, Entity.Issue.Comment>;
 export {};

package/build/tools/updateIssueComment.js

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { buildToolSchema } from '../types/tool.js';
-import { IssueCommentSchema } from '../types/zod/backlogOutputDefinition.js';
+import { outputFields } from '../types/outputFields.js';
 import { resolveIdOrKey } from '../utils/resolveIdOrKey.js';
 const updateIssueCommentSchema = buildToolSchema((t) => ({
     issueId: z
@@ -23,7 +23,19 @@ export const updateIssueCommentTool = (backlog, { t }) => {
         name: 'update_issue_comment',
         description: t('TOOL_UPDATE_ISSUE_COMMENT_DESCRIPTION', 'Updates a comment on an issue'),
         schema: z.object(updateIssueCommentSchema(t)),
-        outputSchema: IssueCommentSchema,
+        returnsList: false,
+        outputFields: outputFields()([
+            'id',
+            'projectId',
+            'issueId',
+            'content',
+            'changeLog',
+            'createdUser',
+            'created',
+            'updated',
+            'stars',
+            'notifications',
+        ]),
         importantFields: ['id', 'content', 'createdUser', 'updated'],
         handler: async ({ issueId, issueKey, commentId, content }) => {
             const result = resolveIdOrKey('issue', { id: issueId, key: issueKey }, t);

package/build/tools/updateProject.d.ts

@@ -1,9 +1,9 @@
 import { z } from 'zod';
+import type { Entity } from 'backlog-js';
 import { Backlog } from 'backlog-js';
 import { ToolDefinition } from '../types/tool.js';
 import { DescriptionHelper } from '../createDescriptionHelper.js';
-import { ProjectSchema } from '../types/zod/backlogOutputDefinition.js';
-declare const updateProjectSchema: (t: DescriptionHelper["t"]) => {
+declare const updateProjectSchema: (t: DescriptionHelper['t']) => {
     projectId: z.ZodOptional<z.ZodNumber>;
     projectKey: z.ZodOptional<z.ZodString>;
     name: z.ZodOptional<z.ZodString>;
@@ -17,5 +17,5 @@ declare const updateProjectSchema: (t: DescriptionHelper["t"]) => {
     }>>;
     archived: z.ZodOptional<z.ZodBoolean>;
 };
-export declare const updateProjectTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof updateProjectSchema>, (typeof ProjectSchema)["shape"]>;
+export declare const updateProjectTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof updateProjectSchema>, Entity.Project.Project>;
 export {};

package/build/tools/updateProject.js

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { buildToolSchema } from '../types/tool.js';
-import { ProjectSchema } from '../types/zod/backlogOutputDefinition.js';
+import { outputFields } from '../types/outputFields.js';
 import { resolveIdOrKey } from '../utils/resolveIdOrKey.js';
 const updateProjectSchema = buildToolSchema((t) => ({
     projectId: z
@@ -45,7 +45,27 @@ export const updateProjectTool = (backlog, { t }) => {
         name: 'update_project',
         description: t('TOOL_UPDATE_PROJECT_DESCRIPTION', 'Updates an existing project'),
         schema: z.object(updateProjectSchema(t)),
-        outputSchema: ProjectSchema,
+        returnsList: false,
+        outputFields: outputFields()([
+            'id',
+            'projectKey',
+            'name',
+            'chartEnabled',
+            'useResolvedForChart',
+            'subtaskingEnabled',
+            'projectLeaderCanEditProjectLeader',
+            'useWiki',
+            'useFileSharing',
+            'useWikiTreeView',
+            'useOriginalImageSizeAtWiki',
+            'useSubversion',
+            'useGit',
+            'textFormattingRule',
+            'archived',
+            'displayOrder',
+            'useDevAttributes',
+            'grandchildIssueEnabled',
+        ]),
         handler: async ({ projectId, projectKey, ...param }) => {
             const result = resolveIdOrKey('project', { id: projectId, key: projectKey }, t);
             if (!result.ok) {

package/build/tools/updatePullRequest.d.ts

@@ -1,9 +1,9 @@
 import { z } from 'zod';
+import type { Entity } from 'backlog-js';
 import { Backlog } from 'backlog-js';
 import { ToolDefinition } from '../types/tool.js';
 import { DescriptionHelper } from '../createDescriptionHelper.js';
-import { PullRequestSchema } from '../types/zod/backlogOutputDefinition.js';
-declare const updatePullRequestSchema: (t: DescriptionHelper["t"]) => {
+declare const updatePullRequestSchema: (t: DescriptionHelper['t']) => {
     projectId: z.ZodOptional<z.ZodNumber>;
     projectKey: z.ZodOptional<z.ZodString>;
     repoId: z.ZodOptional<z.ZodNumber>;
@@ -16,5 +16,5 @@ declare const updatePullRequestSchema: (t: DescriptionHelper["t"]) => {
     notifiedUserId: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
     statusId: z.ZodOptional<z.ZodNumber>;
 };
-export declare const updatePullRequestTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof updatePullRequestSchema>, (typeof PullRequestSchema)["shape"]>;
+export declare const updatePullRequestTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof updatePullRequestSchema>, Entity.PullRequest.PullRequest>;
 export {};

package/build/tools/updatePullRequest.js

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { buildToolSchema } from '../types/tool.js';
-import { PullRequestSchema } from '../types/zod/backlogOutputDefinition.js';
+import { outputFields } from '../types/outputFields.js';
 import { resolveIdOrKey } from '../utils/resolveIdOrKey.js';
 const updatePullRequestSchema = buildToolSchema((t) => ({
     projectId: z
@@ -52,7 +52,31 @@ export const updatePullRequestTool = (backlog, { t }) => {
         name: 'update_pull_request',
         description: t('TOOL_UPDATE_PULL_REQUEST_DESCRIPTION', 'Updates an existing pull request'),
         schema: z.object(updatePullRequestSchema(t)),
-        outputSchema: PullRequestSchema,
+        returnsList: false,
+        outputFields: outputFields()([
+            'id',
+            'projectId',
+            'repositoryId',
+            'number',
+            'summary',
+            'description',
+            'base',
+            'branch',
+            'status',
+            'assignee',
+            'issue',
+            'baseCommit',
+            'branchCommit',
+            'mergeCommit',
+            'closeAt',
+            'mergeAt',
+            'createdUser',
+            'created',
+            'updatedUser',
+            'updated',
+            'attachments',
+            'stars',
+        ]),
         handler: async ({ projectId, projectKey, repoId, repoName, number, ...params }) => {
             const result = resolveIdOrKey('project', { id: projectId, key: projectKey }, t);
             if (!result.ok) {

package/build/tools/updatePullRequestComment.d.ts

@@ -1,9 +1,9 @@
 import { z } from 'zod';
+import type { Entity } from 'backlog-js';
 import { Backlog } from 'backlog-js';
 import { ToolDefinition } from '../types/tool.js';
 import { DescriptionHelper } from '../createDescriptionHelper.js';
-import { PullRequestCommentSchema } from '../types/zod/backlogOutputDefinition.js';
-declare const updatePullRequestCommentSchema: (t: DescriptionHelper["t"]) => {
+declare const updatePullRequestCommentSchema: (t: DescriptionHelper['t']) => {
     projectId: z.ZodOptional<z.ZodNumber>;
     projectKey: z.ZodOptional<z.ZodString>;
     repoId: z.ZodOptional<z.ZodNumber>;
@@ -12,5 +12,5 @@ declare const updatePullRequestCommentSchema: (t: DescriptionHelper["t"]) => {
     commentId: z.ZodNumber;
     content: z.ZodString;
 };
-export declare const updatePullRequestCommentTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof updatePullRequestCommentSchema>, (typeof PullRequestCommentSchema)["shape"]>;
+export declare const updatePullRequestCommentTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof updatePullRequestCommentSchema>, Entity.PullRequest.Comment>;
 export {};

package/build/tools/updatePullRequestComment.js

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { buildToolSchema } from '../types/tool.js';
-import { PullRequestCommentSchema } from '../types/zod/backlogOutputDefinition.js';
+import { outputFields } from '../types/outputFields.js';
 import { resolveIdOrKey, resolveIdOrName } from '../utils/resolveIdOrKey.js';
 const updatePullRequestCommentSchema = buildToolSchema((t) => ({
     projectId: z
@@ -34,7 +34,17 @@ export const updatePullRequestCommentTool = (backlog, { t }) => {
         name: 'update_pull_request_comment',
         description: t('TOOL_UPDATE_PULL_REQUEST_COMMENT_DESCRIPTION', 'Updates a comment on a pull request'),
         schema: z.object(updatePullRequestCommentSchema(t)),
-        outputSchema: PullRequestCommentSchema,
+        returnsList: false,
+        outputFields: outputFields()([
+            'id',
+            'content',
+            'changeLog',
+            'createdUser',
+            'created',
+            'updated',
+            'stars',
+            'notifications',
+        ]),
         importantFields: ['id', 'content', 'createdUser', 'updated'],
         handler: async ({ projectId, projectKey, repoId, repoName, number, commentId, content, }) => {
             const result = resolveIdOrKey('project', { id: projectId, key: projectKey }, t);

package/build/tools/updateVersionMilestone.d.ts

@@ -1,9 +1,9 @@
 import { z } from 'zod';
+import type { Entity } from 'backlog-js';
 import { Backlog } from 'backlog-js';
 import { ToolDefinition } from '../types/tool.js';
 import { DescriptionHelper } from '../createDescriptionHelper.js';
-import { VersionSchema } from '../types/zod/backlogOutputDefinition.js';
-declare const updateVersionMilestoneSchema: (t: DescriptionHelper["t"]) => {
+declare const updateVersionMilestoneSchema: (t: DescriptionHelper['t']) => {
     projectId: z.ZodOptional<z.ZodNumber>;
     projectKey: z.ZodOptional<z.ZodString>;
     id: z.ZodNumber;
@@ -13,5 +13,5 @@ declare const updateVersionMilestoneSchema: (t: DescriptionHelper["t"]) => {
     releaseDueDate: z.ZodOptional<z.ZodString>;
     archived: z.ZodOptional<z.ZodBoolean>;
 };
-export declare const updateVersionMilestoneTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof updateVersionMilestoneSchema>, (typeof VersionSchema)["shape"]>;
+export declare const updateVersionMilestoneTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof updateVersionMilestoneSchema>, Entity.Project.Version>;
 export {};

package/build/tools/updateVersionMilestone.js

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { buildToolSchema } from '../types/tool.js';
-import { VersionSchema } from '../types/zod/backlogOutputDefinition.js';
+import { outputFields } from '../types/outputFields.js';
 import { resolveIdOrKey } from '../utils/resolveIdOrKey.js';
 const updateVersionMilestoneSchema = buildToolSchema((t) => ({
     projectId: z
@@ -37,7 +37,17 @@ export const updateVersionMilestoneTool = (backlog, { t }) => {
         name: 'update_version_milestone',
         description: t('TOOL_UPDATE_VERSION_MILESTONE_DESCRIPTION', 'Updates an existing version milestone'),
         schema: z.object(updateVersionMilestoneSchema(t)),
-        outputSchema: VersionSchema,
+        returnsList: false,
+        outputFields: outputFields()([
+            'id',
+            'projectId',
+            'name',
+            'description',
+            'startDate',
+            'releaseDueDate',
+            'archived',
+            'displayOrder',
+        ]),
         importantFields: [
             'id',
             'name',

package/build/tools/updateWatching.d.ts

@@ -1,11 +1,11 @@
 import { z } from 'zod';
+import type { Entity } from 'backlog-js';
 import { Backlog } from 'backlog-js';
 import { ToolDefinition } from '../types/tool.js';
 import { DescriptionHelper } from '../createDescriptionHelper.js';
-import { WatchingListItemSchema } from '../types/zod/backlogOutputDefinition.js';
-declare const updateWatchingSchema: (t: DescriptionHelper["t"]) => {
+declare const updateWatchingSchema: (t: DescriptionHelper['t']) => {
     watchId: z.ZodNumber;
     note: z.ZodString;
 };
-export declare const updateWatchingTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof updateWatchingSchema>, (typeof WatchingListItemSchema)["shape"]>;
+export declare const updateWatchingTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof updateWatchingSchema>, Entity.WatchingList.WatchingListItem>;
 export {};

package/build/tools/updateWatching.js

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { buildToolSchema } from '../types/tool.js';
-import { WatchingListItemSchema } from '../types/zod/backlogOutputDefinition.js';
+import { outputFields } from '../types/outputFields.js';
 const updateWatchingSchema = buildToolSchema((t) => ({
     watchId: z.number().describe(t('TOOL_UPDATE_WATCHING_WATCH_ID', 'Watch ID')),
     note: z
@@ -12,7 +12,17 @@ export const updateWatchingTool = (backlog, { t }) => {
         name: 'update_watching',
         description: t('TOOL_UPDATE_WATCHING_DESCRIPTION', 'Updates an existing watch note'),
         schema: z.object(updateWatchingSchema(t)),
-        outputSchema: WatchingListItemSchema,
+        returnsList: false,
+        outputFields: outputFields()([
+            'id',
+            'resourceAlreadyRead',
+            'note',
+            'type',
+            'issue',
+            'lastContentUpdated',
+            'created',
+            'updated',
+        ]),
         handler: async ({ watchId, note }) => backlog.patchWatchingListItem(watchId, note),
     };
 };