backlog-mcp-server 0.16.0 → 0.18.0

package/build/loadDescriptionOverrides.js

@@ -1,24 +1,86 @@
-import { cosmiconfigSync } from 'cosmiconfig';
+import { readFileSync } from 'fs';
+import { load } from 'js-yaml';
 import os from 'os';
+import path from 'path';
+import { logger } from './utils/logger.js';
 /**
- * Reads description overrides from a `.backlog-mcp-serverrc` file (`.json`,
- * `.yaml` or `.yml`) in the user's home directory.
+ * Reads description overrides from a `.backlog-mcp-serverrc` file in the user's
+ * home directory.
  *
  * Node-only, and kept separate from `createDescriptionHelper` for that reason:
- * cosmiconfig walks the filesystem and the default search path is the home
- * directory. The CLI calls this and hands the result to the helper.
+ * this reads the filesystem and needs a home directory. The CLI calls it and
+ * hands the result to the helper.
  *
  * The file is user-authored, so its contents are unknown: anything that is not a
  * string is dropped here rather than passed on. Most overrides end up in a tool
  * description, and a number or an array there would produce an invalid
  * `tools/list` payload.
+ *
+ * A file that exists but cannot be parsed is reported and then ignored.
+ * Overriding descriptions is an add-on, and a trailing comma in an optional file
+ * is not a reason to stop serving the tools — from the client's side an
+ * exception here looks like "the MCP server will not connect", with nothing
+ * pointing at the config file.
+ */
+/**
+ * Checked in this order; the first one that exists wins. The extensionless form
+ * is parsed as YAML, which also accepts JSON.
+ */
+const SUFFIXES = ['', '.json', '.yaml', '.yml'];
+/**
+ * A missing candidate is not a failure — there are four of them and at most one
+ * exists. A candidate that exists but does not parse is, and has to be
+ * distinguished from the missing case so it can be reported rather than skipped.
  */
+function readCandidate(filePath) {
+    let raw;
+    try {
+        raw = readFileSync(filePath, 'utf-8');
+    }
+    catch (error) {
+        if (error instanceof Error &&
+            'code' in error &&
+            (error.code === 'ENOENT' || error.code === 'ENOTDIR')) {
+            return { status: 'absent' };
+        }
+        return { status: 'unreadable', error };
+    }
+    try {
+        // An empty file is a config file with nothing in it, not a parse failure.
+        // `JSON.parse('')` throws, so it never reaches the caller's object check.
+        if (raw.trim() === '')
+            return { status: 'found', config: undefined };
+        return {
+            status: 'found',
+            config: filePath.endsWith('.json') ? JSON.parse(raw) : load(raw),
+        };
+    }
+    catch (error) {
+        return { status: 'unreadable', error };
+    }
+}
 export function loadDescriptionOverrides(options) {
-    const explorer = cosmiconfigSync(options?.configName ?? 'backlog-mcp-server');
-    const searchPath = options?.searchDir ?? os.homedir();
-    const config = explorer.search(searchPath)?.config;
-    if (typeof config !== 'object' || config === null || Array.isArray(config)) {
-        return {};
+    const configName = options?.configName ?? 'backlog-mcp-server';
+    const searchDir = options?.searchDir ?? os.homedir();
+    for (const suffix of SUFFIXES) {
+        const filePath = path.join(searchDir, `.${configName}rc${suffix}`);
+        const outcome = readCandidate(filePath);
+        if (outcome.status === 'absent')
+            continue;
+        if (outcome.status === 'unreadable') {
+            // `logger.error`, not `warn`: the logger runs at level `error` unless
+            // NODE_ENV says otherwise, so a warning here would never reach the user
+            // this message exists for.
+            logger.error({ err: outcome.error, filePath }, 'Could not read the description override file; continuing with the built-in defaults');
+            return {};
+        }
+        const config = outcome.config;
+        if (typeof config !== 'object' ||
+            config === null ||
+            Array.isArray(config)) {
+            return {};
+        }
+        return Object.fromEntries(Object.entries(config).filter(([, value]) => typeof value === 'string'));
     }
-    return Object.fromEntries(Object.entries(config).filter(([, value]) => typeof value === 'string'));
+    return {};
 }

package/build/reportUnknownOverrideKeys.d.ts

@@ -0,0 +1,22 @@
+import type { Backlog } from 'backlog-js';
+import type { MCPOptions } from './types/mcp.js';
+import type { BacklogClientRegistry } from './utils/backlogClientRegistry.js';
+/**
+ * Reports override keys in the config file that no tool or parameter asks for.
+ *
+ * The override keys are an untyped, unversioned public API: rename one in the
+ * source and every user's override for it stops applying, falls back to the
+ * built-in default, and says nothing. The user sees "I configured this and it
+ * has no effect". This turns that into a line in the server log.
+ *
+ * The comparison is exact, which also catches keys written in the wrong case —
+ * `t()` looks up `key.toUpperCase()`, so a lower-case entry in the config file
+ * never matches anything either.
+ */
+export declare function reportUnknownOverrideKeys({ overrides, version, backlog, clientRegistry, mcpOption, }: {
+    overrides: Record<string, string>;
+    version: string;
+    backlog: Backlog;
+    clientRegistry: BacklogClientRegistry;
+    mcpOption: MCPOptions;
+}): void;

package/build/reportUnknownOverrideKeys.js

@@ -0,0 +1,42 @@
+import { createBacklogMcpServer } from './createBacklogMcpServer.js';
+import { createDescriptionHelper } from './createDescriptionHelper.js';
+import { logger } from './utils/logger.js';
+/**
+ * Reports override keys in the config file that no tool or parameter asks for.
+ *
+ * The override keys are an untyped, unversioned public API: rename one in the
+ * source and every user's override for it stops applying, falls back to the
+ * built-in default, and says nothing. The user sees "I configured this and it
+ * has no effect". This turns that into a line in the server log.
+ *
+ * The comparison is exact, which also catches keys written in the wrong case —
+ * `t()` looks up `key.toUpperCase()`, so a lower-case entry in the config file
+ * never matches anything either.
+ */
+export function reportUnknownOverrideKeys({ overrides, version, backlog, clientRegistry, mcpOption, }) {
+    const configured = Object.keys(overrides);
+    if (configured.length === 0)
+        return;
+    // Keys are only recorded once a tool asks for them, so the set of valid keys
+    // is whatever building the full tool list touches. This is a throwaway helper
+    // and server built purely to collect them: the real ones may have toolsets
+    // disabled, and their keys would then look unknown. ~17ms, and only for users
+    // who actually have a config file.
+    const probe = createDescriptionHelper();
+    createBacklogMcpServer({
+        version,
+        useFields: mcpOption.useFields,
+        backlog,
+        clientRegistry,
+        descriptionHelper: probe,
+        enabledToolsets: ['all'],
+        mcpOption: { ...mcpOption, useOrganization: true },
+    });
+    const known = new Set(Object.keys(probe.dump()));
+    const unknown = configured.filter((key) => !known.has(key));
+    if (unknown.length === 0)
+        return;
+    // `error`, not `warn`: the logger drops anything below error in the default
+    // configuration, which is what users run.
+    logger.error({ keys: unknown }, 'These description override keys match no tool or parameter and had no effect');
+}

package/build/tools/addDocument.d.ts

@@ -1,7 +1,7 @@
+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 addDocumentSchema: (t: DescriptionHelper["t"]) => {
     projectId: z.ZodNumber;
@@ -11,5 +11,5 @@ declare const addDocumentSchema: (t: DescriptionHelper["t"]) => {
     parentId: z.ZodOptional<z.ZodString>;
     addLast: z.ZodOptional<z.ZodBoolean>;
 };
-export declare const addDocumentTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof addDocumentSchema>, (typeof DocumentItemSchema)["shape"]>;
+export declare const addDocumentTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof addDocumentSchema>, Entity.Document.Document>;
 export {};

package/build/tools/addDocument.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 addDocumentSchema = buildToolSchema((t) => ({
     projectId: z
         .number()
@@ -31,7 +31,22 @@ export const addDocumentTool = (backlog, { t }) => {
         name: 'addDocument',
         description: t('TOOL_ADD_DOCUMENT_DESCRIPTION', 'Adds a new document to the specified project.'),
         schema: z.object(addDocumentSchema(t)),
-        outputSchema: DocumentItemSchema,
+        returnsList: false,
+        outputFields: outputFields()([
+            'id',
+            'projectId',
+            'title',
+            'plain',
+            'json',
+            'statusId',
+            'emoji',
+            'attachments',
+            'tags',
+            'createdUser',
+            'created',
+            'updatedUser',
+            'updated',
+        ]),
         importantFields: ['id', 'projectId', 'title', 'plain', 'createdUser'],
         handler: async (params) => {
             return backlog.addDocument(params);

package/build/tools/addIssue.d.ts

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

package/build/tools/addIssue.js

@@ -1,6 +1,6 @@
 import { z } from 'zod';
-import { IssueSchema } from '../types/zod/backlogOutputDefinition.js';
 import { buildToolSchema } from '../types/tool.js';
+import { outputFields } from '../types/outputFields.js';
 import { customFieldsToPayload } from '../backlog/customFields.js';
 const addIssueSchema = buildToolSchema((t) => ({
     projectId: z.number().describe(t('TOOL_ADD_ISSUE_PROJECT_ID', 'Project ID')),
@@ -88,7 +88,37 @@ export const addIssueTool = (backlog, { t }) => {
         name: 'add_issue',
         description: t('TOOL_ADD_ISSUE_DESCRIPTION', 'Creates a new issue in the specified project.'),
         schema: z.object(addIssueSchema(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',
+        ]),
         importantFields: ['summary', 'issueKey', 'description', 'createdUser'],
         handler: async ({ customFields, ...params }) => {
             const customFieldPayload = customFieldsToPayload(customFields);

package/build/tools/addIssueComment.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 addIssueCommentSchema: (t: DescriptionHelper["t"]) => {
     issueId: z.ZodOptional<z.ZodNumber>;
     issueKey: z.ZodOptional<z.ZodString>;
@@ -10,5 +10,5 @@ declare const addIssueCommentSchema: (t: DescriptionHelper["t"]) => {
     notifiedUserId: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
     attachmentId: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
 };
-export declare const addIssueCommentTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof addIssueCommentSchema>, (typeof IssueCommentSchema)["shape"]>;
+export declare const addIssueCommentTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof addIssueCommentSchema>, Entity.Issue.Comment>;
 export {};

package/build/tools/addIssueComment.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 addIssueCommentSchema = buildToolSchema((t) => ({
     issueId: z
@@ -28,7 +28,19 @@ export const addIssueCommentTool = (backlog, { t }) => {
         name: 'add_issue_comment',
         description: t('TOOL_ADD_ISSUE_COMMENT_DESCRIPTION', 'Adds a comment to an issue'),
         schema: z.object(addIssueCommentSchema(t)),
-        outputSchema: IssueCommentSchema,
+        returnsList: false,
+        outputFields: outputFields()([
+            'id',
+            'projectId',
+            'issueId',
+            'content',
+            'changeLog',
+            'createdUser',
+            'created',
+            'updated',
+            'stars',
+            'notifications',
+        ]),
         handler: async ({ issueId, issueKey, content, notifiedUserId, attachmentId, }) => {
             const result = resolveIdOrKey('issue', { id: issueId, key: issueKey }, t);
             if (!result.ok) {

package/build/tools/addProject.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 { ProjectSchema } from '../types/zod/backlogOutputDefinition.js';
 declare const addProjectSchema: (t: DescriptionHelper["t"]) => {
     name: z.ZodString;
     key: z.ZodString;
@@ -14,5 +14,5 @@ declare const addProjectSchema: (t: DescriptionHelper["t"]) => {
         markdown: "markdown";
     }>>;
 };
-export declare const addProjectTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof addProjectSchema>, (typeof ProjectSchema)["shape"]>;
+export declare const addProjectTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof addProjectSchema>, Entity.Project.Project>;
 export {};

package/build/tools/addProject.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 addProjectSchema = buildToolSchema((t) => ({
     name: z.string().describe(t('TOOL_ADD_PROJECT_NAME', 'Project name')),
     key: z.string().describe(t('TOOL_ADD_PROJECT_KEY', 'Project key')),
@@ -26,7 +26,27 @@ export const addProjectTool = (backlog, { t }) => {
         name: 'add_project',
         description: t('TOOL_ADD_PROJECT_DESCRIPTION', 'Creates a new project'),
         schema: z.object(addProjectSchema(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 ({ name, key, chartEnabled, subtaskingEnabled, projectLeaderCanEditProjectLeader, textFormattingRule, }) => backlog.postProject({
             name,
             key,

package/build/tools/addPullRequest.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 addPullRequestSchema: (t: DescriptionHelper["t"]) => {
     projectId: z.ZodOptional<z.ZodNumber>;
     projectKey: z.ZodOptional<z.ZodString>;
@@ -16,5 +16,5 @@ declare const addPullRequestSchema: (t: DescriptionHelper["t"]) => {
     assigneeId: z.ZodOptional<z.ZodNumber>;
     notifiedUserId: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
 };
-export declare const addPullRequestTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof addPullRequestSchema>, (typeof PullRequestSchema)["shape"]>;
+export declare const addPullRequestTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof addPullRequestSchema>, Entity.PullRequest.PullRequest>;
 export {};

package/build/tools/addPullRequest.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 addPullRequestSchema = buildToolSchema((t) => ({
     projectId: z
@@ -49,7 +49,31 @@ export const addPullRequestTool = (backlog, { t }) => {
         name: 'add_pull_request',
         description: t('TOOL_ADD_PULL_REQUEST_DESCRIPTION', 'Creates a new pull request'),
         schema: z.object(addPullRequestSchema(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, ...params }) => {
             const result = resolveIdOrKey('project', { id: projectId, key: projectKey }, t);
             if (!result.ok) {

package/build/tools/addPullRequestComment.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 addPullRequestCommentSchema: (t: DescriptionHelper["t"]) => {
     projectId: z.ZodOptional<z.ZodNumber>;
     projectKey: z.ZodOptional<z.ZodString>;
@@ -12,5 +12,5 @@ declare const addPullRequestCommentSchema: (t: DescriptionHelper["t"]) => {
     content: z.ZodString;
     notifiedUserId: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
 };
-export declare const addPullRequestCommentTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof addPullRequestCommentSchema>, (typeof PullRequestCommentSchema)["shape"]>;
+export declare const addPullRequestCommentTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof addPullRequestCommentSchema>, Entity.PullRequest.Comment>;
 export {};

package/build/tools/addPullRequestComment.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 addPullRequestCommentSchema = buildToolSchema((t) => ({
     projectId: z
@@ -35,7 +35,17 @@ export const addPullRequestCommentTool = (backlog, { t }) => {
         name: 'add_pull_request_comment',
         description: t('TOOL_ADD_PULL_REQUEST_COMMENT_DESCRIPTION', 'Adds a comment to a pull request'),
         schema: z.object(addPullRequestCommentSchema(t)),
-        outputSchema: PullRequestCommentSchema,
+        returnsList: false,
+        outputFields: outputFields()([
+            'id',
+            'content',
+            'changeLog',
+            'createdUser',
+            'created',
+            'updated',
+            'stars',
+            'notifications',
+        ]),
         importantFields: ['id', 'content', 'createdUser'],
         handler: async ({ projectId, projectKey, repoId, repoName, number, ...params }) => {
             const result = resolveIdOrKey('project', { id: projectId, key: projectKey }, t);

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

package/build/tools/addRelatedIssue.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 addRelatedIssueSchema = buildToolSchema((t) => ({
     issueId: z
@@ -20,7 +20,38 @@ export const addRelatedIssueTool = (backlog, { t }) => {
         name: 'add_related_issue',
         description: t('TOOL_ADD_RELATED_ISSUE_DESCRIPTION', 'Relates an issue to another issue'),
         schema: z.object(addRelatedIssueSchema(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, targetIssueId }) => {
             const result = resolveIdOrKey('issue', { id: issueId, key: issueKey }, t);
             if (!result.ok) {

package/build/tools/addVersionMilestone.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 { VersionSchema } from '../types/zod/backlogOutputDefinition.js';
 declare const addVersionMilestoneSchema: (t: DescriptionHelper["t"]) => {
     projectId: z.ZodOptional<z.ZodNumber>;
     projectKey: z.ZodOptional<z.ZodString>;
@@ -11,5 +11,5 @@ declare const addVersionMilestoneSchema: (t: DescriptionHelper["t"]) => {
     startDate: z.ZodOptional<z.ZodString>;
     releaseDueDate: z.ZodOptional<z.ZodString>;
 };
-export declare const addVersionMilestoneTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof addVersionMilestoneSchema>, (typeof VersionSchema)["shape"]>;
+export declare const addVersionMilestoneTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof addVersionMilestoneSchema>, Entity.Project.Version>;
 export {};

package/build/tools/addVersionMilestone.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 addVersionMilestoneSchema = buildToolSchema((t) => ({
     projectId: z
@@ -32,7 +32,17 @@ export const addVersionMilestoneTool = (backlog, { t }) => {
         name: 'add_version_milestone',
         description: t('TOOL_ADD_VERSION_MILESTONE_DESCRIPTION', 'Creates a new version milestone'),
         schema: z.object(addVersionMilestoneSchema(t)),
-        outputSchema: VersionSchema,
+        returnsList: false,
+        outputFields: outputFields()([
+            'id',
+            'projectId',
+            'name',
+            'description',
+            'startDate',
+            'releaseDueDate',
+            'archived',
+            'displayOrder',
+        ]),
         importantFields: [
             'id',
             'name',

package/build/tools/addWatching.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 addWatchingSchema: (t: DescriptionHelper["t"]) => {
     issueIdOrKey: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
     note: z.ZodDefault<z.ZodOptional<z.ZodString>>;
 };
-export declare const addWatchingTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof addWatchingSchema>, (typeof WatchingListItemSchema)["shape"]>;
+export declare const addWatchingTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof addWatchingSchema>, Entity.WatchingList.WatchingListItem>;
 export {};

package/build/tools/addWatching.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 addWatchingSchema = buildToolSchema((t) => ({
     issueIdOrKey: z
         .union([z.number(), z.string()])
@@ -16,7 +16,17 @@ export const addWatchingTool = (backlog, { t }) => {
         name: 'add_watching',
         description: t('TOOL_ADD_WATCHING_DESCRIPTION', 'Adds a new watch to an issue'),
         schema: z.object(addWatchingSchema(t)),
-        outputSchema: WatchingListItemSchema,
+        returnsList: false,
+        outputFields: outputFields()([
+            'id',
+            'resourceAlreadyRead',
+            'note',
+            'type',
+            'issue',
+            'lastContentUpdated',
+            'created',
+            'updated',
+        ]),
         handler: async ({ issueIdOrKey, note }) => backlog.postWatchingListItem({
             issueIdOrKey,
             note,