backlog-mcp-server 0.16.0 → 0.18.0

package/build/tools/addWiki.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 { WikiSchema } from '../types/zod/backlogOutputDefinition.js';
 declare const addWikiSchema: (t: DescriptionHelper["t"]) => {
     projectId: z.ZodNumber;
     name: z.ZodString;
     content: z.ZodString;
     mailNotify: z.ZodOptional<z.ZodBoolean>;
 };
-export declare const addWikiTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof addWikiSchema>, (typeof WikiSchema)["shape"]>;
+export declare const addWikiTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof addWikiSchema>, Entity.Wiki.Wiki>;
 export {};

package/build/tools/addWiki.js

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { buildToolSchema } from '../types/tool.js';
-import { WikiSchema } from '../types/zod/backlogOutputDefinition.js';
+import { outputFields } from '../types/outputFields.js';
 const addWikiSchema = buildToolSchema((t) => ({
     projectId: z.number().describe(t('TOOL_ADD_WIKI_PROJECT_ID', 'Project ID')),
     name: z.string().describe(t('TOOL_ADD_WIKI_NAME', 'Name of the wiki page')),
@@ -17,7 +17,21 @@ export const addWikiTool = (backlog, { t }) => {
         name: 'add_wiki',
         description: t('TOOL_ADD_WIKI_DESCRIPTION', 'Creates a new wiki page'),
         schema: z.object(addWikiSchema(t)),
-        outputSchema: WikiSchema,
+        returnsList: false,
+        outputFields: outputFields()([
+            'id',
+            'projectId',
+            'name',
+            'content',
+            'tags',
+            'attachments',
+            'sharedFiles',
+            'stars',
+            'createdUser',
+            'created',
+            'updatedUser',
+            'updated',
+        ]),
         importantFields: ['id', 'name', 'content', 'createdUser'],
         handler: async ({ projectId, name, content, mailNotify }) => backlog.postWiki({
             projectId,

package/build/tools/countIssues.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 { IssueCountSchema } from '../types/zod/backlogOutputDefinition.js';
 declare const countIssuesSchema: (t: DescriptionHelper["t"]) => {
     projectId: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
     issueTypeId: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
@@ -44,5 +44,5 @@ declare const countIssuesSchema: (t: DescriptionHelper["t"]) => {
         value: z.ZodUnion<readonly [z.ZodNumber, z.ZodArray<z.ZodNumber>]>;
     }, z.core.$strip>], "type">>>;
 };
-export declare const countIssuesTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof countIssuesSchema>, (typeof IssueCountSchema)["shape"]>;
+export declare const countIssuesTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof countIssuesSchema>, Entity.Issue.IssueCount>;
 export {};

package/build/tools/countIssues.js

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { buildToolSchema } from '../types/tool.js';
-import { IssueCountSchema } from '../types/zod/backlogOutputDefinition.js';
+import { outputFields } from '../types/outputFields.js';
 import { customFieldFiltersToPayload } from '../backlog/customFields.js';
 import { buildCustomFieldFilterSchema } from './shared/customFieldFiltersSchema.js';
 const countIssuesSchema = buildToolSchema((t) => ({
@@ -94,7 +94,8 @@ export const countIssuesTool = (backlog, { t }) => {
         name: 'count_issues',
         description: t('TOOL_COUNT_ISSUES_DESCRIPTION', 'Returns count of issues'),
         schema: z.object(countIssuesSchema(t)),
-        outputSchema: IssueCountSchema,
+        returnsList: false,
+        outputFields: outputFields()(['count']),
         handler: async ({ customFields, ...rest }) => {
             return backlog.getIssuesCount({
                 ...rest,

package/build/tools/deleteIssue.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 deleteIssueSchema: (t: DescriptionHelper["t"]) => {
     issueId: z.ZodOptional<z.ZodNumber>;
     issueKey: z.ZodOptional<z.ZodString>;
 };
-export declare const deleteIssueTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof deleteIssueSchema>, (typeof IssueSchema)["shape"]>;
+export declare const deleteIssueTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof deleteIssueSchema>, Entity.Issue.Issue>;
 export {};

package/build/tools/deleteIssue.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 deleteIssueSchema = buildToolSchema((t) => ({
     issueId: z
@@ -17,7 +17,37 @@ export const deleteIssueTool = (backlog, { t }) => {
         name: 'delete_issue',
         description: t('TOOL_DELETE_ISSUE_DESCRIPTION', 'Deletes an issue'),
         schema: z.object(deleteIssueSchema(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 }) => {
             const result = resolveIdOrKey('issue', { id: issueId, key: issueKey }, t);
             if (!result.ok) {

package/build/tools/deleteProject.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 deleteProjectSchema: (t: DescriptionHelper["t"]) => {
     projectId: z.ZodOptional<z.ZodNumber>;
     projectKey: z.ZodOptional<z.ZodString>;
 };
-export declare const deleteProjectTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof deleteProjectSchema>, (typeof ProjectSchema)["shape"]>;
+export declare const deleteProjectTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof deleteProjectSchema>, Entity.Project.Project>;
 export {};

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