backlog-mcp-server 0.18.0 → 0.19.0

package/README.ja.md

@@ -469,6 +469,22 @@ MAX_TOKENS=10000
 
 > 注：これはベストエフォートの緩和策であり、保証された強制ではありません。
 
+### ログ出力
+
+ログは **stderr** に出力されます（stdio トランスポートでは stdout が JSON-RPC のストリームに使われるため）。
+
+| 変数        | 説明                                                                                                                                                                        |
+| ----------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `LOG_LEVEL` | `fatal` / `error` / `warn` / `info` / `debug` / `trace` / `silent`。既定は `NODE_ENV` が `production`（未設定時もこれに含まれる）のとき `error`、それ以外は `debug`。認識できない値は通知した上で既定値にフォールバックします。 |
+
+出力**フォーマット**は引き続き `NODE_ENV` が決めます（`production` 以外では `pino-pretty` が利用可能なら人間向けの整形出力に切り替わります）。ログ量を変えたいときは `NODE_ENV` ではなく `LOG_LEVEL` を設定してください。デプロイ先で構造化 JSON のまま保てます。
+
+`pino-pretty` は開発用の依存なので、公開されている npm パッケージにもコンテナイメージにも含まれていません。そのため、これらでは `NODE_ENV` の値に関わらず常に構造化 JSON が出力され、出力を変えられるのは `LOG_LEVEL` だけです。
+
+```
+LOG_LEVEL=info node build/index.js --transport http
+```
+
 ### 完全なカスタム設定例
 
 このセクションでは、複数の環境変数を使用した高度な設定を示します。これらは実験的な機能であり、すべてのMCPクライアントでサポートされているとは限りません。これはMCP標準仕様の一部ではなく、注意して使用する必要があります。

package/README.md

@@ -294,6 +294,7 @@ Tools for managing projects, categories, custom fields, and issue types.
 Tools for managing issues, their comments, and related items like priorities, categories, custom fields, issue types, resolutions, and watching lists.
 
 - `get_issue`: Returns information about a specific issue.
+- `get_issue_attachment`: Downloads one attachment of an issue. Returns it as image or embedded resource content, or as base64 with `format: "base64"`.
 - `get_issues`: Returns list of issues.
 - `count_issues`: Returns count of issues.
 - `add_issue`: Creates a new issue in the specified project.
@@ -586,6 +587,22 @@ If a response exceeds the limit, it will be truncated with a warning.
 
 > Note: This is a best-effort mitigation, not a guaranteed enforcement.
 
+### Logging
+
+The server logs to **stderr** (stdout carries the JSON-RPC stream on the stdio transport).
+
+| Variable    | Description                                                                                                                                                                                             |
+| ----------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `LOG_LEVEL` | `fatal`, `error`, `warn`, `info`, `debug`, `trace` or `silent`. Defaults to `error` when `NODE_ENV` is `production` — which is also the default when `NODE_ENV` is unset — and to `debug` otherwise. An unrecognised value is reported and the default is used. |
+
+`NODE_ENV` still selects the output *format*: any value other than `production` switches to human-readable `pino-pretty` output when that package is available. Use `LOG_LEVEL`, not `NODE_ENV`, to change how much is logged, so that a deployment keeps structured JSON:
+
+`pino-pretty` is a development dependency, so neither the published npm package nor the container image carries a copy. In those, logs are structured JSON whatever `NODE_ENV` says, and `LOG_LEVEL` is the only setting that changes the output.
+
+```
+LOG_LEVEL=info node build/index.js --transport http
+```
+
 ### Full Custom Configuration Example
 
 This section demonstrates advanced configuration using multiple environment variables. These are experimental features and may not be supported across all MCP clients. This is not part of the MCP standard specification and should be used with caution.

package/build/auth/oauthRoutes.js

@@ -119,7 +119,7 @@ export function createOAuthRoutes(config, store, mcpPath) {
         const declaredApplicationType = body.application_type ?? undefined;
         if (declaredApplicationType !== undefined &&
             !APPLICATION_TYPES.includes(declaredApplicationType)) {
-            return c.json(oauthError('invalid_client_metadata', `Unsupported application_type: ${String(declaredApplicationType)}. Supported: ${APPLICATION_TYPES.join(', ')}`), 400);
+            return c.json(oauthError('invalid_client_metadata', `Unsupported application_type: ${JSON.stringify(declaredApplicationType)}. Supported: ${APPLICATION_TYPES.join(', ')}`), 400);
         }
         const applicationType = resolveApplicationType(declaredApplicationType, redirectUris);
         if (applicationType === 'web') {

package/build/backlog/customFields.js

@@ -49,20 +49,23 @@ export function customFieldFiltersToPayload(customFields) {
                 break;
             }
             case 'list': {
-                if (Array.isArray(field.value)) {
-                    const values = field.value.filter((value) => Number.isFinite(value));
-                    if (values.length > 0) {
-                        result[`${baseKey}[]`] = values;
-                    }
-                }
-                else if (Number.isFinite(field.value)) {
-                    result[baseKey] = field.value;
+                // Always an array, single value included. Backlog matches a list custom
+                // field only on the indexed parameters `customField_1[0]=…`, which
+                // `Request.toQueryString` produces from an array under a `customField_`
+                // key. A bare `customField_1=…` is not matched, and neither is the
+                // `customField_1[][0]=…` that a `[]` suffix on this key would produce.
+                // Neither is rejected either — the filter is silently ignored and every
+                // issue comes back, so the caller cannot tell a filtered query from an
+                // unfiltered one.
+                const values = (Array.isArray(field.value) ? field.value : [field.value]).filter((value) => Number.isFinite(value));
+                if (values.length > 0) {
+                    result[baseKey] = values;
                 }
                 break;
             }
             default: {
                 const exhaustiveCheck = field;
-                throw new Error(`Unsupported custom field filter type: ${exhaustiveCheck}`);
+                throw new Error(`Unsupported custom field filter type: ${JSON.stringify(exhaustiveCheck)}`);
             }
         }
     }

package/build/handlers/builders/composeDynamicToolHandler.d.ts

@@ -0,0 +1,147 @@
+import { z } from 'zod';
+import { ErrorLike } from '../../types/result.js';
+import { DynamicToolDefinition } from '../../types/tool.js';
+export type ComposeDynamicOptions = {
+    errorHandler?: (err: unknown) => ErrorLike;
+    useOrganization?: boolean;
+};
+type DynamicInput = {
+    organization?: string;
+} & Record<string, unknown>;
+/**
+ * Builds the schema and handler a dynamic tool is registered with.
+ *
+ * The counterpart of `composeToolHandler` for tools that produce a
+ * `CallToolResult` themselves. Those cannot go through the whole pipeline:
+ * field picking, the token limit and `wrapWithToolResult` all assume a JSON
+ * value they may reshape, and reshaping is exactly what a tool returning binary
+ * content must not allow — a base64 payload cut at the token limit is a corrupt
+ * file reported as a success.
+ *
+ * The two steps that are not about reshaping still apply, and are why this
+ * exists rather than registering the handler directly:
+ *
+ * - `wrapWithOrganizationContext`, without which a dynamic tool ignores
+ *   `organization` and always talks to the default space;
+ * - `wrapWithErrorHandling`, without which a thrown Backlog error escapes as a
+ *   protocol error rather than an `isError` result, and never reaches the
+ *   handler that reacts to Backlog rejecting a credential.
+ *
+ * As in `composeToolHandler`, the returned schema is a fresh object: the tool
+ * definition is never mutated, because one toolset group is shared across
+ * per-request servers.
+ */
+export declare function composeDynamicToolHandler(tool: DynamicToolDefinition<any>, { errorHandler, useOrganization }?: ComposeDynamicOptions): {
+    schema: z.ZodObject<{
+        [x: string]: any;
+        organization: z.ZodOptional<z.ZodString>;
+    } | {
+        [x: string]: any;
+        organization?: undefined;
+    }, z.core.$strip>;
+    handler: (input: DynamicInput) => Promise<{
+        [x: string]: unknown;
+        _meta?: {
+            [x: string]: unknown;
+            "io.modelcontextprotocol/serverInfo"?: {
+                version: string;
+                websiteUrl?: string | undefined;
+                description?: string | undefined;
+                icons?: {
+                    src: string;
+                    mimeType?: string | undefined;
+                    sizes?: string[] | undefined;
+                    theme?: "dark" | "light" | undefined;
+                }[] | undefined;
+                name: string;
+                title?: string | undefined;
+            } | undefined;
+        } | undefined;
+        content: ({
+            type: "text";
+            text: string;
+            annotations?: {
+                audience?: ("assistant" | "user")[] | undefined;
+                priority?: number | undefined;
+                lastModified?: string | undefined;
+            } | undefined;
+            _meta?: {
+                [x: string]: unknown;
+            } | undefined;
+        } | {
+            type: "image";
+            data: string;
+            mimeType: string;
+            annotations?: {
+                audience?: ("assistant" | "user")[] | undefined;
+                priority?: number | undefined;
+                lastModified?: string | undefined;
+            } | undefined;
+            _meta?: {
+                [x: string]: unknown;
+            } | undefined;
+        } | {
+            type: "audio";
+            data: string;
+            mimeType: string;
+            annotations?: {
+                audience?: ("assistant" | "user")[] | undefined;
+                priority?: number | undefined;
+                lastModified?: string | undefined;
+            } | undefined;
+            _meta?: {
+                [x: string]: unknown;
+            } | undefined;
+        } | {
+            uri: string;
+            description?: string | undefined;
+            mimeType?: string | undefined;
+            size?: number | undefined;
+            annotations?: {
+                audience?: ("assistant" | "user")[] | undefined;
+                priority?: number | undefined;
+                lastModified?: string | undefined;
+            } | undefined;
+            _meta?: {
+                [x: string]: unknown;
+            } | undefined;
+            icons?: {
+                src: string;
+                mimeType?: string | undefined;
+                sizes?: string[] | undefined;
+                theme?: "dark" | "light" | undefined;
+            }[] | undefined;
+            name: string;
+            title?: string | undefined;
+            type: "resource_link";
+        } | {
+            type: "resource";
+            resource: {
+                uri: string;
+                mimeType?: string | undefined;
+                _meta?: {
+                    [x: string]: unknown;
+                } | undefined;
+                text: string;
+            } | {
+                uri: string;
+                mimeType?: string | undefined;
+                _meta?: {
+                    [x: string]: unknown;
+                } | undefined;
+                blob: string;
+            };
+            annotations?: {
+                audience?: ("assistant" | "user")[] | undefined;
+                priority?: number | undefined;
+                lastModified?: string | undefined;
+            } | undefined;
+            _meta?: {
+                [x: string]: unknown;
+            } | undefined;
+        })[];
+        structuredContent?: unknown;
+        isError?: boolean | undefined;
+    }>;
+};
+export {};

package/build/handlers/builders/composeDynamicToolHandler.js

@@ -0,0 +1,55 @@
+import { z } from 'zod';
+import { wrapWithErrorHandling } from '../transformers/wrapWithErrorHandling.js';
+import { wrapWithOrganizationContext } from '../transformers/wrapWithOrganizationContext.js';
+import { isErrorLike } from '../../types/result.js';
+/**
+ * Builds the schema and handler a dynamic tool is registered with.
+ *
+ * The counterpart of `composeToolHandler` for tools that produce a
+ * `CallToolResult` themselves. Those cannot go through the whole pipeline:
+ * field picking, the token limit and `wrapWithToolResult` all assume a JSON
+ * value they may reshape, and reshaping is exactly what a tool returning binary
+ * content must not allow — a base64 payload cut at the token limit is a corrupt
+ * file reported as a success.
+ *
+ * The two steps that are not about reshaping still apply, and are why this
+ * exists rather than registering the handler directly:
+ *
+ * - `wrapWithOrganizationContext`, without which a dynamic tool ignores
+ *   `organization` and always talks to the default space;
+ * - `wrapWithErrorHandling`, without which a thrown Backlog error escapes as a
+ *   protocol error rather than an `isError` result, and never reaches the
+ *   handler that reacts to Backlog rejecting a credential.
+ *
+ * As in `composeToolHandler`, the returned schema is a fresh object: the tool
+ * definition is never mutated, because one toolset group is shared across
+ * per-request servers.
+ */
+export function composeDynamicToolHandler(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+tool, { errorHandler, useOrganization = false } = {}) {
+    // `extend` even with nothing to add, so the returned schema is always a copy.
+    // Handing back `tool.schema` itself would make the invariant above hold only
+    // when `useOrganization` is set.
+    const schema = tool.schema.extend(useOrganization
+        ? {
+            organization: z
+                .string()
+                .optional()
+                .describe('Optional organization name. Use list_organizations to inspect available organizations.'),
+        }
+        : {});
+    const handler = wrapWithErrorHandling(wrapWithOrganizationContext(tool.handler), errorHandler);
+    return {
+        schema,
+        handler: async (input) => {
+            const result = await handler(input);
+            return isErrorLike(result)
+                ? {
+                    isError: true,
+                    content: [{ type: 'text', text: result.message }],
+                }
+                : result.data;
+        },
+    };
+}

package/build/httpMcpServer.js

@@ -16,6 +16,14 @@ export const runHttpMcpServer = async (options) => {
     const app = new Hono();
     const isLocalhostBind = LOCALHOST_BINDS.includes(host);
     const oauthEnabled = !!(oauthConfig && tokenStore);
+    // Registered before the Host and Origin guards so that it stays reachable
+    // under an allow list. A load balancer health check addresses the target
+    // directly and puts its address in `Host` — AWS ALB gives no way to override
+    // it — so a guarded `/health` can only ever answer 403, leaving an operator
+    // to choose between dropping the allow list and treating 403 as healthy.
+    // Exempting it costs nothing: the response is constant and reaches no state,
+    // so there is nothing here for a rebinding page to reach either.
+    app.get('/health', (c) => c.json({ status: 'healthy', timestamp: new Date().toISOString(), version }));
     // DNS rebinding protection. `Host` is the actual defense: a rebinding page
     // reaches us carrying its own hostname, which the allow list rejects.
     if (allowedHosts?.length) {
@@ -36,7 +44,6 @@ export const runHttpMcpServer = async (options) => {
     else if (isLocalhostBind && !allowedHosts?.length) {
         app.use('*', localhostOriginValidation());
     }
-    app.get('/health', (c) => c.json({ status: 'healthy', timestamp: new Date().toISOString(), version }));
     if (oauthEnabled) {
         const { createOAuthRoutes } = await import('./auth/oauthRoutes.js');
         const { createBearerAuthMiddleware } = await import('./auth/bearerAuthMiddleware.js');

package/build/lib.d.ts

@@ -14,11 +14,13 @@
  */
 export { allTools } from './tools/tools.js';
 export { composeToolHandler } from './handlers/builders/composeToolHandler.js';
+export { composeDynamicToolHandler } from './handlers/builders/composeDynamicToolHandler.js';
 export { createDescriptionHelper } from './createDescriptionHelper.js';
 export { backlogErrorHandler } from './backlog/backlogErrorHandler.js';
 export { buildToolSchema } from './types/tool.js';
 export { isErrorLike } from './types/result.js';
 export type { ComposeOptions } from './handlers/builders/composeToolHandler.js';
+export type { ComposeDynamicOptions } from './handlers/builders/composeDynamicToolHandler.js';
 export type { DescriptionHelper } from './createDescriptionHelper.js';
 export type { ToolDefinition, DynamicToolDefinition } from './types/tool.js';
 export type { Toolset, ToolsetGroup, DynamicToolset, DynamicToolsetGroup, } from './types/toolsets.js';

package/build/lib.js

@@ -14,6 +14,7 @@
  */
 export { allTools } from './tools/tools.js';
 export { composeToolHandler } from './handlers/builders/composeToolHandler.js';
+export { composeDynamicToolHandler } from './handlers/builders/composeDynamicToolHandler.js';
 export { createDescriptionHelper } from './createDescriptionHelper.js';
 export { backlogErrorHandler } from './backlog/backlogErrorHandler.js';
 export { buildToolSchema } from './types/tool.js';

package/build/loadDescriptionOverrides.js

@@ -69,8 +69,8 @@ export function loadDescriptionOverrides(options) {
             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.
+            // LOG_LEVEL or 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 {};
         }

package/build/registerTools.js

@@ -1,4 +1,5 @@
 import { backlogErrorHandler } from './backlog/backlogErrorHandler.js';
+import { composeDynamicToolHandler } from './handlers/builders/composeDynamicToolHandler.js';
 import { composeToolHandler } from './handlers/builders/composeToolHandler.js';
 export function registerTools(server, toolsetGroup, options) {
     const { useFields, maxTokens, prefix, useOrganization } = options;
@@ -15,6 +16,23 @@ export function registerTools(server, toolsetGroup, options) {
             useOrganization,
         }),
     });
+    // Tools that build their own result, registered from the same toolsets so
+    // that `--enable-toolsets` and the prefix cover them too.
+    registerToolsets({
+        server,
+        toolsetGroup: {
+            toolsets: toolsetGroup.toolsets.map((toolset) => ({
+                name: toolset.name,
+                description: toolset.description,
+                enabled: toolset.enabled,
+                tools: toolset.dynamicTools ?? [],
+            })),
+        },
+        prefix,
+        prepareTool: (tool) => composeDynamicToolHandler(
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        tool, { errorHandler: backlogErrorHandler, useOrganization }),
+    });
 }
 export function registerDynamicTools(server, dynamicToolsetGroup, prefix) {
     registerToolsets({

package/build/tools/addDocument.d.ts

@@ -3,7 +3,7 @@ import { Backlog } from 'backlog-js';
 import { z } from 'zod';
 import { DescriptionHelper } from '../createDescriptionHelper.js';
 import { ToolDefinition } from '../types/tool.js';
-declare const addDocumentSchema: (t: DescriptionHelper["t"]) => {
+declare const addDocumentSchema: (t: DescriptionHelper['t']) => {
     projectId: z.ZodNumber;
     title: z.ZodOptional<z.ZodString>;
     content: z.ZodOptional<z.ZodString>;

package/build/tools/addDocument.js

@@ -28,7 +28,7 @@ const addDocumentSchema = buildToolSchema((t) => ({
 }));
 export const addDocumentTool = (backlog, { t }) => {
     return {
-        name: 'addDocument',
+        name: 'add_document',
         description: t('TOOL_ADD_DOCUMENT_DESCRIPTION', 'Adds a new document to the specified project.'),
         schema: z.object(addDocumentSchema(t)),
         returnsList: false,
@@ -46,6 +46,7 @@ export const addDocumentTool = (backlog, { t }) => {
             'created',
             'updatedUser',
             'updated',
+            'childDocumentIds',
         ]),
         importantFields: ['id', 'projectId', 'title', 'plain', 'createdUser'],
         handler: async (params) => {

package/build/tools/addIssue.d.ts

@@ -3,7 +3,7 @@ import { Backlog } from 'backlog-js';
 import { z } from 'zod';
 import { DescriptionHelper } from '../createDescriptionHelper.js';
 import { ToolDefinition } from '../types/tool.js';
-declare const addIssueSchema: (t: DescriptionHelper["t"]) => {
+declare const addIssueSchema: (t: DescriptionHelper['t']) => {
     projectId: z.ZodNumber;
     summary: z.ZodString;
     issueTypeId: z.ZodNumber;

package/build/tools/addIssueComment.d.ts

@@ -3,7 +3,7 @@ import type { Entity } from 'backlog-js';
 import { Backlog } from 'backlog-js';
 import { ToolDefinition } from '../types/tool.js';
 import { DescriptionHelper } from '../createDescriptionHelper.js';
-declare const addIssueCommentSchema: (t: DescriptionHelper["t"]) => {
+declare const addIssueCommentSchema: (t: DescriptionHelper['t']) => {
     issueId: z.ZodOptional<z.ZodNumber>;
     issueKey: z.ZodOptional<z.ZodString>;
     content: z.ZodString;

package/build/tools/addProject.d.ts

@@ -3,7 +3,7 @@ import type { Entity } from 'backlog-js';
 import { Backlog } from 'backlog-js';
 import { ToolDefinition } from '../types/tool.js';
 import { DescriptionHelper } from '../createDescriptionHelper.js';
-declare const addProjectSchema: (t: DescriptionHelper["t"]) => {
+declare const addProjectSchema: (t: DescriptionHelper['t']) => {
     name: z.ZodString;
     key: z.ZodString;
     chartEnabled: z.ZodOptional<z.ZodBoolean>;

package/build/tools/addPullRequest.d.ts

@@ -3,7 +3,7 @@ import type { Entity } from 'backlog-js';
 import { Backlog } from 'backlog-js';
 import { ToolDefinition } from '../types/tool.js';
 import { DescriptionHelper } from '../createDescriptionHelper.js';
-declare const addPullRequestSchema: (t: DescriptionHelper["t"]) => {
+declare const addPullRequestSchema: (t: DescriptionHelper['t']) => {
     projectId: z.ZodOptional<z.ZodNumber>;
     projectKey: z.ZodOptional<z.ZodString>;
     repoId: z.ZodOptional<z.ZodNumber>;

package/build/tools/addPullRequestComment.d.ts

@@ -3,7 +3,7 @@ import type { Entity } from 'backlog-js';
 import { Backlog } from 'backlog-js';
 import { ToolDefinition } from '../types/tool.js';
 import { DescriptionHelper } from '../createDescriptionHelper.js';
-declare const addPullRequestCommentSchema: (t: DescriptionHelper["t"]) => {
+declare const addPullRequestCommentSchema: (t: DescriptionHelper['t']) => {
     projectId: z.ZodOptional<z.ZodNumber>;
     projectKey: z.ZodOptional<z.ZodString>;
     repoId: z.ZodOptional<z.ZodNumber>;

package/build/tools/addRelatedIssue.d.ts

@@ -3,7 +3,7 @@ import type { Entity } from 'backlog-js';
 import { Backlog } from 'backlog-js';
 import { ToolDefinition } from '../types/tool.js';
 import { DescriptionHelper } from '../createDescriptionHelper.js';
-declare const addRelatedIssueSchema: (t: DescriptionHelper["t"]) => {
+declare const addRelatedIssueSchema: (t: DescriptionHelper['t']) => {
     issueId: z.ZodOptional<z.ZodNumber>;
     issueKey: z.ZodOptional<z.ZodString>;
     targetIssueId: z.ZodNumber;

package/build/tools/addVersionMilestone.d.ts

@@ -3,7 +3,7 @@ import type { Entity } from 'backlog-js';
 import { Backlog } from 'backlog-js';
 import { ToolDefinition } from '../types/tool.js';
 import { DescriptionHelper } from '../createDescriptionHelper.js';
-declare const addVersionMilestoneSchema: (t: DescriptionHelper["t"]) => {
+declare const addVersionMilestoneSchema: (t: DescriptionHelper['t']) => {
     projectId: z.ZodOptional<z.ZodNumber>;
     projectKey: z.ZodOptional<z.ZodString>;
     name: z.ZodString;

package/build/tools/addWatching.d.ts

@@ -3,7 +3,7 @@ import type { Entity } from 'backlog-js';
 import { Backlog } from 'backlog-js';
 import { ToolDefinition } from '../types/tool.js';
 import { DescriptionHelper } from '../createDescriptionHelper.js';
-declare const addWatchingSchema: (t: DescriptionHelper["t"]) => {
+declare const addWatchingSchema: (t: DescriptionHelper['t']) => {
     issueIdOrKey: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
     note: z.ZodDefault<z.ZodOptional<z.ZodString>>;
 };

package/build/tools/addWiki.d.ts

@@ -3,7 +3,7 @@ import type { Entity } from 'backlog-js';
 import { Backlog } from 'backlog-js';
 import { ToolDefinition } from '../types/tool.js';
 import { DescriptionHelper } from '../createDescriptionHelper.js';
-declare const addWikiSchema: (t: DescriptionHelper["t"]) => {
+declare const addWikiSchema: (t: DescriptionHelper['t']) => {
     projectId: z.ZodNumber;
     name: z.ZodString;
     content: z.ZodString;

package/build/tools/countIssues.d.ts

@@ -3,7 +3,7 @@ import type { Entity } from 'backlog-js';
 import { Backlog } from 'backlog-js';
 import { ToolDefinition } from '../types/tool.js';
 import { DescriptionHelper } from '../createDescriptionHelper.js';
-declare const countIssuesSchema: (t: DescriptionHelper["t"]) => {
+declare const countIssuesSchema: (t: DescriptionHelper['t']) => {
     projectId: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
     issueTypeId: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
     categoryId: z.ZodOptional<z.ZodArray<z.ZodNumber>>;

package/build/tools/deleteIssue.d.ts

@@ -3,7 +3,7 @@ import type { Entity } from 'backlog-js';
 import { Backlog } from 'backlog-js';
 import { ToolDefinition } from '../types/tool.js';
 import { DescriptionHelper } from '../createDescriptionHelper.js';
-declare const deleteIssueSchema: (t: DescriptionHelper["t"]) => {
+declare const deleteIssueSchema: (t: DescriptionHelper['t']) => {
     issueId: z.ZodOptional<z.ZodNumber>;
     issueKey: z.ZodOptional<z.ZodString>;
 };

package/build/tools/deleteProject.d.ts

@@ -3,7 +3,7 @@ import type { Entity } from 'backlog-js';
 import { Backlog } from 'backlog-js';
 import { ToolDefinition } from '../types/tool.js';
 import { DescriptionHelper } from '../createDescriptionHelper.js';
-declare const deleteProjectSchema: (t: DescriptionHelper["t"]) => {
+declare const deleteProjectSchema: (t: DescriptionHelper['t']) => {
     projectId: z.ZodOptional<z.ZodNumber>;
     projectKey: z.ZodOptional<z.ZodString>;
 };

package/build/tools/deleteVersion.d.ts

@@ -3,7 +3,7 @@ import type { Entity } from 'backlog-js';
 import { Backlog } from 'backlog-js';
 import { ToolDefinition } from '../types/tool.js';
 import { DescriptionHelper } from '../createDescriptionHelper.js';
-declare const deleteVersionSchema: (t: DescriptionHelper["t"]) => {
+declare const deleteVersionSchema: (t: DescriptionHelper['t']) => {
     projectId: z.ZodOptional<z.ZodNumber>;
     projectKey: z.ZodOptional<z.ZodString>;
     id: z.ZodNumber;

package/build/tools/deleteWatching.d.ts

@@ -3,7 +3,7 @@ import type { Entity } from 'backlog-js';
 import { Backlog } from 'backlog-js';
 import { ToolDefinition } from '../types/tool.js';
 import { DescriptionHelper } from '../createDescriptionHelper.js';
-declare const deleteWatchingSchema: (t: DescriptionHelper["t"]) => {
+declare const deleteWatchingSchema: (t: DescriptionHelper['t']) => {
     watchId: z.ZodNumber;
 };
 export declare const deleteWatchingTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof deleteWatchingSchema>, Entity.WatchingList.WatchingListItem>;

package/build/tools/getCategories.d.ts

@@ -3,7 +3,7 @@ import type { Entity } from 'backlog-js';
 import { Backlog } from 'backlog-js';
 import { ToolDefinition } from '../types/tool.js';
 import { DescriptionHelper } from '../createDescriptionHelper.js';
-declare const getCategoriesSchema: (t: DescriptionHelper["t"]) => {
+declare const getCategoriesSchema: (t: DescriptionHelper['t']) => {
     projectId: z.ZodOptional<z.ZodNumber>;
     projectKey: z.ZodOptional<z.ZodString>;
 };

package/build/tools/getCustomFields.d.ts

@@ -3,7 +3,7 @@ import { Backlog } from 'backlog-js';
 import { z } from 'zod';
 import { ToolDefinition } from '../types/tool.js';
 import { DescriptionHelper } from '../createDescriptionHelper.js';
-declare const getCustomFieldsInputSchema: (t: DescriptionHelper["t"]) => {
+declare const getCustomFieldsInputSchema: (t: DescriptionHelper['t']) => {
     projectId: z.ZodOptional<z.ZodNumber>;
     projectKey: z.ZodOptional<z.ZodString>;
 };

package/build/tools/getDocument.d.ts

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

package/build/tools/getDocument.js

@@ -26,6 +26,7 @@ export const getDocumentTool = (backlog, { t }) => {
             'created',
             'updatedUser',
             'updated',
+            'childDocumentIds',
         ]),
         importantFields: ['id', 'title', 'createdUser'],
         handler: async ({ documentId }) => {

package/build/tools/getDocumentTree.d.ts

@@ -3,7 +3,7 @@ import { Backlog } from 'backlog-js';
 import { z } from 'zod';
 import { DescriptionHelper } from '../createDescriptionHelper.js';
 import { ToolDefinition } from '../types/tool.js';
-declare const getDocumentTreeSchema: (t: DescriptionHelper["t"]) => {
+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>, Entity.Document.DocumentTree>;

package/build/tools/getDocuments.d.ts

@@ -3,7 +3,7 @@ import { Backlog } from 'backlog-js';
 import { z } from 'zod';
 import { DescriptionHelper } from '../createDescriptionHelper.js';
 import { ToolDefinition } from '../types/tool.js';
-declare const getDocumentsSchema: (t: DescriptionHelper["t"]) => {
+declare const getDocumentsSchema: (t: DescriptionHelper['t']) => {
     projectIds: z.ZodArray<z.ZodNumber>;
     offset: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
 };

package/build/tools/getDocuments.js

@@ -31,6 +31,7 @@ export const getDocumentsTool = (backlog, { t }) => {
             'created',
             'updatedUser',
             'updated',
+            'childDocumentIds',
         ]),
         importantFields: ['id', 'projectId', 'title', 'plain'],
         handler: async ({ projectIds, offset }) => {