backlog-mcp-server 0.15.0 → 0.16.0

package/build/index.js

@@ -7,7 +7,8 @@ import yargs from 'yargs';
 import { hideBin } from 'yargs/helpers';
 import { getBacklogOAuthConfig } from './auth/backlogOAuthConfig.js';
 import { createTokenStore } from './auth/tokenStore.js';
-import { createTranslationHelper } from './createTranslationHelper.js';
+import { createDescriptionHelper } from './createDescriptionHelper.js';
+import { loadDescriptionOverrides } from './loadDescriptionOverrides.js';
 import { createBacklogMcpServer } from './createBacklogMcpServer.js';
 import { runHttpMcpServer } from './httpMcpServer.js';
 import { createBacklogClientRegistry, createOAuthBacklogClientRegistry, } from './utils/backlogClientRegistry.js';
@@ -97,9 +98,14 @@ const argv = yargs(hideBin(process.argv))
     describe: 'Optional string prefix to prepend to all generated outputs',
     default: env.get('PREFIX').default('').asString(),
 })
-    .option('export-translations', {
+    .option('export-descriptions', {
     type: 'boolean',
-    describe: 'Export translations and exit',
+    // Deprecated alias, to be removed in a future release. Kept because the old name is
+    // documented with docker and npx examples, and dropping it outright would
+    // not fail loudly: yargs ignores unknown flags, so the process would fall
+    // through to starting a server and the caller would see a hang.
+    alias: 'export-translations',
+    describe: 'Export tool and parameter descriptions and exit',
     default: false,
 })
     .option('enable-toolsets', {
@@ -120,6 +126,13 @@ Available toolsets:
     default: env.get('ENABLE_DYNAMIC_TOOLSETS').default('false').asBool(),
 })
     .parseSync();
+// The alias resolves both spellings to the same argv key, so which one was typed
+// is only visible in the raw arguments. Written straight to stderr rather than
+// through `logger`, which drops anything below `error` in production — and stdout
+// carries the JSON-RPC stream, so a notice there would corrupt the protocol.
+if (hideBin(process.argv).some((arg) => arg.split('=')[0] === '--export-translations')) {
+    process.stderr.write('--export-translations is deprecated and will be removed in a future release. Use --export-descriptions.\n');
+}
 const clientRegistry = oauthConfig
     ? createOAuthBacklogClientRegistry(oauthConfig.backlogDomain)
     : createBacklogClientRegistry();
@@ -131,19 +144,24 @@ if (tokenStore) {
     cleanupTimer.unref();
 }
 const useFields = argv.optimizeResponse;
-const transHelper = createTranslationHelper();
+const descriptionHelper = createDescriptionHelper(loadDescriptionOverrides());
 const maxTokens = argv.maxTokens;
 const prefix = argv.prefix;
 const enabledToolsets = argv.dynamicToolsets
     ? argv.enableToolsets.filter((a) => a !== 'all')
     : argv.enableToolsets;
-const mcpOption = { useFields: useFields, maxTokens, prefix };
+const mcpOption = {
+    useFields: useFields,
+    maxTokens,
+    prefix,
+    useOrganization: clientRegistry.isMultiOrganization,
+};
 // Built once and shared by every server the factory produces. `enable_toolset`
 // mutates this group, and the stateless HTTP model discards its server after
 // each request — so a per-server group would lose the enablement immediately.
 // Sharing it makes toolset state process-wide, which is the only scope left now
 // that the protocol has no sessions.
-const sharedToolsetGroup = buildToolsetGroup(backlog, transHelper, enabledToolsets);
+const sharedToolsetGroup = buildToolsetGroup(backlog, descriptionHelper, enabledToolsets);
 // Factory: creates a fresh MCP server with all tools registered.
 // Used once per stdio connection; one fresh instance per HTTP request.
 const createServer = () => createBacklogMcpServer({
@@ -151,14 +169,14 @@ const createServer = () => createBacklogMcpServer({
     useFields,
     backlog,
     clientRegistry,
-    transHelper,
+    descriptionHelper,
     enabledToolsets,
     mcpOption,
     dynamicToolsets: argv.dynamicToolsets,
     toolsetGroup: sharedToolsetGroup,
 });
-if (argv.exportTranslations) {
-    // Translation keys are only recorded once a tool asks for them, so build a
+if (argv.exportDescriptions) {
+    // Description keys are only recorded once a tool asks for them, so build a
     // server with every toolset enabled before dumping. Without this the dump is
     // empty, because no tool has been created yet at this point.
     createBacklogMcpServer({
@@ -166,12 +184,12 @@ if (argv.exportTranslations) {
         useFields,
         backlog,
         clientRegistry,
-        transHelper,
+        descriptionHelper,
         enabledToolsets: ['all'],
         mcpOption,
         dynamicToolsets: true,
     });
-    const data = transHelper.dump();
+    const data = descriptionHelper.dump();
     // eslint-disable-next-line no-console
     console.log(JSON.stringify(data, null, 2));
     process.exit(0);

package/build/lib.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Library entry point.
+ *
+ * `src/index.ts` is the CLI: it parses argv, reads config files and starts a
+ * transport. Consumers that only want the tool layer — to host the same tools on
+ * a different runtime, for example — cannot import it without running all of that.
+ * This module exposes the pieces needed to build a server, and nothing that runs
+ * on import.
+ *
+ * Nothing reachable from here may touch a Node built-in. `loadDescriptionOverrides`
+ * is the counter-example worth remembering: it reads the override file from disk,
+ * so it belongs to the CLI and is deliberately absent below. Consumers on other
+ * runtimes pass their own overrides to `createDescriptionHelper`.
+ */
+export { allTools } from './tools/tools.js';
+export { composeToolHandler } from './handlers/builders/composeToolHandler.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 { DescriptionHelper } from './createDescriptionHelper.js';
+export type { ToolDefinition, DynamicToolDefinition, ToolRegistrar, } from './types/tool.js';
+export type { Toolset, ToolsetGroup, DynamicToolset, DynamicToolsetGroup, } from './types/toolsets.js';
+export type { ErrorLike, SafeResult } from './types/result.js';

package/build/lib.js

@@ -0,0 +1,20 @@
+/**
+ * Library entry point.
+ *
+ * `src/index.ts` is the CLI: it parses argv, reads config files and starts a
+ * transport. Consumers that only want the tool layer — to host the same tools on
+ * a different runtime, for example — cannot import it without running all of that.
+ * This module exposes the pieces needed to build a server, and nothing that runs
+ * on import.
+ *
+ * Nothing reachable from here may touch a Node built-in. `loadDescriptionOverrides`
+ * is the counter-example worth remembering: it reads the override file from disk,
+ * so it belongs to the CLI and is deliberately absent below. Consumers on other
+ * runtimes pass their own overrides to `createDescriptionHelper`.
+ */
+export { allTools } from './tools/tools.js';
+export { composeToolHandler } from './handlers/builders/composeToolHandler.js';
+export { createDescriptionHelper } from './createDescriptionHelper.js';
+export { backlogErrorHandler } from './backlog/backlogErrorHandler.js';
+export { buildToolSchema } from './types/tool.js';
+export { isErrorLike } from './types/result.js';

package/build/loadDescriptionOverrides.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Reads description overrides from a `.backlog-mcp-serverrc` file (`.json`,
+ * `.yaml` or `.yml`) 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.
+ *
+ * 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.
+ */
+export declare function loadDescriptionOverrides(options?: {
+    configName?: string;
+    searchDir?: string;
+}): Record<string, string>;

package/build/loadDescriptionOverrides.js

@@ -0,0 +1,24 @@
+import { cosmiconfigSync } from 'cosmiconfig';
+import os from 'os';
+/**
+ * Reads description overrides from a `.backlog-mcp-serverrc` file (`.json`,
+ * `.yaml` or `.yml`) 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.
+ *
+ * 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.
+ */
+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 {};
+    }
+    return Object.fromEntries(Object.entries(config).filter(([, value]) => typeof value === 'string'));
+}

package/build/registerTools.d.ts

@@ -0,0 +1,5 @@
+import { MCPOptions } from './types/mcp.js';
+import { DynamicToolsetGroup, ToolsetGroup } from './types/toolsets.js';
+import { BacklogMCPServer } from './utils/wrapServerWithToolRegistry.js';
+export declare function registerTools(server: BacklogMCPServer, toolsetGroup: ToolsetGroup, options: MCPOptions): void;
+export declare function registerDynamicTools(server: BacklogMCPServer, dynamicToolsetGroup: DynamicToolsetGroup, prefix: string): void;

package/build/registerTools.js

@@ -1,17 +1,18 @@
 import { backlogErrorHandler } from './backlog/backlogErrorHandler.js';
 import { composeToolHandler } from './handlers/builders/composeToolHandler.js';
 export function registerTools(server, toolsetGroup, options) {
-    const { useFields, maxTokens, prefix } = options;
+    const { useFields, maxTokens, prefix, useOrganization } = options;
     registerToolsets({
         server,
         toolsetGroup,
         prefix,
-        handlerStrategy: (tool) => 
+        prepareTool: (tool) => 
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         composeToolHandler(tool, {
             useFields,
             errorHandler: backlogErrorHandler,
             maxTokens,
+            useOrganization,
         }),
     });
 }
@@ -20,18 +21,18 @@ export function registerDynamicTools(server, dynamicToolsetGroup, prefix) {
         server,
         toolsetGroup: dynamicToolsetGroup,
         prefix,
-        handlerStrategy: (tool) => tool.handler,
+        prepareTool: (tool) => ({ schema: tool.schema, handler: tool.handler }),
     });
 }
-function registerToolsets({ server, toolsetGroup, prefix, handlerStrategy, }) {
+function registerToolsets({ server, toolsetGroup, prefix, prepareTool, }) {
     for (const toolset of toolsetGroup.toolsets) {
         if (!toolset.enabled) {
             continue;
         }
         for (const tool of toolset.tools) {
             const toolNameWithPrefix = `${prefix}${tool.name}`;
-            const handler = handlerStrategy(tool);
-            server.registerOnce(toolNameWithPrefix, tool.description, tool.schema, handler);
+            const { schema, handler } = prepareTool(tool);
+            server.registerOnce(toolNameWithPrefix, tool.description, schema, handler);
         }
     }
 }

package/build/tools/addDocument.d.ts

@@ -0,0 +1,15 @@
+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;
+    title: z.ZodOptional<z.ZodString>;
+    content: z.ZodOptional<z.ZodString>;
+    emoji: z.ZodOptional<z.ZodString>;
+    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 {};

package/build/tools/addIssue.d.ts

@@ -0,0 +1,30 @@
+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;
+    summary: z.ZodString;
+    issueTypeId: z.ZodNumber;
+    priorityId: z.ZodNumber;
+    description: z.ZodOptional<z.ZodString>;
+    startDate: z.ZodOptional<z.ZodString>;
+    dueDate: z.ZodOptional<z.ZodString>;
+    estimatedHours: z.ZodOptional<z.ZodNumber>;
+    actualHours: z.ZodOptional<z.ZodNumber>;
+    categoryId: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    versionId: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    milestoneId: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    assigneeId: z.ZodOptional<z.ZodNumber>;
+    notifiedUserId: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    attachmentId: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    parentIssueId: z.ZodOptional<z.ZodNumber>;
+    customFields: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodArray<z.ZodString>, z.ZodArray<z.ZodNumber>]>>;
+        otherValue: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+};
+export declare const addIssueTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof addIssueSchema>, (typeof IssueSchema)["shape"]>;
+export {};

package/build/tools/addIssueComment.d.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+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>;
+    content: z.ZodString;
+    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 {};

package/build/tools/addProject.d.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+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;
+    chartEnabled: z.ZodOptional<z.ZodBoolean>;
+    subtaskingEnabled: z.ZodOptional<z.ZodBoolean>;
+    projectLeaderCanEditProjectLeader: z.ZodOptional<z.ZodBoolean>;
+    textFormattingRule: z.ZodOptional<z.ZodEnum<{
+        backlog: "backlog";
+        markdown: "markdown";
+    }>>;
+};
+export declare const addProjectTool: (backlog: Backlog, { t }: DescriptionHelper) => ToolDefinition<ReturnType<typeof addProjectSchema>, (typeof ProjectSchema)["shape"]>;
+export {};

package/build/tools/addPullRequest.d.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+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>;
+    repoId: z.ZodOptional<z.ZodNumber>;
+    repoName: z.ZodOptional<z.ZodString>;
+    summary: z.ZodString;
+    description: z.ZodString;
+    base: z.ZodString;
+    branch: z.ZodString;
+    issueId: z.ZodOptional<z.ZodNumber>;
+    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 {};

package/build/tools/addPullRequestComment.d.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+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>;
+    repoId: z.ZodOptional<z.ZodNumber>;
+    repoName: z.ZodOptional<z.ZodString>;
+    number: z.ZodNumber;
+    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 {};

package/build/tools/addRelatedIssue.d.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+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 {};

package/build/tools/addVersionMilestone.d.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+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>;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    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 {};

package/build/tools/addWatching.d.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+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 {};

package/build/tools/addWiki.d.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+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 {};

package/build/tools/countIssues.d.ts

@@ -0,0 +1,48 @@
+import { z } from 'zod';
+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>>;
+    categoryId: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    versionId: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    milestoneId: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    statusId: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    priorityId: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    assigneeId: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    createdUserId: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    resolutionId: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    parentIssueId: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    keyword: z.ZodOptional<z.ZodString>;
+    startDateSince: z.ZodOptional<z.ZodString>;
+    startDateUntil: z.ZodOptional<z.ZodString>;
+    dueDateSince: z.ZodOptional<z.ZodString>;
+    dueDateUntil: z.ZodOptional<z.ZodString>;
+    createdSince: z.ZodOptional<z.ZodString>;
+    createdUntil: z.ZodOptional<z.ZodString>;
+    updatedSince: z.ZodOptional<z.ZodString>;
+    updatedUntil: z.ZodOptional<z.ZodString>;
+    customFields: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        id: z.ZodNumber;
+        value: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"numeric">;
+        id: z.ZodNumber;
+        min: z.ZodOptional<z.ZodNumber>;
+        max: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"date">;
+        id: z.ZodNumber;
+        min: z.ZodOptional<z.ZodString>;
+        max: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"list">;
+        id: z.ZodNumber;
+        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 {};

package/build/tools/deleteIssue.d.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+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 {};

package/build/tools/deleteProject.d.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+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 {};

package/build/tools/deleteVersion.d.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+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 {};

package/build/tools/deleteWatching.d.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+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 {};

package/build/tools/dynamicTools/organizations.d.ts

@@ -0,0 +1,6 @@
+import { DescriptionHelper } from '../../createDescriptionHelper.js';
+import { BacklogClientRegistry } from '../../utils/backlogClientRegistry.js';
+import { DynamicToolDefinition } from '../../types/tool.js';
+import { DynamicToolsetGroup } from '../../types/toolsets.js';
+export declare function organizationTools(registry: BacklogClientRegistry, { t }: DescriptionHelper): DynamicToolsetGroup;
+export declare function listOrganizationsTool(registry: BacklogClientRegistry, t: DescriptionHelper['t']): DynamicToolDefinition<Record<string, never>>;

package/build/tools/dynamicTools/toolsets.d.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+import { DynamicToolDefinition, ToolRegistrar } from '../../types/tool.js';
+import { DynamicToolsetGroup, ToolsetGroup } from '../../types/toolsets.js';
+import { DescriptionHelper } from '../../createDescriptionHelper.js';
+export declare const dynamicTools: (toolRegistrar: ToolRegistrar, helper: DescriptionHelper, toolsetGroup: ToolsetGroup) => DynamicToolsetGroup;
+declare const enableToolsetSchema: (t: DescriptionHelper["t"]) => {
+    toolset: z.ZodString;
+};
+export declare const enableToolsetTool: (toolRegistrar: ToolRegistrar, { t }: DescriptionHelper) => DynamicToolDefinition<ReturnType<typeof enableToolsetSchema>>;
+export declare const listAvailableToolsets: ({ t }: DescriptionHelper, toolsetGroup: ToolsetGroup) => DynamicToolDefinition<Record<string, never>>;
+declare const getToolsetToolsSchema: (t: DescriptionHelper["t"]) => {
+    toolset: z.ZodString;
+};
+export declare const getToolsetTools: ({ t }: DescriptionHelper, toolsetGroup: ToolsetGroup) => DynamicToolDefinition<ReturnType<typeof getToolsetToolsSchema>>;
+export {};

package/build/tools/getCategories.d.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+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 {};

package/build/tools/getCustomFields.d.ts

@@ -0,0 +1,12 @@
+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"]>;
+export {};

package/build/tools/getDocument.d.ts

@@ -0,0 +1,10 @@
+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 {};

package/build/tools/getDocumentTree.d.ts

@@ -0,0 +1,10 @@
+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 {};

package/build/tools/getDocuments.d.ts

@@ -0,0 +1,11 @@
+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 {};

package/build/tools/getGitRepositories.d.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+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 {};