backlog-mcp-server 0.17.0 → 0.18.0

package/build/tools/deleteProject.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 deleteProjectSchema = buildToolSchema((t) => ({
     projectId: z
@@ -17,7 +17,27 @@ export const deleteProjectTool = (backlog, { t }) => {
         name: 'delete_project',
         description: t('TOOL_DELETE_PROJECT_DESCRIPTION', 'Deletes a project'),
         schema: z.object(deleteProjectSchema(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/deleteVersion.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 { VersionSchema } from '../types/zod/backlogOutputDefinition.js';
 declare const deleteVersionSchema: (t: DescriptionHelper["t"]) => {
     projectId: z.ZodOptional<z.ZodNumber>;
     projectKey: z.ZodOptional<z.ZodString>;
     id: z.ZodNumber;
 };
-export declare const deleteVersionTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof deleteVersionSchema>, (typeof VersionSchema)["shape"]>;
+export declare const deleteVersionTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof deleteVersionSchema>, Entity.Project.Version>;
 export {};

package/build/tools/deleteVersion.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 deleteVersionSchema = buildToolSchema((t) => ({
     projectId: z
@@ -20,7 +20,17 @@ export const deleteVersionTool = (backlog, { t }) => {
         name: 'delete_version',
         description: t('TOOL_DELETE_VERSION_DESCRIPTION', 'Deletes a version from a project'),
         schema: z.object(deleteVersionSchema(t)),
-        outputSchema: VersionSchema,
+        returnsList: false,
+        outputFields: outputFields()([
+            'id',
+            'projectId',
+            'name',
+            'description',
+            'startDate',
+            'releaseDueDate',
+            'archived',
+            'displayOrder',
+        ]),
         handler: async ({ projectId, projectKey, id }) => {
             const result = resolveIdOrKey('project', { id: projectId, key: projectKey }, t);
             if (!result.ok) {

package/build/tools/deleteWatching.d.ts

@@ -1,10 +1,10 @@
 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 deleteWatchingSchema: (t: DescriptionHelper["t"]) => {
     watchId: z.ZodNumber;
 };
-export declare const deleteWatchingTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof deleteWatchingSchema>, (typeof WatchingListItemSchema)["shape"]>;
+export declare const deleteWatchingTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof deleteWatchingSchema>, Entity.WatchingList.WatchingListItem>;
 export {};

package/build/tools/deleteWatching.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 deleteWatchingSchema = buildToolSchema((t) => ({
     watchId: z
         .number()
@@ -11,7 +11,17 @@ export const deleteWatchingTool = (backlog, { t }) => {
         name: 'delete_watching',
         description: t('TOOL_DELETE_WATCHING_DESCRIPTION', 'Deletes a watch from an issue'),
         schema: z.object(deleteWatchingSchema(t)),
-        outputSchema: WatchingListItemSchema,
+        returnsList: false,
+        outputFields: outputFields()([
+            'id',
+            'resourceAlreadyRead',
+            'note',
+            'type',
+            'issue',
+            'lastContentUpdated',
+            'created',
+            'updated',
+        ]),
         handler: async ({ watchId }) => backlog.deletehWatchingListItem(watchId),
     };
 };

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

package/build/tools/getCategories.js

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { buildToolSchema } from '../types/tool.js';
-import { CategorySchema } from '../types/zod/backlogOutputDefinition.js';
+import { outputFields } from '../types/outputFields.js';
 import { resolveIdOrKey } from '../utils/resolveIdOrKey.js';
 const getCategoriesSchema = buildToolSchema((t) => ({
     projectId: z
@@ -18,7 +18,13 @@ export const getCategoriesTool = (backlog, { t }) => {
         description: t('TOOL_GET_CATEGORIES_DESCRIPTION', 'Returns list of categories for a project'),
         schema: z.object(getCategoriesSchema(t)),
         importantFields: ['id', 'projectId', 'name'],
-        outputSchema: CategorySchema,
+        returnsList: true,
+        outputFields: outputFields()([
+            'id',
+            'projectId',
+            'name',
+            'displayOrder',
+        ]),
         handler: async ({ projectId, projectKey }) => {
             const result = resolveIdOrKey('project', { id: projectId, key: projectKey }, t);
             if (!result.ok) {

package/build/tools/getCustomFields.d.ts

@@ -1,12 +1,12 @@
+import type { Entity } from 'backlog-js';
 import { Backlog } from 'backlog-js';
 import { z } from 'zod';
 import { ToolDefinition } from '../types/tool.js';
 import { DescriptionHelper } from '../createDescriptionHelper.js';
-import { CustomFieldSchema } from '../types/zod/backlogOutputDefinition.js';
 declare const getCustomFieldsInputSchema: (t: DescriptionHelper["t"]) => {
     projectId: z.ZodOptional<z.ZodNumber>;
     projectKey: z.ZodOptional<z.ZodString>;
 };
 export declare const getCustomFieldsTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof getCustomFieldsInputSchema>, // Shape for input schema
-(typeof CustomFieldSchema)["shape"]>;
+Entity.Project.CustomField>;
 export {};

package/build/tools/getCustomFields.js

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { buildToolSchema } from '../types/tool.js';
-import { CustomFieldSchema } from '../types/zod/backlogOutputDefinition.js';
+import { outputFields } from '../types/outputFields.js';
 import { resolveIdOrKey } from '../utils/resolveIdOrKey.js';
 const getCustomFieldsInputSchema = buildToolSchema((t) => ({
     projectId: z
@@ -18,7 +18,27 @@ export const getCustomFieldsTool = (backlog, { t }) => {
         name: 'get_custom_fields',
         description: t('TOOL_GET_CUSTOM_FIELDS_DESCRIPTION', 'Returns list of custom fields for a project'),
         schema: inputSchemaObject,
-        outputSchema: CustomFieldSchema,
+        returnsList: true,
+        outputFields: outputFields()([
+            'id',
+            'projectId',
+            'typeId',
+            'name',
+            'description',
+            'required',
+            'useIssueType',
+            'applicableIssueTypes',
+            'displayOrder',
+            'version',
+            'min',
+            'max',
+            'initialValue',
+            'unit',
+            'initialDate',
+            'items',
+            'allowAddItem',
+            'allowInput',
+        ]),
         importantFields: [
             'id',
             'name',

package/build/tools/getDocument.d.ts

@@ -1,10 +1,10 @@
+import type { Entity } from 'backlog-js';
 import { Backlog } from 'backlog-js';
 import { z } from 'zod';
 import { DescriptionHelper } from '../createDescriptionHelper.js';
-import { DocumentItemSchema } from '../types/zod/backlogOutputDefinition.js';
 import { ToolDefinition } from '../types/tool.js';
 declare const getDocumentSchema: (t: DescriptionHelper["t"]) => {
     documentId: z.ZodString;
 };
-export declare const getDocumentTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof getDocumentSchema>, (typeof DocumentItemSchema)["shape"]>;
+export declare const getDocumentTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof getDocumentSchema>, Entity.Document.Document>;
 export {};

package/build/tools/getDocument.js

@@ -1,6 +1,6 @@
 import { z } from 'zod';
-import { DocumentItemSchema } from '../types/zod/backlogOutputDefinition.js';
 import { buildToolSchema } from '../types/tool.js';
+import { outputFields } from '../types/outputFields.js';
 const getDocumentSchema = buildToolSchema((t) => ({
     documentId: z
         .string()
@@ -11,7 +11,22 @@ export const getDocumentTool = (backlog, { t }) => {
         name: 'get_document',
         description: t('TOOL_GET_DOCUMENT_DESCRIPTION', 'Gets information about a document.'),
         schema: z.object(getDocumentSchema(t)),
-        outputSchema: DocumentItemSchema,
+        returnsList: false,
+        outputFields: outputFields()([
+            'id',
+            'projectId',
+            'title',
+            'plain',
+            'json',
+            'statusId',
+            'emoji',
+            'attachments',
+            'tags',
+            'createdUser',
+            'created',
+            'updatedUser',
+            'updated',
+        ]),
         importantFields: ['id', 'title', 'createdUser'],
         handler: async ({ documentId }) => {
             return backlog.getDocument(documentId);

package/build/tools/getDocumentTree.d.ts

@@ -1,10 +1,10 @@
+import type { Entity } from 'backlog-js';
 import { Backlog } from 'backlog-js';
 import { z } from 'zod';
 import { DescriptionHelper } from '../createDescriptionHelper.js';
-import { DocumentTreeFullSchema } from '../types/zod/backlogOutputDefinition.js';
 import { ToolDefinition } from '../types/tool.js';
 declare const getDocumentTreeSchema: (t: DescriptionHelper["t"]) => {
     projectIdOrKey: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
 };
-export declare const getDocumentTreeTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof getDocumentTreeSchema>, typeof DocumentTreeFullSchema>;
+export declare const getDocumentTreeTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof getDocumentTreeSchema>, Entity.Document.DocumentTree>;
 export {};

package/build/tools/getDocumentTree.js

@@ -1,6 +1,6 @@
 import { z } from 'zod';
-import { DocumentTreeFullSchemaZ, } from '../types/zod/backlogOutputDefinition.js';
 import { buildToolSchema } from '../types/tool.js';
+import { outputFields } from '../types/outputFields.js';
 const getDocumentTreeSchema = buildToolSchema((t) => ({
     projectIdOrKey: z
         .union([z.string(), z.number()])
@@ -11,7 +11,12 @@ export const getDocumentTreeTool = (backlog, { t }) => {
         name: 'get_document_tree',
         description: t('TOOL_GET_DOCUMENT_TREE_DESCRIPTION', 'Gets the document tree of a project.'),
         schema: z.object(getDocumentTreeSchema(t)),
-        outputSchema: DocumentTreeFullSchemaZ,
+        returnsList: false,
+        outputFields: outputFields()([
+            'projectId',
+            'activeTree',
+            'trashTree',
+        ]),
         importantFields: ['projectId', 'activeTree', 'trashTree'],
         handler: async ({ projectIdOrKey }) => {
             return backlog.getDocumentTree(projectIdOrKey);

package/build/tools/getDocuments.d.ts

@@ -1,11 +1,11 @@
+import type { Entity } from 'backlog-js';
 import { Backlog } from 'backlog-js';
 import { z } from 'zod';
 import { DescriptionHelper } from '../createDescriptionHelper.js';
-import { DocumentItemSchema } from '../types/zod/backlogOutputDefinition.js';
 import { ToolDefinition } from '../types/tool.js';
 declare const getDocumentsSchema: (t: DescriptionHelper["t"]) => {
     projectIds: z.ZodArray<z.ZodNumber>;
     offset: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
 };
-export declare const getDocumentsTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof getDocumentsSchema>, (typeof DocumentItemSchema)["shape"]>;
+export declare const getDocumentsTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof getDocumentsSchema>, Entity.Document.Document>;
 export {};

package/build/tools/getDocuments.js

@@ -1,6 +1,6 @@
 import { z } from 'zod';
-import { DocumentItemSchema } from '../types/zod/backlogOutputDefinition.js';
 import { buildToolSchema } from '../types/tool.js';
+import { outputFields } from '../types/outputFields.js';
 const getDocumentsSchema = buildToolSchema((t) => ({
     projectIds: z
         .array(z.number())
@@ -16,7 +16,22 @@ export const getDocumentsTool = (backlog, { t }) => {
         name: 'get_documents',
         description: t('TOOL_GET_DOCUMENTS_DESCRIPTION', 'Gets a list of documents in a project.'),
         schema: z.object(getDocumentsSchema(t)),
-        outputSchema: DocumentItemSchema,
+        returnsList: true,
+        outputFields: outputFields()([
+            'id',
+            'projectId',
+            'title',
+            'plain',
+            'json',
+            'statusId',
+            'emoji',
+            'attachments',
+            'tags',
+            'createdUser',
+            'created',
+            'updatedUser',
+            'updated',
+        ]),
         importantFields: ['id', 'projectId', 'title', 'plain'],
         handler: async ({ projectIds, offset }) => {
             return backlog.getDocuments({ projectId: projectIds, offset });

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

package/build/tools/getGitRepositories.js

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { buildToolSchema } from '../types/tool.js';
-import { GitRepositorySchema } from '../types/zod/backlogOutputDefinition.js';
+import { outputFields } from '../types/outputFields.js';
 import { resolveIdOrKey } from '../utils/resolveIdOrKey.js';
 const getGitRepositoriesSchema = buildToolSchema((t) => ({
     projectId: z
@@ -17,7 +17,22 @@ export const getGitRepositoriesTool = (backlog, { t }) => {
         name: 'get_git_repositories',
         description: t('TOOL_GET_GIT_REPOSITORIES_DESCRIPTION', 'Returns list of Git repositories for a project'),
         schema: z.object(getGitRepositoriesSchema(t)),
-        outputSchema: GitRepositorySchema,
+        returnsList: true,
+        outputFields: outputFields()([
+            'id',
+            'projectId',
+            'name',
+            'description',
+            'hookUrl',
+            'httpUrl',
+            'sshUrl',
+            'displayOrder',
+            'pushedAt',
+            'createdUser',
+            'created',
+            'updatedUser',
+            'updated',
+        ]),
         handler: async ({ projectId, projectKey }) => {
             const result = resolveIdOrKey('project', { id: projectId, key: projectKey }, t);
             if (!result.ok) {

package/build/tools/getGitRepository.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 { GitRepositorySchema } from '../types/zod/backlogOutputDefinition.js';
 declare const getGitRepositorySchema: (t: DescriptionHelper["t"]) => {
     projectId: z.ZodOptional<z.ZodNumber>;
     projectKey: z.ZodOptional<z.ZodString>;
     repoId: z.ZodOptional<z.ZodNumber>;
     repoName: z.ZodOptional<z.ZodString>;
 };
-export declare const getGitRepositoryTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof getGitRepositorySchema>, (typeof GitRepositorySchema)["shape"]>;
+export declare const getGitRepositoryTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof getGitRepositorySchema>, Entity.Git.GitRepository>;
 export {};

package/build/tools/getGitRepository.js

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { buildToolSchema } from '../types/tool.js';
-import { GitRepositorySchema } from '../types/zod/backlogOutputDefinition.js';
+import { outputFields } from '../types/outputFields.js';
 import { resolveIdOrKey, resolveIdOrName } from '../utils/resolveIdOrKey.js';
 const getGitRepositorySchema = buildToolSchema((t) => ({
     projectId: z
@@ -25,7 +25,22 @@ export const getGitRepositoryTool = (backlog, { t }) => {
         name: 'get_git_repository',
         description: t('TOOL_GET_GIT_REPOSITORY_DESCRIPTION', 'Returns information about a specific Git repository'),
         schema: z.object(getGitRepositorySchema(t)),
-        outputSchema: GitRepositorySchema,
+        returnsList: false,
+        outputFields: outputFields()([
+            'id',
+            'projectId',
+            'name',
+            'description',
+            'hookUrl',
+            'httpUrl',
+            'sshUrl',
+            'displayOrder',
+            'pushedAt',
+            'createdUser',
+            'created',
+            'updatedUser',
+            'updated',
+        ]),
         handler: async ({ projectId, projectKey, repoId, repoName }) => {
             const result = resolveIdOrKey('project', { id: projectId, key: projectKey }, t);
             if (!result.ok) {

package/build/tools/getIssue.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 { IssueSchema } from '../types/zod/backlogOutputDefinition.js';
 declare const getIssueSchema: (t: DescriptionHelper["t"]) => {
     issueId: z.ZodOptional<z.ZodNumber>;
     issueKey: z.ZodOptional<z.ZodString>;
 };
-export declare const getIssueTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof getIssueSchema>, (typeof IssueSchema)["shape"]>;
+export declare const getIssueTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof getIssueSchema>, Entity.Issue.Issue>;
 export {};

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 {};