backlog-mcp-server 0.15.0 → 0.15.1

package/README.ja.md

@@ -596,7 +596,9 @@ BACKLOG_API_KEY=your-api-key
 
 ### ツールの使い方
 
-通常のツールはすべて、任意の`organization`入力フィールドを受け付けます。指定した場合、そのBacklog組織に対してツールが実行されます。
+マルチ組織用の環境変数が設定されている場合、通常のツールはすべて任意の`organization`入力フィールドを受け付けます。指定した場合、そのBacklog組織に対してツールが実行されます。
+
+単一組織モードでは、ルーティング先が1つしかないためこのフィールドは公開されません。これにより`tools/list`のレスポンスから約8KBのスキーマが削減されます。
 
 例：
 
@@ -614,7 +616,7 @@ BACKLOG_API_KEY=your-api-key
 
 ### 組織一覧の確認
 
-サーバーは `list_organizations` ツールを提供しており、設定済みの組織名、ドメイン、デフォルト組織かどうかを返します。
+マルチ組織モードでは、サーバーは `list_organizations` ツールを提供しており、設定済みの組織名、ドメイン、デフォルト組織かどうかを返します。単一組織モードでは登録されません。
 
 レスポンス例：
 

package/README.md

@@ -715,7 +715,9 @@ BACKLOG_API_KEY=your-api-key
 
 ### Tool Usage
 
-All normal tools accept an optional `organization` input field. When provided, the tool call is routed to that Backlog organization.
+When multi-organization env vars are configured, all normal tools accept an optional `organization` input field. When provided, the tool call is routed to that Backlog organization.
+
+In single-organization mode the field is not published, since there would be only one organization to route to. Omitting it keeps roughly 8 KB of tool schema out of every `tools/list` response.
 
 Examples:
 
@@ -733,7 +735,7 @@ If `organization` is omitted:
 
 ### Organization Discovery
 
-The server provides a `list_organizations` tool that returns the configured organization names, their domains, and which one is the default.
+In multi-organization mode the server provides a `list_organizations` tool that returns the configured organization names, their domains, and which one is the default. It is not registered in single-organization mode.
 
 Example response:
 

package/build/auth/backlogAuthContext.d.ts

@@ -0,0 +1,2 @@
+export declare function runWithAccessToken<T>(token: string | undefined, fn: () => Promise<T>): Promise<T>;
+export declare function getCurrentAccessToken(): string | undefined;

package/build/auth/backlogOAuthClient.d.ts

@@ -0,0 +1,10 @@
+import type { BacklogOAuthConfig } from './backlogOAuthConfig.js';
+import type { BacklogTokenData } from './tokenStore.js';
+export declare function buildBacklogAuthorizationUrl(config: BacklogOAuthConfig, redirectUri: string, state: string): string;
+export declare function exchangeBacklogCode(config: BacklogOAuthConfig, code: string, redirectUri: string): Promise<BacklogTokenData>;
+export declare function refreshBacklogToken(config: BacklogOAuthConfig, refreshToken: string): Promise<BacklogTokenData>;
+export declare function verifyBacklogToken(domain: string, accessToken: string): Promise<{
+    id: number;
+    userId: string;
+    name: string;
+}>;

package/build/auth/backlogOAuthConfig.d.ts

@@ -0,0 +1,9 @@
+export type BacklogOAuthConfig = {
+    clientId: string;
+    clientSecret: string;
+    backlogDomain: string;
+    serverBaseUrl: string;
+};
+type Environment = Record<string, string | undefined>;
+export declare function getBacklogOAuthConfig(env?: Environment): BacklogOAuthConfig | undefined;
+export {};

package/build/auth/bearerAuthMiddleware.d.ts

@@ -0,0 +1,4 @@
+import type { MiddlewareHandler } from 'hono';
+import type { BacklogOAuthConfig } from './backlogOAuthConfig.js';
+import type { TokenStore } from './tokenStore.js';
+export declare function createBearerAuthMiddleware(store: TokenStore, config: BacklogOAuthConfig, mcpPath: string): MiddlewareHandler;

package/build/auth/oauthRoutes.d.ts

@@ -0,0 +1,4 @@
+import { Hono } from 'hono';
+import type { BacklogOAuthConfig } from './backlogOAuthConfig.js';
+import type { TokenStore } from './tokenStore.js';
+export declare function createOAuthRoutes(config: BacklogOAuthConfig, store: TokenStore, mcpPath: string): Hono;

package/build/auth/tokenStore.d.ts

@@ -0,0 +1,62 @@
+import type { AuthInfo } from '@modelcontextprotocol/server';
+export type BacklogTokenData = {
+    access_token: string;
+    token_type: string;
+    expires_in: number;
+    refresh_token: string;
+};
+export type OAuthClientInfo = {
+    client_id: string;
+    client_secret?: string;
+    client_id_issued_at: number;
+    client_secret_expires_at: number;
+    redirect_uris: string[];
+    client_name?: string;
+    token_endpoint_auth_method?: string;
+    grant_types?: string[];
+    response_types?: string[];
+};
+type PendingAuthorization = {
+    mcpClientId: string;
+    codeChallenge: string;
+    redirectUri: string;
+    resource?: string;
+    scopes: string[];
+    state?: string;
+    createdAt: number;
+};
+type AuthCodeEntry = {
+    mcpClientId: string;
+    backlogTokens: BacklogTokenData;
+    codeChallenge: string;
+    redirectUri: string;
+    resource?: string;
+    expiresAt: number;
+};
+export type McpTokenEntry = {
+    backlogAccessToken: string;
+    clientId: string;
+    expiresAt: number;
+};
+type McpRefreshEntry = {
+    backlogRefreshToken: string;
+    clientId: string;
+    expiresAt: number;
+};
+export type TokenStore = ReturnType<typeof createTokenStore>;
+export declare function createTokenStore(): {
+    storePendingAuth(backlogState: string, pending: PendingAuthorization): void;
+    consumePendingAuth(backlogState: string): PendingAuthorization | undefined;
+    storeAuthCode(code: string, entry: AuthCodeEntry): void;
+    consumeAuthCode(code: string): AuthCodeEntry | undefined;
+    getClient(clientId: string): OAuthClientInfo | undefined;
+    registerClient(client: OAuthClientInfo): boolean;
+    getCachedVerification(token: string): AuthInfo | undefined;
+    cacheVerification(token: string, authInfo: AuthInfo, ttlMs: number): void;
+    storeMcpToken(mcpToken: string, entry: McpTokenEntry): void;
+    getMcpToken(mcpToken: string): McpTokenEntry | undefined;
+    storeMcpRefreshToken(mcpRefreshToken: string, entry: McpRefreshEntry): void;
+    consumeMcpRefreshToken(mcpRefreshToken: string): McpRefreshEntry | undefined;
+    cleanup(): void;
+};
+export {};

package/build/backlog/backlogErrorHandler.d.ts

@@ -0,0 +1,2 @@
+import { ErrorLike } from '../types/result.js';
+export declare const backlogErrorHandler: (err: unknown) => ErrorLike;

package/build/backlog/customFields.d.ts

@@ -0,0 +1,29 @@
+export type CustomFieldInput = {
+    id: number;
+    value?: string | number | string[] | number[];
+    otherValue?: string;
+};
+export type CustomFieldFilterInput = {
+    id: number;
+    type: 'text';
+    value: string;
+} | {
+    id: number;
+    type: 'numeric';
+    min?: number;
+    max?: number;
+} | {
+    id: number;
+    type: 'date';
+    min?: string;
+    max?: string;
+} | {
+    id: number;
+    type: 'list';
+    value: number | number[];
+};
+/**
+ * Converts Backlog-style customFields array into proper payload format
+ */
+export declare function customFieldsToPayload(customFields: CustomFieldInput[] | undefined): Record<string, string | number | string[] | number[] | undefined>;
+export declare function customFieldFiltersToPayload(customFields: CustomFieldFilterInput[] | undefined): Record<string, string | number | number[] | undefined>;

package/build/backlog/parseBacklogAPIError.d.ts

@@ -0,0 +1,8 @@
+export type ParsedBacklogAPIError = {
+    type: 'BacklogAuthError' | 'BacklogApiError' | 'UnexpectedError' | 'UnknownError';
+    message: string;
+    status?: number;
+    code?: number;
+    url?: string;
+};
+export declare function parseBacklogAPIError(err: unknown): ParsedBacklogAPIError;

package/build/createBacklogMcpServer.d.ts

@@ -0,0 +1,29 @@
+import type { Backlog } from 'backlog-js';
+import type { TranslationHelper } from './createTranslationHelper.js';
+import type { MCPOptions } from './types/mcp.js';
+import type { ToolsetGroup } from './types/toolsets.js';
+import type { BacklogClientRegistry } from './utils/backlogClientRegistry.js';
+import { type BacklogMCPServer } from './utils/wrapServerWithToolRegistry.js';
+export type CreateBacklogMcpServerConfig = {
+    version: string;
+    useFields: boolean;
+    backlog: Backlog;
+    clientRegistry: BacklogClientRegistry;
+    transHelper: TranslationHelper;
+    enabledToolsets: string[];
+    mcpOption: MCPOptions;
+    dynamicToolsets: boolean;
+    /**
+     * A toolset group to register from, instead of building one from
+     * `enabledToolsets`. Callers that produce many servers from one factory pass
+     * a single shared group: `enable_toolset` mutates it, and under the stateless
+     * HTTP model — one server per request — a group built per server would throw
+     * that mutation away the moment the request ends.
+     */
+    toolsetGroup?: ToolsetGroup;
+};
+/**
+ * Builds a fresh MCP server instance with all Backlog tools registered.
+ * Used once per stdio connection; one instance per HTTP request for Streamable HTTP.
+ */
+export declare function createBacklogMcpServer({ version, useFields, backlog, clientRegistry, transHelper, enabledToolsets, mcpOption, dynamicToolsets, toolsetGroup: sharedToolsetGroup, }: CreateBacklogMcpServerConfig): BacklogMCPServer;

package/build/createBacklogMcpServer.js

@@ -26,7 +26,12 @@ export function createBacklogMcpServer({ version, useFields, backlog, clientRegi
     const toolsetGroup = sharedToolsetGroup ??
         buildToolsetGroup(backlog, transHelper, enabledToolsets);
     registerTools(server, toolsetGroup, mcpOption);
-    registerDynamicTools(server, organizationTools(clientRegistry, transHelper), mcpOption.prefix);
+    // `list_organizations` only has something to report when more than one space
+    // is configured; the `organization` parameter its description points at is
+    // published under the same condition.
+    if (mcpOption.useOrganization) {
+        registerDynamicTools(server, organizationTools(clientRegistry, transHelper), mcpOption.prefix);
+    }
     if (dynamicToolsets) {
         const registrar = createToolRegistrar(server, toolsetGroup, mcpOption);
         const dynamicToolsetGroup = dynamicTools(registrar, transHelper, toolsetGroup);

package/build/createTranslationHelper.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Resolves the schema strings every tool definition passes through `t()`: tool
+ * descriptions and parameter descriptions. These are read by the model when it
+ * picks a tool and fills in arguments; they never reach the end user.
+ *
+ * This module intentionally imports nothing. Every tool in `src/tools/` depends on
+ * it, so anything imported here is reachable from the tool layer — and the tool
+ * layer is meant to run on non-Node runtimes too. Discovering and reading the
+ * override file needs a filesystem and a home directory, so that part lives in
+ * `loadTranslationOverrides` and the CLI passes the result in.
+ */
+export interface TranslationHelper {
+    t: (key: string, fallback: string) => string;
+    dump: () => Record<string, string>;
+}
+export declare function createTranslationHelper(overrides?: Record<string, string>): TranslationHelper;

package/build/createTranslationHelper.js

@@ -1,13 +1,5 @@
-import { cosmiconfigSync } from 'cosmiconfig';
-import os from 'os';
-export function createTranslationHelper(options) {
+export function createTranslationHelper(overrides = {}) {
     const usedKeys = {};
-    const configName = options?.configName ?? 'backlog-mcp-server';
-    // Load config file
-    const explorer = cosmiconfigSync(configName);
-    const searchPath = options?.searchDir ?? os.homedir();
-    const configResult = explorer.search(searchPath);
-    const config = configResult?.config || {};
     function toEnvKey(key) {
         return `BACKLOG_MCP_${key}`;
     }
@@ -16,8 +8,12 @@ export function createTranslationHelper(options) {
         if (usedKeys[upperKey]) {
             return usedKeys[upperKey];
         }
-        // Priority：ENV → config → fallback
-        const value = process.env[toEnvKey(upperKey)] || config[upperKey] || fallback;
+        // Runtimes without a Node compatibility layer have no `process`, and a
+        // partial shim can have `process` without `env`.
+        const env = typeof process === 'undefined' ? undefined : process.env;
+        const fromEnv = env?.[toEnvKey(upperKey)];
+        // Priority：ENV → overrides → fallback
+        const value = fromEnv || overrides[upperKey] || fallback;
         usedKeys[upperKey] = value;
         return value;
     }

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

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+import { ErrorLike } from '../../types/result.js';
+import { ToolDefinition } from '../../types/tool.js';
+export interface ComposeOptions {
+    useFields: boolean;
+    errorHandler?: (err: unknown) => ErrorLike;
+    maxTokens: number;
+    /**
+     * Whether to advertise `organization`. Defaults to false: with a single
+     * Backlog space the parameter has exactly one legal value, and repeating it
+     * across every tool costs the client ~8 KB of schema for nothing.
+     */
+    useOrganization?: boolean;
+}
+type ComposedInput = {
+    fields?: string;
+    organization?: string;
+} & Record<string, unknown>;
+/**
+ * Builds the schema and handler a tool is registered with.
+ *
+ * The returned schema is a fresh object: the tool definition is never mutated.
+ * That matters under the stateless HTTP model, where one toolset group is shared
+ * by every per-request server — an in-place extension would be re-applied on
+ * every request, against a definition other requests are reading concurrently.
+ */
+export declare function composeToolHandler(tool: ToolDefinition<any, any>, options: ComposeOptions): {
+    schema: z.ZodObject<any, z.core.$strip>;
+    handler: (input: ComposedInput, extra: import("@modelcontextprotocol/server").ServerContext) => Promise<import("@modelcontextprotocol/server").CallToolResult>;
+};
+export {};

package/build/handlers/builders/composeToolHandler.js

@@ -6,25 +6,37 @@ import { wrapWithTokenLimit } from '../transformers/wrapWithTokenLimit.js';
 import { wrapWithToolResult } from '../transformers/wrapWithToolResult.js';
 import { z } from 'zod';
 import { generateFieldsDescription } from '../../utils/generateFieldsDescription.js';
+/**
+ * Builds the schema and handler a tool is registered with.
+ *
+ * The returned schema is a fresh object: the tool definition is never mutated.
+ * That matters under the stateless HTTP model, where one toolset group is shared
+ * by every per-request server — an in-place extension would be re-applied on
+ * every request, against a definition other requests are reading concurrently.
+ */
 export function composeToolHandler(tool, options) {
-    const { useFields, errorHandler, maxTokens } = options;
+    const { useFields, errorHandler, maxTokens, useOrganization = false, } = options;
     // Step 1: Add `fields` to schema if needed
     const fieldDesc = useFields
         ? generateFieldsDescription(tool.outputSchema, tool.importantFields ?? [], tool.name)
         : undefined;
-    tool.schema = extendSchema(tool.schema, fieldDesc);
+    const schema = extendSchema(tool.schema, fieldDesc, useOrganization);
     // Step 2: Compose
     const baseHandler = wrapWithErrorHandling(wrapWithOrganizationContext(tool.handler), errorHandler);
-    const handler = useFields ? wrapWithFieldPicking(baseHandler) : baseHandler;
-    return wrapWithToolResult(wrapWithTokenLimit(handler, maxTokens));
+    const composed = useFields ? wrapWithFieldPicking(baseHandler) : baseHandler;
+    return {
+        schema,
+        handler: wrapWithToolResult(wrapWithTokenLimit(composed, maxTokens)),
+    };
 }
-function extendSchema(schema, desc) {
-    const extension = {
-        organization: z
+function extendSchema(schema, desc, withOrganization = false) {
+    const extension = {};
+    if (withOrganization) {
+        extension.organization = z
             .string()
             .optional()
-            .describe('Optional organization name. Use list_organizations to inspect available organizations.'),
-    };
+            .describe('Optional organization name. Use list_organizations to inspect available organizations.');
+    }
     if (desc) {
         extension.fields = z.string().describe(desc);
     }

package/build/handlers/transformers/wrapWithErrorHandling.d.ts

@@ -0,0 +1,2 @@
+import { ErrorLike, SafeResult } from '../../types/result.js';
+export declare function wrapWithErrorHandling<I, O>(fn: (input: I) => Promise<O>, onError?: (err: unknown) => ErrorLike): (input: I) => Promise<SafeResult<O>>;

package/build/handlers/transformers/wrapWithFieldPicking.d.ts

@@ -0,0 +1,4 @@
+import { SafeResult } from '../../types/result.js';
+export declare function wrapWithFieldPicking<I extends {
+    fields?: string;
+}, O>(fn: (input: I) => Promise<SafeResult<O>>): (input: I) => Promise<SafeResult<O>>;

package/build/handlers/transformers/wrapWithOrganizationContext.d.ts

@@ -0,0 +1,3 @@
+export declare function wrapWithOrganizationContext<I extends {
+    organization?: string;
+}, O>(fn: (input: Omit<I, 'organization'>) => Promise<O>): (input: I) => Promise<O>;

package/build/handlers/transformers/wrapWithTokenLimit.d.ts

@@ -0,0 +1,2 @@
+import { SafeResult } from '../../types/result.js';
+export declare function wrapWithTokenLimit<I, O>(fn: (input: I) => Promise<SafeResult<O>>, maxTokens: number): (input: I) => Promise<SafeResult<string>>;

package/build/handlers/transformers/wrapWithToolResult.d.ts

@@ -0,0 +1,6 @@
+import { CallToolResult, ServerContext } from '@modelcontextprotocol/server';
+import { SafeResult } from '../../types/result.js';
+/**
+ * Convert SafeResult<T> to CallToolResult
+ */
+export declare function wrapWithToolResult<I, T>(fn: (input: I) => Promise<SafeResult<string | T>>): (input: I, extra: ServerContext) => Promise<CallToolResult>;

package/build/httpMcpServer.d.ts

@@ -0,0 +1,22 @@
+import type { Server } from 'node:http';
+import type { BacklogOAuthConfig } from './auth/backlogOAuthConfig.js';
+import type { TokenStore } from './auth/tokenStore.js';
+import type { BacklogMCPServer } from './utils/wrapServerWithToolRegistry.js';
+type RunHttpMcpServerOptions = {
+    host: string;
+    port: number;
+    path: string;
+    version: string;
+    enableJsonResponse: boolean;
+    allowedHosts?: string[];
+    allowedOrigins?: string[];
+    createServer: () => BacklogMCPServer;
+    oauthConfig?: BacklogOAuthConfig;
+    tokenStore?: TokenStore;
+};
+type HttpMcpServerHandle = {
+    httpServer: Server;
+    shutdown: () => Promise<void>;
+};
+export declare const runHttpMcpServer: (options: RunHttpMcpServerOptions) => Promise<HttpMcpServerHandle>;
+export {};

package/build/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/build/index.js

@@ -8,6 +8,7 @@ import { hideBin } from 'yargs/helpers';
 import { getBacklogOAuthConfig } from './auth/backlogOAuthConfig.js';
 import { createTokenStore } from './auth/tokenStore.js';
 import { createTranslationHelper } from './createTranslationHelper.js';
+import { loadTranslationOverrides } from './loadTranslationOverrides.js';
 import { createBacklogMcpServer } from './createBacklogMcpServer.js';
 import { runHttpMcpServer } from './httpMcpServer.js';
 import { createBacklogClientRegistry, createOAuthBacklogClientRegistry, } from './utils/backlogClientRegistry.js';
@@ -131,13 +132,18 @@ if (tokenStore) {
     cleanupTimer.unref();
 }
 const useFields = argv.optimizeResponse;
-const transHelper = createTranslationHelper();
+const transHelper = createTranslationHelper(loadTranslationOverrides());
 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.

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. `loadTranslationOverrides`
+ * 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 `createTranslationHelper`.
+ */
+export { allTools } from './tools/tools.js';
+export { composeToolHandler } from './handlers/builders/composeToolHandler.js';
+export { createTranslationHelper } from './createTranslationHelper.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 { TranslationHelper } from './createTranslationHelper.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. `loadTranslationOverrides`
+ * 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 `createTranslationHelper`.
+ */
+export { allTools } from './tools/tools.js';
+export { composeToolHandler } from './handlers/builders/composeToolHandler.js';
+export { createTranslationHelper } from './createTranslationHelper.js';
+export { backlogErrorHandler } from './backlog/backlogErrorHandler.js';
+export { buildToolSchema } from './types/tool.js';
+export { isErrorLike } from './types/result.js';

package/build/loadTranslationOverrides.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 `createTranslationHelper` 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. Every override ends up in a tool
+ * description, and a number or an array there would produce an invalid
+ * `tools/list` payload.
+ */
+export declare function loadTranslationOverrides(options?: {
+    configName?: string;
+    searchDir?: string;
+}): Record<string, string>;

package/build/loadTranslationOverrides.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 `createTranslationHelper` 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. Every override ends up in a tool
+ * description, and a number or an array there would produce an invalid
+ * `tools/list` payload.
+ */
+export function loadTranslationOverrides(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 { TranslationHelper } from '../createTranslationHelper.js';
+import { DocumentItemSchema } from '../types/zod/backlogOutputDefinition.js';
+import { ToolDefinition } from '../types/tool.js';
+declare const addDocumentSchema: (t: TranslationHelper["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 }: TranslationHelper) => 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 { TranslationHelper } from '../createTranslationHelper.js';
+import { IssueSchema } from '../types/zod/backlogOutputDefinition.js';
+import { ToolDefinition } from '../types/tool.js';
+declare const addIssueSchema: (t: TranslationHelper["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 }: TranslationHelper) => ToolDefinition<ReturnType<typeof addIssueSchema>, (typeof IssueSchema)["shape"]>;
+export {};