backlog-mcp-server 0.17.0 → 0.18.0

package/build/tools/updateIssue.d.ts

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

package/build/tools/updateIssue.js

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

package/build/tools/updateIssueComment.d.ts

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

package/build/tools/updateIssueComment.js

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

package/build/tools/updateProject.d.ts

@@ -1,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 updateProjectSchema: (t: DescriptionHelper["t"]) => {
     projectId: z.ZodOptional<z.ZodNumber>;
     projectKey: z.ZodOptional<z.ZodString>;
@@ -17,5 +17,5 @@ declare const updateProjectSchema: (t: DescriptionHelper["t"]) => {
     }>>;
     archived: z.ZodOptional<z.ZodBoolean>;
 };
-export declare const updateProjectTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof updateProjectSchema>, (typeof ProjectSchema)["shape"]>;
+export declare const updateProjectTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof updateProjectSchema>, Entity.Project.Project>;
 export {};

package/build/tools/updateProject.js

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

package/build/tools/updatePullRequest.d.ts

@@ -1,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 updatePullRequestSchema: (t: DescriptionHelper["t"]) => {
     projectId: z.ZodOptional<z.ZodNumber>;
     projectKey: z.ZodOptional<z.ZodString>;
@@ -16,5 +16,5 @@ declare const updatePullRequestSchema: (t: DescriptionHelper["t"]) => {
     notifiedUserId: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
     statusId: z.ZodOptional<z.ZodNumber>;
 };
-export declare const updatePullRequestTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof updatePullRequestSchema>, (typeof PullRequestSchema)["shape"]>;
+export declare const updatePullRequestTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof updatePullRequestSchema>, Entity.PullRequest.PullRequest>;
 export {};

package/build/tools/updatePullRequest.js

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

package/build/tools/updatePullRequestComment.d.ts

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

package/build/tools/updatePullRequestComment.js

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

package/build/tools/updateVersionMilestone.d.ts

@@ -1,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 updateVersionMilestoneSchema: (t: DescriptionHelper["t"]) => {
     projectId: z.ZodOptional<z.ZodNumber>;
     projectKey: z.ZodOptional<z.ZodString>;
@@ -13,5 +13,5 @@ declare const updateVersionMilestoneSchema: (t: DescriptionHelper["t"]) => {
     releaseDueDate: z.ZodOptional<z.ZodString>;
     archived: z.ZodOptional<z.ZodBoolean>;
 };
-export declare const updateVersionMilestoneTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof updateVersionMilestoneSchema>, (typeof VersionSchema)["shape"]>;
+export declare const updateVersionMilestoneTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof updateVersionMilestoneSchema>, Entity.Project.Version>;
 export {};

package/build/tools/updateVersionMilestone.js

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

package/build/tools/updateWatching.d.ts

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

package/build/tools/updateWatching.js

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

package/build/tools/updateWiki.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 updateWikiSchema: (t: DescriptionHelper["t"]) => {
     wikiId: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
     name: z.ZodOptional<z.ZodString>;
     content: z.ZodOptional<z.ZodString>;
     mailNotify: z.ZodOptional<z.ZodBoolean>;
 };
-export declare const updateWikiTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof updateWikiSchema>, (typeof WikiSchema)["shape"]>;
+export declare const updateWikiTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof updateWikiSchema>, Entity.Wiki.Wiki>;
 export {};

package/build/tools/updateWiki.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 updateWikiSchema = buildToolSchema((t) => ({
     wikiId: z
         .union([z.string(), z.number()])
@@ -23,7 +23,21 @@ export const updateWikiTool = (backlog, { t }) => {
         name: 'update_wiki',
         description: t('TOOL_UPDATE_WIKI_DESCRIPTION', 'Updates an existing wiki page'),
         schema: z.object(updateWikiSchema(t)),
-        outputSchema: WikiSchema,
+        returnsList: false,
+        outputFields: outputFields()([
+            'id',
+            'projectId',
+            'name',
+            'content',
+            'tags',
+            'attachments',
+            'sharedFiles',
+            'stars',
+            'createdUser',
+            'created',
+            'updatedUser',
+            'updated',
+        ]),
         importantFields: ['id', 'name', 'content', 'updatedUser'],
         handler: async ({ wikiId, name, content, mailNotify }) => {
             const wikiIdNumber = typeof wikiId === 'string' ? parseInt(wikiId, 10) : wikiId;

package/build/types/outputFields.d.ts

@@ -0,0 +1,26 @@
+/**
+ * The list of field names a tool's result carries.
+ *
+ * Only names are needed at runtime — `--optimize-response` publishes them as the
+ * enum of its `fields` parameter — and TypeScript types are erased, so the list
+ * has to be written out. What this adds is that writing it wrong does not
+ * compile: the names are checked against the `backlog-js` type in both
+ * directions, so a field that package gains, or one it never had, is a build
+ * error rather than a quiet difference.
+ *
+ *     outputFields<Entity.Issue.Issue>()(['id', 'projectId', ...])
+ *
+ * Missing a name fails with the name in the message:
+ *
+ *     Type '{ __outputFieldsMissing: "childIssueSummary"; }' is missing the
+ *     following properties from type 'readonly (keyof Issue)[]'
+ *
+ * A name the type does not have fails with:
+ *
+ *     Type '"nope"' is not assignable to type 'keyof Space'
+ */
+type Missing<T, K extends readonly PropertyKey[]> = Exclude<keyof T, K[number]>;
+export declare function outputFields<T>(): <K extends readonly (keyof T)[]>(keys: K) => [Missing<T, K>] extends [never] ? readonly (keyof T)[] : {
+    __outputFieldsMissing: Missing<T, K>;
+};
+export {};

package/build/types/outputFields.js

@@ -0,0 +1,3 @@
+export function outputFields() {
+    return (keys) => keys;
+}

package/build/types/tool.d.ts

@@ -1,16 +1,32 @@
 import { z } from 'zod';
 import { DescriptionHelper } from '../createDescriptionHelper.js';
 import { CallToolResult } from '@modelcontextprotocol/server';
-export type ToolDefinition<Shape extends z.ZodRawShape, OutputShape extends z.ZodRawShape> = {
+export type ToolDefinition<Shape extends z.ZodRawShape, Result> = {
     name: string;
     description: string;
     schema: z.ZodObject<Shape>;
-    outputSchema: z.ZodObject<OutputShape>;
+    outputFields: readonly (keyof Result)[];
     handler: (input: z.infer<z.ZodObject<Shape>> & {
-        fields?: string;
+        fields?: string[];
         organization?: string;
-    }) => Promise<z.infer<z.ZodObject<OutputShape>> | z.infer<z.ZodObject<OutputShape>>[]>;
-    importantFields?: (keyof z.infer<z.ZodObject<OutputShape>>)[];
+    }) => Promise<Result | Result[]>;
+    importantFields?: (keyof Result)[];
+    /**
+     * Whether the Backlog call behind this tool returns a list.
+     *
+     * `--optimize-response` only publishes its `fields` parameter on these. A list
+     * is the case where the response grows without bound — `get_issues` alone
+     * returns up to 100 issues — and where trimming it is worth the schema every
+     * client downloads. A tool that returns one record saves a few hundred bytes at
+     * best, against a cost paid on every session by everyone.
+     *
+     * Verifiable: it is true exactly for the tools whose `backlog-js` method is
+     * declared as `Promise<T[]>`.
+     *
+     * Required rather than optional so that a new tool has to answer the question.
+     * Left optional, forgetting it would silently mean "no field selection".
+     */
+    returnsList: boolean;
 };
 export declare const buildToolSchema: <T extends z.ZodRawShape>(fn: (t: DescriptionHelper["t"]) => T) => (t: DescriptionHelper["t"]) => T;
 export type DynamicToolDefinition<Shape extends z.ZodRawShape> = {
@@ -19,6 +35,3 @@ export type DynamicToolDefinition<Shape extends z.ZodRawShape> = {
     schema: z.ZodObject<Shape>;
     handler: (input: z.infer<z.ZodObject<Shape>>) => Promise<CallToolResult>;
 };
-export interface ToolRegistrar {
-    enableToolsetAndRefresh(toolset: string): Promise<string>;
-}

package/build/types/zod/activityType.d.ts

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+/**
+ * The activity type ids the Backlog API accepts as a filter.
+ *
+ * All that is left of backlogOutputDefinition.ts. That file described API
+ * responses in parallel with the types backlog-js already ships; tools now take
+ * their field names from those types instead. This one is different: it is an
+ * input filter, and backlog-js has no enum for it.
+ */
+export declare const ActivityTypeSchema: z.ZodEnum<{
+    Undefined: number;
+    IssueCreated: number;
+    IssueUpdated: number;
+    IssueCommented: number;
+    IssueDeleted: number;
+    WikiCreated: number;
+    WikiUpdated: number;
+    WikiDeleted: number;
+    FileAdded: number;
+    FileUpdated: number;
+    FileDeleted: number;
+    SvnCommitted: number;
+    GitPushed: number;
+    GitRepositoryCreated: number;
+    IssueMultiUpdated: number;
+    ProjectUserAdded: number;
+    ProjectUserRemoved: number;
+    NotifyAdded: number;
+    PullRequestAdded: number;
+    PullRequestUpdated: number;
+    PullRequestCommented: number;
+    PullRequestMerged: number;
+    MilestoneCreated: number;
+    MilestoneUpdated: number;
+    MilestoneDeleted: number;
+    ProjectGroupAdded: number;
+    ProjectGroupDeleted: number;
+}>;

package/build/types/zod/activityType.js

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+/**
+ * The activity type ids the Backlog API accepts as a filter.
+ *
+ * All that is left of backlogOutputDefinition.ts. That file described API
+ * responses in parallel with the types backlog-js already ships; tools now take
+ * their field names from those types instead. This one is different: it is an
+ * input filter, and backlog-js has no enum for it.
+ */
+export const ActivityTypeSchema = z.nativeEnum({
+    Undefined: -1,
+    IssueCreated: 1,
+    IssueUpdated: 2,
+    IssueCommented: 3,
+    IssueDeleted: 4,
+    WikiCreated: 5,
+    WikiUpdated: 6,
+    WikiDeleted: 7,
+    FileAdded: 8,
+    FileUpdated: 9,
+    FileDeleted: 10,
+    SvnCommitted: 11,
+    GitPushed: 12,
+    GitRepositoryCreated: 13,
+    IssueMultiUpdated: 14,
+    ProjectUserAdded: 15,
+    ProjectUserRemoved: 16,
+    NotifyAdded: 17,
+    PullRequestAdded: 18,
+    PullRequestUpdated: 19,
+    PullRequestCommented: 20,
+    PullRequestMerged: 21,
+    MilestoneCreated: 22,
+    MilestoneUpdated: 23,
+    MilestoneDeleted: 24,
+    ProjectGroupAdded: 25,
+    ProjectGroupDeleted: 26,
+});

package/build/utils/fieldSelection.d.ts

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+/**
+ * Describes the `fields` parameter that `--optimize-response` adds to a tool.
+ *
+ * The selectable names come straight from the tool's `outputFields`, so they are
+ * published as a JSON Schema enum rather than described in prose. That is the
+ * whole point of the shape: the enum *is* the documentation, an unknown name is
+ * rejected by schema validation instead of being silently dropped, and the text
+ * shrinks to one sentence per tool.
+ *
+ * Selection is one level deep. It used to accept a GraphQL selection set, parsed
+ * with the `graphql` package, which cost ~1 MB for one `parse` call and accepted
+ * far more of the grammar than was ever honoured — aliases, fragments, arguments
+ * and directives all parsed and were then quietly ignored, and descending into an
+ * array field returned `{}` and lost the data.
+ */
+export declare function fieldSelection(outputFields: readonly PropertyKey[], importantFields?: readonly PropertyKey[]): {
+    names: string[];
+    description: string;
+} | undefined;
+/** The `fields` parameter itself, or undefined when the tool has nothing to offer. */
+export declare function fieldSelectionSchema(outputFields: readonly PropertyKey[], importantFields?: readonly PropertyKey[]): z.ZodOptional<z.ZodArray<z.ZodEnum<Record<string, string>>>> | undefined;

package/build/utils/fieldSelection.js

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+/**
+ * Describes the `fields` parameter that `--optimize-response` adds to a tool.
+ *
+ * The selectable names come straight from the tool's `outputFields`, so they are
+ * published as a JSON Schema enum rather than described in prose. That is the
+ * whole point of the shape: the enum *is* the documentation, an unknown name is
+ * rejected by schema validation instead of being silently dropped, and the text
+ * shrinks to one sentence per tool.
+ *
+ * Selection is one level deep. It used to accept a GraphQL selection set, parsed
+ * with the `graphql` package, which cost ~1 MB for one `parse` call and accepted
+ * far more of the grammar than was ever honoured — aliases, fragments, arguments
+ * and directives all parsed and were then quietly ignored, and descending into an
+ * array field returned `{}` and lost the data.
+ */
+export function fieldSelection(outputFields, importantFields = []) {
+    // `keyof T` admits numbers and symbols. Entity keys are all strings, but taking
+    // PropertyKey here keeps the caller from having to assert that.
+    const names = outputFields.map(String);
+    // `z.enum([])` is not constructible, and a tool with no known output fields has
+    // nothing to select from anyway.
+    if (names.length === 0)
+        return undefined;
+    const useful = importantFields.map(String).filter((f) => names.includes(f));
+    const description = useful.length > 0
+        ? `Return only these fields of the result, to keep the response small. Most callers want: ${useful.join(', ')}.`
+        : 'Return only these fields of the result, to keep the response small.';
+    return { names, description };
+}
+/** The `fields` parameter itself, or undefined when the tool has nothing to offer. */
+export function fieldSelectionSchema(outputFields, importantFields = []) {
+    const selection = fieldSelection(outputFields, importantFields);
+    if (!selection)
+        return undefined;
+    return z
+        .array(z.enum(selection.names))
+        .optional()
+        .describe(selection.description);
+}

package/build/utils/toolsetUtils.d.ts

@@ -1,6 +1,4 @@
 import { Backlog } from 'backlog-js';
-import { ToolsetGroup, Toolset } from '../types/toolsets.js';
+import { ToolsetGroup } from '../types/toolsets.js';
 import { DescriptionHelper } from '../createDescriptionHelper.js';
-export declare function getToolset(group: ToolsetGroup, name: string): Toolset | undefined;
-export declare function enableToolset(group: ToolsetGroup, name: string): string;
 export declare const buildToolsetGroup: (backlog: Backlog, helper: DescriptionHelper, enabledToolsets: string[]) => ToolsetGroup;