backlog-mcp-server 0.16.0 → 0.18.0

package/build/tools/getIssue.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';
 const getIssueSchema = buildToolSchema((t) => ({
     issueId: z
@@ -16,7 +16,37 @@ export const getIssueTool = (backlog, { t }) => {
     return {
         name: 'get_issue',
         description: t('TOOL_GET_ISSUE_DESCRIPTION', 'Returns information about a specific issue'),
-        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',
+        ]),
         schema: z.object(getIssueSchema(t)),
         handler: async ({ issueId, issueKey }) => {
             const result = resolveIdOrKey('issue', { id: issueId, key: issueKey }, t);

package/build/tools/getIssueComments.d.ts

@@ -1,8 +1,8 @@
 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 getIssueCommentsSchema: (t: DescriptionHelper["t"]) => {
     issueId: z.ZodOptional<z.ZodNumber>;
     issueKey: z.ZodOptional<z.ZodString>;
@@ -14,5 +14,5 @@ declare const getIssueCommentsSchema: (t: DescriptionHelper["t"]) => {
         desc: "desc";
     }>>;
 };
-export declare const getIssueCommentsTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof getIssueCommentsSchema>, (typeof IssueCommentSchema)["shape"]>;
+export declare const getIssueCommentsTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof getIssueCommentsSchema>, Entity.Issue.Comment>;
 export {};

package/build/tools/getIssueComments.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 getIssueCommentsSchema = buildToolSchema((t) => ({
     issueId: z
@@ -33,7 +33,19 @@ export const getIssueCommentsTool = (backlog, { t }) => {
         name: 'get_issue_comments',
         description: t('TOOL_GET_ISSUE_COMMENTS_DESCRIPTION', 'Returns list of comments for an issue'),
         schema: z.object(getIssueCommentsSchema(t)),
-        outputSchema: IssueCommentSchema,
+        returnsList: true,
+        outputFields: outputFields()([
+            'id',
+            'projectId',
+            'issueId',
+            'content',
+            'changeLog',
+            'createdUser',
+            'created',
+            'updated',
+            'stars',
+            'notifications',
+        ]),
         handler: async ({ issueId, issueKey, ...params }) => {
             const result = resolveIdOrKey('issue', { id: issueId, key: issueKey }, t);
             if (!result.ok) {

package/build/tools/getIssueTypes.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 { IssueTypeSchema } from '../types/zod/backlogOutputDefinition.js';
 declare const getIssueTypesSchema: (t: DescriptionHelper["t"]) => {
     projectId: z.ZodOptional<z.ZodNumber>;
     projectKey: z.ZodOptional<z.ZodString>;
 };
-export declare const getIssueTypesTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof getIssueTypesSchema>, (typeof IssueTypeSchema)["shape"]>;
+export declare const getIssueTypesTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof getIssueTypesSchema>, Entity.Issue.IssueType>;
 export {};

package/build/tools/getIssueTypes.js

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { buildToolSchema } from '../types/tool.js';
-import { IssueTypeSchema } from '../types/zod/backlogOutputDefinition.js';
+import { outputFields } from '../types/outputFields.js';
 import { resolveIdOrKey } from '../utils/resolveIdOrKey.js';
 const getIssueTypesSchema = buildToolSchema((t) => ({
     projectId: z
@@ -17,7 +17,16 @@ export const getIssueTypesTool = (backlog, { t }) => {
         name: 'get_issue_types',
         description: t('TOOL_GET_ISSUE_TYPES_DESCRIPTION', 'Returns list of issue types for a project'),
         schema: z.object(getIssueTypesSchema(t)),
-        outputSchema: IssueTypeSchema,
+        returnsList: true,
+        outputFields: outputFields()([
+            'id',
+            'projectId',
+            'name',
+            'color',
+            'displayOrder',
+            'templateSummary',
+            'templateDescription',
+        ]),
         importantFields: ['id', 'name'],
         handler: async ({ projectId, projectKey }) => {
             const result = resolveIdOrKey('project', { id: projectId, key: projectKey }, t);

package/build/tools/getIssues.d.ts

@@ -1,8 +1,8 @@
 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 { IssueSchema } from '../types/zod/backlogOutputDefinition.js';
 declare const getIssuesSchema: (t: DescriptionHelper["t"]) => {
     projectId: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
     issueTypeId: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
@@ -27,20 +27,20 @@ declare const getIssuesSchema: (t: DescriptionHelper["t"]) => {
     sort: z.ZodOptional<z.ZodEnum<{
         version: "version";
         priority: "priority";
-        createdUser: "createdUser";
-        created: "created";
+        summary: "summary";
         startDate: "startDate";
-        updatedUser: "updatedUser";
-        updated: "updated";
+        dueDate: "dueDate";
+        estimatedHours: "estimatedHours";
+        actualHours: "actualHours";
         issueType: "issueType";
         status: "status";
-        summary: "summary";
         assignee: "assignee";
         category: "category";
         milestone: "milestone";
-        dueDate: "dueDate";
-        estimatedHours: "estimatedHours";
-        actualHours: "actualHours";
+        createdUser: "createdUser";
+        created: "created";
+        updatedUser: "updatedUser";
+        updated: "updated";
         attachment: "attachment";
         sharedFile: "sharedFile";
         childIssue: "childIssue";
@@ -71,5 +71,5 @@ declare const getIssuesSchema: (t: DescriptionHelper["t"]) => {
         value: z.ZodUnion<readonly [z.ZodNumber, z.ZodArray<z.ZodNumber>]>;
     }, z.core.$strip>], "type">>>;
 };
-export declare const getIssuesTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof getIssuesSchema>, (typeof IssueSchema)["shape"]>;
+export declare const getIssuesTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof getIssuesSchema>, Entity.Issue.Issue>;
 export {};

package/build/tools/getIssues.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 { customFieldFiltersToPayload } from '../backlog/customFields.js';
 import { buildCustomFieldFilterSchema } from './shared/customFieldFiltersSchema.js';
 const getIssuesSchema = buildToolSchema((t) => ({
@@ -138,7 +138,37 @@ export const getIssuesTool = (backlog, { t }) => {
             'description',
             'issueType',
         ],
-        outputSchema: IssueSchema,
+        returnsList: true,
+        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 ({ customFields, ...rest }) => {
             return backlog.getIssues({
                 ...rest,

package/build/tools/getMyself.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 { UserSchema } from '../types/zod/backlogOutputDefinition.js';
 declare const getMyselfSchema: (t: DescriptionHelper["t"]) => {};
-export declare const getMyselfTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof getMyselfSchema>, (typeof UserSchema)["shape"]>;
+export declare const getMyselfTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof getMyselfSchema>, Entity.User.User>;
 export {};

package/build/tools/getMyself.js

@@ -1,13 +1,22 @@
 import { z } from 'zod';
 import { buildToolSchema } from '../types/tool.js';
-import { UserSchema } from '../types/zod/backlogOutputDefinition.js';
+import { outputFields } from '../types/outputFields.js';
 const getMyselfSchema = buildToolSchema((_t) => ({}));
 export const getMyselfTool = (backlog, { t }) => {
     return {
         name: 'get_myself',
         description: t('TOOL_GET_MYSELF_DESCRIPTION', 'Returns information about the authenticated user'),
         schema: z.object(getMyselfSchema(t)),
-        outputSchema: UserSchema,
+        returnsList: false,
+        outputFields: outputFields()([
+            'id',
+            'userId',
+            'name',
+            'roleType',
+            'lang',
+            'mailAddress',
+            'lastLoginTime',
+        ]),
         importantFields: ['id', 'userId', 'name', 'roleType'],
         handler: async () => backlog.getMyself(),
     };

package/build/tools/getNotifications.d.ts

@@ -1,8 +1,8 @@
 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 { NotificationSchema } from '../types/zod/backlogOutputDefinition.js';
 declare const getNotificationsSchema: (t: DescriptionHelper["t"]) => {
     minId: z.ZodOptional<z.ZodNumber>;
     maxId: z.ZodOptional<z.ZodNumber>;
@@ -12,5 +12,5 @@ declare const getNotificationsSchema: (t: DescriptionHelper["t"]) => {
         desc: "desc";
     }>>;
 };
-export declare const getNotificationsTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof getNotificationsSchema>, (typeof NotificationSchema)["shape"]>;
+export declare const getNotificationsTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof getNotificationsSchema>, Entity.Notification.Notification>;
 export {};

package/build/tools/getNotifications.js

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { buildToolSchema } from '../types/tool.js';
-import { NotificationSchema } from '../types/zod/backlogOutputDefinition.js';
+import { outputFields } from '../types/outputFields.js';
 const getNotificationsSchema = buildToolSchema((t) => ({
     minId: z
         .number()
@@ -24,7 +24,20 @@ export const getNotificationsTool = (backlog, { t }) => {
         name: 'get_notifications',
         description: t('TOOL_GET_NOTIFICATIONS_DESCRIPTION', 'Returns list of notifications'),
         schema: z.object(getNotificationsSchema(t)),
-        outputSchema: NotificationSchema,
+        returnsList: true,
+        outputFields: outputFields()([
+            'id',
+            'alreadyRead',
+            'reason',
+            'resourceAlreadyRead',
+            'project',
+            'issue',
+            'comment',
+            'pullRequest',
+            'pullRequestComment',
+            'sender',
+            'created',
+        ]),
         handler: async ({ minId, maxId, count, order }) => backlog.getNotifications({
             minId,
             maxId,

package/build/tools/getNotificationsCount.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 { NotificationCountSchema } from '../types/zod/backlogOutputDefinition.js';
 declare const getNotificationsCountSchema: (t: DescriptionHelper["t"]) => {
     alreadyRead: z.ZodBoolean;
     resourceAlreadyRead: z.ZodBoolean;
 };
-export declare const getNotificationsCountTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof getNotificationsCountSchema>, (typeof NotificationCountSchema)["shape"]>;
+export declare const getNotificationsCountTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof getNotificationsCountSchema>, Entity.Notification.NotificationCount>;
 export {};

package/build/tools/getNotificationsCount.js

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { buildToolSchema } from '../types/tool.js';
-import { NotificationCountSchema } from '../types/zod/backlogOutputDefinition.js';
+import { outputFields } from '../types/outputFields.js';
 const getNotificationsCountSchema = buildToolSchema((t) => ({
     alreadyRead: z
         .boolean()
@@ -14,7 +14,10 @@ export const getNotificationsCountTool = (backlog, { t }) => {
         name: 'count_notifications',
         description: t('TOOL_COUNT_NOTIFICATIONS_DESCRIPTION', 'Returns count of notifications'),
         schema: z.object(getNotificationsCountSchema(t)),
-        outputSchema: NotificationCountSchema,
+        returnsList: false,
+        outputFields: outputFields()([
+            'count',
+        ]),
         handler: async (params) => backlog.getNotificationsCount(params),
     };
 };

package/build/tools/getPriorities.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 { PrioritySchema } from '../types/zod/backlogOutputDefinition.js';
 declare const getPrioritiesSchema: (t: DescriptionHelper["t"]) => {};
-export declare const getPrioritiesTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof getPrioritiesSchema>, (typeof PrioritySchema)["shape"]>;
+export declare const getPrioritiesTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof getPrioritiesSchema>, Entity.Issue.Priority>;
 export {};

package/build/tools/getPriorities.js

@@ -1,13 +1,14 @@
 import { z } from 'zod';
 import { buildToolSchema } from '../types/tool.js';
-import { PrioritySchema } from '../types/zod/backlogOutputDefinition.js';
+import { outputFields } from '../types/outputFields.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,
+        returnsList: true,
+        outputFields: outputFields()(['id', 'name']),
         handler: async () => backlog.getPriorities(),
     };
 };

package/build/tools/getProject.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 { ProjectSchema } from '../types/zod/backlogOutputDefinition.js';
 declare const getProjectSchema: (t: DescriptionHelper["t"]) => {
     projectId: z.ZodOptional<z.ZodNumber>;
     projectKey: z.ZodOptional<z.ZodString>;
 };
-export declare const getProjectTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof getProjectSchema>, (typeof ProjectSchema)["shape"]>;
+export declare const getProjectTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof getProjectSchema>, Entity.Project.Project>;
 export {};

package/build/tools/getProject.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 getProjectSchema = buildToolSchema((t) => ({
     projectId: z
@@ -17,7 +17,27 @@ export const getProjectTool = (backlog, { t }) => {
         name: 'get_project',
         description: t('TOOL_GET_PROJECT_DESCRIPTION', 'Returns information about a specific project'),
         schema: z.object(getProjectSchema(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 }) => {
             const result = resolveIdOrKey('project', { id: projectId, key: projectKey }, t);
             if (!result.ok) {

package/build/tools/getProjectList.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 { ProjectSchema } from '../types/zod/backlogOutputDefinition.js';
 declare const getProjectListSchema: (t: DescriptionHelper["t"]) => {
     archived: z.ZodOptional<z.ZodBoolean>;
     all: z.ZodOptional<z.ZodBoolean>;
 };
-export declare const getProjectListTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof getProjectListSchema>, (typeof ProjectSchema)["shape"]>;
+export declare const getProjectListTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof getProjectListSchema>, Entity.Project.Project>;
 export {};

package/build/tools/getProjectList.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';
 const getProjectListSchema = buildToolSchema((t) => ({
     archived: z
         .boolean()
@@ -16,7 +16,27 @@ export const getProjectListTool = (backlog, { t }) => {
         name: 'get_project_list',
         description: t('TOOL_GET_PROJECT_LIST_DESCRIPTION', 'Returns list of projects'),
         schema: z.object(getProjectListSchema(t)),
-        outputSchema: ProjectSchema,
+        returnsList: true,
+        outputFields: outputFields()([
+            'id',
+            'projectKey',
+            'name',
+            'chartEnabled',
+            'useResolvedForChart',
+            'subtaskingEnabled',
+            'projectLeaderCanEditProjectLeader',
+            'useWiki',
+            'useFileSharing',
+            'useWikiTreeView',
+            'useOriginalImageSizeAtWiki',
+            'useSubversion',
+            'useGit',
+            'textFormattingRule',
+            'archived',
+            'displayOrder',
+            'useDevAttributes',
+            'grandchildIssueEnabled',
+        ]),
         importantFields: ['id', 'projectKey', 'name'],
         handler: async ({ archived, all }) => backlog.getProjects({ archived, all }),
     };

package/build/tools/getProjectUsers.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 { UserSchema } from '../types/zod/backlogOutputDefinition.js';
 declare const getProjectUsersSchema: (t: DescriptionHelper["t"]) => {
     projectId: z.ZodOptional<z.ZodNumber>;
     projectKey: z.ZodOptional<z.ZodString>;
 };
-export declare const getProjectUsersTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof getProjectUsersSchema>, (typeof UserSchema)["shape"]>;
+export declare const getProjectUsersTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof getProjectUsersSchema>, Entity.User.User>;
 export {};

package/build/tools/getProjectUsers.js

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { buildToolSchema } from '../types/tool.js';
-import { UserSchema } from '../types/zod/backlogOutputDefinition.js';
+import { outputFields } from '../types/outputFields.js';
 import { resolveIdOrKey } from '../utils/resolveIdOrKey.js';
 const getProjectUsersSchema = buildToolSchema((t) => ({
     projectId: z
@@ -17,7 +17,16 @@ export const getProjectUsersTool = (backlog, { t }) => {
         name: 'get_project_users',
         description: t('TOOL_GET_PROJECT_USERS_DESCRIPTION', 'Returns list of users in a specific project'),
         schema: z.object(getProjectUsersSchema(t)),
-        outputSchema: UserSchema,
+        returnsList: true,
+        outputFields: outputFields()([
+            'id',
+            'userId',
+            'name',
+            'roleType',
+            'lang',
+            'mailAddress',
+            'lastLoginTime',
+        ]),
         importantFields: ['userId', 'name', 'roleType', 'lang'],
         handler: async ({ projectId, projectKey }) => {
             const result = resolveIdOrKey('project', { id: projectId, key: projectKey }, t);

package/build/tools/getPullRequest.d.ts

@@ -1,8 +1,8 @@
 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 getPullRequestSchema: (t: DescriptionHelper["t"]) => {
     projectId: z.ZodOptional<z.ZodNumber>;
     projectKey: z.ZodOptional<z.ZodString>;
@@ -10,5 +10,5 @@ declare const getPullRequestSchema: (t: DescriptionHelper["t"]) => {
     repoName: z.ZodOptional<z.ZodString>;
     number: z.ZodNumber;
 };
-export declare const getPullRequestTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof getPullRequestSchema>, (typeof PullRequestSchema)["shape"]>;
+export declare const getPullRequestTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof getPullRequestSchema>, Entity.PullRequest.PullRequest>;
 export {};

package/build/tools/getPullRequest.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, resolveIdOrName } from '../utils/resolveIdOrKey.js';
 const getPullRequestSchema = buildToolSchema((t) => ({
     projectId: z
@@ -28,7 +28,31 @@ export const getPullRequestTool = (backlog, { t }) => {
         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,
+        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 }) => {
             const result = resolveIdOrKey('project', { id: projectId, key: projectKey }, t);
             if (!result.ok) {

package/build/tools/getPullRequestComments.d.ts

@@ -1,8 +1,8 @@
 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 getPullRequestCommentsSchema: (t: DescriptionHelper["t"]) => {
     projectId: z.ZodOptional<z.ZodNumber>;
     projectKey: z.ZodOptional<z.ZodString>;
@@ -17,5 +17,5 @@ declare const getPullRequestCommentsSchema: (t: DescriptionHelper["t"]) => {
         desc: "desc";
     }>>;
 };
-export declare const getPullRequestCommentsTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof getPullRequestCommentsSchema>, (typeof PullRequestCommentSchema)["shape"]>;
+export declare const getPullRequestCommentsTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof getPullRequestCommentsSchema>, Entity.PullRequest.Comment>;
 export {};

package/build/tools/getPullRequestComments.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 getPullRequestCommentsSchema = buildToolSchema((t) => ({
     projectId: z
@@ -44,7 +44,17 @@ export const getPullRequestCommentsTool = (backlog, { t }) => {
         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,
+        returnsList: true,
+        outputFields: outputFields()([
+            'id',
+            'content',
+            'changeLog',
+            'createdUser',
+            'created',
+            'updated',
+            'stars',
+            'notifications',
+        ]),
         handler: async ({ projectId, projectKey, repoId, repoName, number, ...params }) => {
             const result = resolveIdOrKey('project', { id: projectId, key: projectKey }, t);
             if (!result.ok) {