backlog-mcp-server 0.16.0 → 0.18.0

package/README.ja.md

@@ -16,7 +16,7 @@ Backlog API とやり取りするための Model Context Protocol（MCP）サー
 - Wikiページサポート
 - Gitリポジトリとプルリクエストツール
 - 通知ツール
-- 最適化されたレスポンスのためのGraphQLスタイルのフィールド選択
+- 最適化されたレスポンスのためのフィールド選択
 - 大規模なレスポンスに対するトークン制限
 
 ## 利用開始
@@ -188,6 +188,14 @@ OAuth有効時、サーバーは以下のOAuthエンドポイントを自動的
 
 MCP認可仕様に対応するMCPクライアントは、これらのエンドポイントを自動的に使用します。
 
+`POST /register` は登録できる redirect URI を制限します。ループバック URI
+（`http://localhost`、`http://127.0.0.1`、`http://[::1]`）はユーザーのマシン上で動く
+アプリが認可コードを受け取るための手段で、`"application_type": "native"` を宣言した
+クライアント、または宣言がない場合は redirect URI が**すべて**ループバックである
+クライアントから受け付けます。`"application_type": "web"` を宣言したクライアントや、
+宣言なしでリモートの `https:` URI とループバック URI を混在させた登録は
+`invalid_client_metadata` で拒否されます。
+
 > **制約事項:**
 >
 > - OAuthモードは現在、単一のBacklog組織のみをサポートしています。複数組織設定との併用はできません。
@@ -233,26 +241,6 @@ ENABLE_TOOLSETS="space,project,issue"
 
 > 🧩 ヒント: `project` ツールセットは、他の多くのツールがエントリポイントとしてプロジェクトデータに依存しているため、強く推奨されます。
 
-### 動的なツールセット検出（実験的）
-
-MCPサーバーをAIエージェントと共に使用している場合、実行時にツールセットの動的な検出を有効にすることができます：
-
-CLI経由での有効化：
-
-```
---dynamic-toolsets
-```
-
-または環境変数経由：
-
-```
--e DYNAMIC_TOOLSETS=1 \
-```
-
-動的ツールセットを有効にすると、LLMはツールインターフェースを介してオンデマンドでツールセットを一覧表示およびアクティブ化できるようになります。
-
-> **HTTPでのスコープ:** MCP `2026-07-28` にはプロトコルセッションがないため、アクティブ化したツールセットはクライアント単位ではなく**サーバープロセス単位**で保持されます。HTTPトランスポートでは接続中の全クライアントが1つのツールセット状態を共有し、プロセス再起動でリセットされます。共有されるのはツールの*可視性*のみで、認可は共有されません（各呼び出しは呼び出し元自身の認証情報で認証されます）。
-
 ## 利用可能なツール
 
 以下のような Backlog 機能に対応するツールを提供しています：
@@ -437,7 +425,7 @@ PREFIX="backlog_"
 
 ### レスポンスの最適化とトークン制限
 
-#### フィールド選択（GraphQLスタイル）
+#### フィールド選択
 
 ```
 --optimize-response
@@ -449,17 +437,13 @@ PREFIX="backlog_"
 OPTIMIZE_RESPONSE=1
 ```
 
-次に、特定のフィールドのみを要求します：
+**一覧を返すツール**に `fields` パラメータ（省略可）が追加されます。値はそのツールの結果のトップレベルのフィールド名のリストで、enum として公開されるため、そのツールに存在しない名前は無視されずに拒否されます。単体のレコードを返すツールには追加されません（パラメータは毎セッション費用がかかる一方、1 件のレコードから削れる量はごくわずかなためです）。
 
 ```
-get_project(projectIdOrKey: "PROJECT-KEY", fields: "{ name key description }")
+get_project(projectIdOrKey: "PROJECT-KEY", fields: ["name", "key", "description"])
 ```
 
-AIはフィールド選択を使用してレスポンスを最適化します：
-
-```
-get_project(projectIdOrKey: "PROJECT-KEY", fields: "{ name key description }")
-```
+`fields` を省略すると結果全体が返ります。選択は 1 階層のみで、オブジェクトや配列のフィールドを指定した場合はそのまま丸ごと返ります。
 
 利点：
 
@@ -518,8 +502,7 @@ MAX_TOKENS=10000
         "MAX_TOKENS": "10000",
         "OPTIMIZE_RESPONSE": "1",
         "PREFIX": "backlog_",
-        "ENABLE_TOOLSETS": "space,project,issue",
-        "ENABLE_DYNAMIC_TOOLSETS": "1"
+        "ENABLE_TOOLSETS": "space,project,issue"
       }
     }
   }
@@ -546,7 +529,7 @@ pnpm test
 サーバーはいくつかのコマンドラインオプションをサポートしています：
 
 - `--export-descriptions`: ツール一覧の構築時に解決される説明キーと値をエクスポート。旧名は `--export-translations` で、非推奨エイリアスとして当面動作しますが、将来のリリースで削除されます
-- `--optimize-response`: GraphQLスタイルのフィールド選択を有効にする
+- `--optimize-response`: 各ツールに、返す結果フィールドを選ぶ `fields` パラメータを追加する
 - `--max-tokens=NUMBER`: レスポンスの最大トークン制限を設定
 - `--prefix=STRING`: すべてのツール名に付加するオプションの文字列プレフィックス（デフォルト：""）
 - `--enable-toolsets <toolsets...>`: 有効にするツールセットを指定します（カンマ区切りまたは複数の引数）。デフォルトは "all" です。

package/README.md

@@ -17,7 +17,7 @@ A Model Context Protocol (MCP) server for interacting with the Backlog API. This
 - Wiki page support
 - Git repository and pull request tools
 - Notification tools
-- GraphQL-style field selection for optimized responses
+- Field selection for optimized responses
 - Token limiting for large responses
 
 ## Getting Started
@@ -215,6 +215,14 @@ The server automatically exposes the following OAuth endpoints when OAuth is ena
 
 MCP clients that support the MCP authorization specification will use these endpoints automatically.
 
+`POST /register` restricts which redirect URIs a client may register. A loopback
+URI (`http://localhost`, `http://127.0.0.1`, `http://[::1]`) is how an app running
+on the user's machine receives the authorization code, and is accepted from a
+client that declares `"application_type": "native"` — or, when the field is
+absent, from one whose redirect URIs are _all_ loopback. A client declaring
+`"application_type": "web"`, or mixing a remote `https:` URI with a loopback one
+without declaring itself, is rejected with `invalid_client_metadata`.
+
 > **Limitations:**
 >
 > - OAuth mode currently supports a single Backlog organization. It is not compatible with the multi-organization configuration.
@@ -260,26 +268,6 @@ Using selective toolsets can be helpful if the toolset list is too large for you
 
 > 🧩 Tip: `project` toolset is highly recommended, as many other tools rely on project data as an entry point.
 
-### Dynamic Toolset Discovery (Experimental)
-
-If you're using the MCP server with AI agents, you can enable dynamic discovery of toolsets at runtime:
-
-Enabling via CLI:
-
-```
---dynamic-toolsets
-```
-
-Or via environment variable::
-
-```
--e DYNAMIC_TOOLSETS=1 \
-```
-
-With dynamic toolsets enabled, the LLM will be able to list and activate toolsets on demand via tool interface.
-
-> **Scope over HTTP:** MCP `2026-07-28` has no protocol sessions, so an activated toolset is remembered per **server process**, not per client. On the HTTP transport every connected client shares one toolset state, and it resets when the process restarts. Tool _visibility_ is shared; authorization is not — every call is still authenticated with the caller's own credentials.
-
 ## Available Tools
 
 ### Toolset: `space`
@@ -549,7 +537,7 @@ This is especially useful if you're using multiple MCP servers or tools in the s
 
 ### Response Optimization & Token Limits
 
-#### Field Selection (GraphQL-style)
+#### Field Selection
 
 ```
 --optimize-response
@@ -561,17 +549,18 @@ Or environment variable:
 OPTIMIZE_RESPONSE=1
 ```
 
-Then, request only specific fields:
+Tools that return a **list** then take an optional `fields` parameter: a list of
+top-level field names from that tool's own result, published as an enum so a name
+the tool does not have is rejected rather than ignored. Tools that return a single
+record do not get it — the parameter costs schema on every session, and one record
+has almost nothing to trim.
 
 ```
-get_project(projectIdOrKey: "PROJECT-KEY", fields: "{ name key description }")
+get_project(projectIdOrKey: "PROJECT-KEY", fields: ["name", "key", "description"])
 ```
 
-The AI will use field selection to optimize the response:
-
-```
-get_project(projectIdOrKey: "PROJECT-KEY", fields: "{ name key description }")
-```
+Omitting `fields` returns the whole result. Selection is one level deep: naming an
+object or array field returns it whole.
 
 Benefits:
 
@@ -630,8 +619,7 @@ This section demonstrates advanced configuration using multiple environment vari
         "MAX_TOKENS": "10000",
         "OPTIMIZE_RESPONSE": "1",
         "PREFIX": "backlog_",
-        "ENABLE_TOOLSETS": "space,project,issue",
-        "ENABLE_DYNAMIC_TOOLSETS": "1"
+        "ENABLE_TOOLSETS": "space,project,issue"
       }
     }
   }
@@ -663,7 +651,7 @@ The server supports several command line options:
 - `--http-allowed-hosts`: Comma-separated allowed `Host` hostnames (port-agnostic). Needed when binding to all interfaces, or on a loopback bind behind a reverse proxy.
 - `--http-allowed-origins`: Comma-separated allowed `Origin` hostnames for browser-based clients. Defaults to the localhost set on a bare loopback bind, and to no `Origin` check otherwise.
 - `--export-descriptions`: Export the description keys and values resolved when building the tool list. Was named `--export-translations`; that spelling still works as a deprecated alias and will be removed in a future release
-- `--optimize-response`: Enable GraphQL-style field selection
+- `--optimize-response`: Add a `fields` parameter to each tool for selecting which result fields to return
 - `--max-tokens=NUMBER`: Set maximum token limit for responses
 - `--prefix=STRING`: Optional string prefix to prepend to all tool names (default: "")
 - `--enable-toolsets <toolsets...>`: Specify which toolsets to enable (comma-separated or multiple arguments). Defaults to "all".

package/build/auth/oauthRoutes.js

@@ -15,17 +15,54 @@ function verifyPkce(codeVerifier, codeChallenge) {
 function oauthError(code, description) {
     return { error: code, error_description: description };
 }
+function isLoopbackRedirectUri(uri) {
+    try {
+        const parsed = new URL(uri);
+        return (parsed.protocol === 'http:' && LOCALHOST_HOSTS.includes(parsed.hostname));
+    }
+    catch {
+        return false;
+    }
+}
 function isValidRedirectUri(uri) {
     try {
         const parsed = new URL(uri);
         if (parsed.protocol === 'https:')
             return true;
-        return (parsed.protocol === 'http:' && LOCALHOST_HOSTS.includes(parsed.hostname));
+        return isLoopbackRedirectUri(uri);
     }
     catch {
         return false;
     }
 }
+/** RFC 7591 defines these two, and defaults to `web` when the field is absent. */
+const APPLICATION_TYPES = ['web', 'native'];
+/**
+ * Decides which application type a registration is held to.
+ *
+ * A loopback redirect URI is the standard way for an app on the user's machine
+ * to receive the authorization code (RFC 8252), and the wrong thing entirely for
+ * an app that has a domain of its own: nobody owns `http://localhost`, so
+ * whichever process is listening on that port receives the code.
+ *
+ * RFC 7591 defaults the field to `web`, which would reject every local MCP
+ * client that does not declare itself — and they do not, because nothing has
+ * ever checked. So an undeclared registration is judged by what it asks for: a
+ * set of redirect URIs that is entirely loopback can only be a native client,
+ * and is treated as one.
+ *
+ * The inference deliberately requires *all* of them. A registration mixing a
+ * remote https URI with a loopback one is the shape this check exists to stop:
+ * something that can serve a redirect on its own domain has no need to also
+ * collect codes on the user's machine. Mixing is only accepted from a client
+ * that declares `native` outright, which RFC 8252 does allow (a native app may
+ * claim an https URI as well as a loopback one).
+ */
+function resolveApplicationType(declared, redirectUris) {
+    if (declared)
+        return declared;
+    return redirectUris.every(isLoopbackRedirectUri) ? 'native' : 'web';
+}
 export function createOAuthRoutes(config, store, mcpPath) {
     const app = new Hono();
     const { serverBaseUrl } = config;
@@ -76,6 +113,21 @@ export function createOAuthRoutes(config, store, mcpPath) {
                 return c.json(oauthError('invalid_client_metadata', `redirect_uri must use https or http://localhost: ${uri}`), 400);
             }
         }
+        // `null` counts as not declared. Serialisers that emit null for an absent
+        // optional field are common, and rejecting it would break clients this
+        // change is meant to leave alone.
+        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);
+        }
+        const applicationType = resolveApplicationType(declaredApplicationType, redirectUris);
+        if (applicationType === 'web') {
+            const loopback = redirectUris.filter(isLoopbackRedirectUri);
+            if (loopback.length > 0) {
+                return c.json(oauthError('invalid_client_metadata', `application_type "web" may not use a loopback redirect_uri: ${loopback.join(', ')}. Declare application_type "native" if this client runs on the user's machine.`), 400);
+            }
+        }
         const authMethod = typeof body.token_endpoint_auth_method === 'string'
             ? body.token_endpoint_auth_method
             : 'client_secret_post';

package/build/createBacklogMcpServer.d.ts

@@ -12,13 +12,11 @@ export type CreateBacklogMcpServerConfig = {
     descriptionHelper: DescriptionHelper;
     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.
+     * `enabledToolsets`. Callers that produce many servers from one factory pass a
+     * single shared group so the tool tree is built once rather than per request.
+     * Nothing mutates it.
      */
     toolsetGroup?: ToolsetGroup;
 };
@@ -26,4 +24,4 @@ export type CreateBacklogMcpServerConfig = {
  * 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, descriptionHelper, enabledToolsets, mcpOption, dynamicToolsets, toolsetGroup: sharedToolsetGroup, }: CreateBacklogMcpServerConfig): BacklogMCPServer;
+export declare function createBacklogMcpServer({ version, useFields, backlog, clientRegistry, descriptionHelper, enabledToolsets, mcpOption, toolsetGroup: sharedToolsetGroup, }: CreateBacklogMcpServerConfig): BacklogMCPServer;

package/build/createBacklogMcpServer.js

@@ -3,13 +3,10 @@
 import { McpServer } from '@modelcontextprotocol/server';
 import { registerDynamicTools, registerTools } from './registerTools.js';
 import { organizationTools } from './tools/dynamicTools/organizations.js';
-import { dynamicTools } from './tools/dynamicTools/toolsets.js';
-import { createToolRegistrar } from './utils/toolRegistrar.js';
 import { buildToolsetGroup } from './utils/toolsetUtils.js';
 import { wrapServerWithToolRegistry, } from './utils/wrapServerWithToolRegistry.js';
-// The tool list is fixed for the process lifetime (it only depends on CLI flags
-// and environment), so clients may cache it. With dynamic toolsets the list can
-// grow at runtime, so no hint is published in that case.
+// The tool list is fixed for the process lifetime: it only depends on CLI flags
+// and environment, so clients may cache it.
 const TOOL_LIST_CACHE_HINT = {
     'tools/list': { ttlMs: 5 * 60 * 1000, cacheScope: 'public' },
 };
@@ -17,12 +14,12 @@ const TOOL_LIST_CACHE_HINT = {
  * 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 function createBacklogMcpServer({ version, useFields, backlog, clientRegistry, descriptionHelper, enabledToolsets, mcpOption, dynamicToolsets, toolsetGroup: sharedToolsetGroup, }) {
+export function createBacklogMcpServer({ version, useFields, backlog, clientRegistry, descriptionHelper, enabledToolsets, mcpOption, toolsetGroup: sharedToolsetGroup, }) {
     const server = wrapServerWithToolRegistry(new McpServer({
         name: 'backlog',
         title: useFields ? 'backlog (field selection enabled)' : 'backlog',
         version,
-    }, dynamicToolsets ? undefined : { cacheHints: TOOL_LIST_CACHE_HINT }));
+    }, { cacheHints: TOOL_LIST_CACHE_HINT }));
     const toolsetGroup = sharedToolsetGroup ??
         buildToolsetGroup(backlog, descriptionHelper, enabledToolsets);
     registerTools(server, toolsetGroup, mcpOption);
@@ -32,10 +29,5 @@ export function createBacklogMcpServer({ version, useFields, backlog, clientRegi
     if (mcpOption.useOrganization) {
         registerDynamicTools(server, organizationTools(clientRegistry, descriptionHelper), mcpOption.prefix);
     }
-    if (dynamicToolsets) {
-        const registrar = createToolRegistrar(server, toolsetGroup, mcpOption);
-        const dynamicToolsetGroup = dynamicTools(registrar, descriptionHelper, toolsetGroup);
-        registerDynamicTools(server, dynamicToolsetGroup, mcpOption.prefix);
-    }
     return server;
 }

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

@@ -13,7 +13,7 @@ export interface ComposeOptions {
     useOrganization?: boolean;
 }
 type ComposedInput = {
-    fields?: string;
+    fields?: string[];
     organization?: string;
 } & Record<string, unknown>;
 /**

package/build/handlers/builders/composeToolHandler.js

@@ -5,7 +5,7 @@ import { wrapWithOrganizationContext } from '../transformers/wrapWithOrganizatio
 import { wrapWithTokenLimit } from '../transformers/wrapWithTokenLimit.js';
 import { wrapWithToolResult } from '../transformers/wrapWithToolResult.js';
 import { z } from 'zod';
-import { generateFieldsDescription } from '../../utils/generateFieldsDescription.js';
+import { fieldSelectionSchema } from '../../utils/fieldSelection.js';
 /**
  * Builds the schema and handler a tool is registered with.
  *
@@ -16,20 +16,24 @@ import { generateFieldsDescription } from '../../utils/generateFieldsDescription
  */
 export function composeToolHandler(tool, 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)
+    // Step 1: Add `fields` to schema if needed.
+    //
+    // Only on tools that return a list. That is where a response grows without
+    // bound and trimming it pays for the schema every client downloads; a tool
+    // returning one record saves a few hundred bytes at best.
+    const fields = useFields && tool.returnsList
+        ? fieldSelectionSchema(tool.outputFields, tool.importantFields ?? [])
         : undefined;
-    const schema = extendSchema(tool.schema, fieldDesc, useOrganization);
+    const schema = extendSchema(tool.schema, fields, useOrganization);
     // Step 2: Compose
     const baseHandler = wrapWithErrorHandling(wrapWithOrganizationContext(tool.handler), errorHandler);
-    const composed = useFields ? wrapWithFieldPicking(baseHandler) : baseHandler;
+    const composed = useFields && fields ? wrapWithFieldPicking(baseHandler) : baseHandler;
     return {
         schema,
         handler: wrapWithToolResult(wrapWithTokenLimit(composed, maxTokens)),
     };
 }
-function extendSchema(schema, desc, withOrganization = false) {
+function extendSchema(schema, fields, withOrganization = false) {
     const extension = {};
     if (withOrganization) {
         extension.organization = z
@@ -37,8 +41,10 @@ function extendSchema(schema, desc, withOrganization = false) {
             .optional()
             .describe('Optional organization name. Use list_organizations to inspect available organizations.');
     }
-    if (desc) {
-        extension.fields = z.string().describe(desc);
+    // Optional, as `wrapWithFieldPicking` assumes: it returns the whole result
+    // when `fields` is absent.
+    if (fields) {
+        extension.fields = fields;
     }
     // zod v4 reworked the ZodObject shape generics, so `extend()`'s result no
     // longer overlaps the declared return type enough for a direct cast. The

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

@@ -1,4 +1,17 @@
 import { SafeResult } from '../../types/result.js';
+/**
+ * Narrows a successful result to the fields the caller asked for.
+ *
+ * `fields` is a list of top-level names, validated against the tool's own enum
+ * before it reaches here, so an unknown name is rejected by the protocol rather
+ * than dropped in silence. A missing or empty list returns everything.
+ *
+ * One level deep on purpose. This used to accept a GraphQL selection set and
+ * parse it with the `graphql` package: ~1 MB for a single `parse` call, a grammar
+ * that accepted aliases, fragments, arguments and directives and then honoured
+ * none of them, and a descent into an array field that returned `{}` and lost the
+ * data outright.
+ */
 export declare function wrapWithFieldPicking<I extends {
-    fields?: string;
+    fields?: string[];
 }, O>(fn: (input: I) => Promise<SafeResult<O>>): (input: I) => Promise<SafeResult<O>>;

package/build/handlers/transformers/wrapWithFieldPicking.js

@@ -1,55 +1,49 @@
-import { parse } from 'graphql';
 import { isErrorLike } from '../../types/result.js';
+/**
+ * Narrows a successful result to the fields the caller asked for.
+ *
+ * `fields` is a list of top-level names, validated against the tool's own enum
+ * before it reaches here, so an unknown name is rejected by the protocol rather
+ * than dropped in silence. A missing or empty list returns everything.
+ *
+ * One level deep on purpose. This used to accept a GraphQL selection set and
+ * parse it with the `graphql` package: ~1 MB for a single `parse` call, a grammar
+ * that accepted aliases, fragments, arguments and directives and then honoured
+ * none of them, and a descent into an array field that returned `{}` and lost the
+ * data outright.
+ */
 export function wrapWithFieldPicking(fn) {
     return async (input) => {
         const { fields, ...rest } = input;
         const result = await fn(rest);
-        if (!fields || isErrorLike(result)) {
+        if (!fields || fields.length === 0 || isErrorLike(result)) {
             return result;
         }
-        const selectionSet = parseFieldsSelection(fields);
-        const resultData = result.data;
-        if (Array.isArray(resultData)) {
+        const data = result.data;
+        if (Array.isArray(data)) {
             return {
                 kind: 'ok',
-                data: resultData.map((item) => pickFieldsFromData(item, selectionSet)),
+                data: data.map((item) => pick(item, fields)),
             };
         }
-        else if (typeof result === 'object' && result !== null) {
+        if (typeof data === 'object' && data !== null) {
             return {
                 kind: 'ok',
-                data: pickFieldsFromData(resultData, selectionSet),
+                data: pick(data, fields),
             };
         }
-        else {
-            return result;
-        }
+        // A scalar has no fields to narrow.
+        return result;
     };
 }
-function parseFieldsSelection(fieldsString) {
-    const query = `query Dummy ${fieldsString}`;
-    const ast = parse(query);
-    const opDef = ast.definitions[0];
-    if (opDef.kind !== 'OperationDefinition' || !opDef.selectionSet) {
-        throw new Error('Invalid GraphQL fields');
-    }
-    return opDef.selectionSet;
-}
-function pickFieldsFromData(data, selectionSet) {
-    const result = {};
-    for (const selection of selectionSet.selections) {
-        if (selection.kind === 'Field') {
-            const key = selection.name.value;
-            if (data != null && key in data) {
-                const value = data[key];
-                if (selection.selectionSet && value != null) {
-                    result[key] = pickFieldsFromData(data[key], selection.selectionSet);
-                }
-                else {
-                    result[key] = data[key];
-                }
-            }
-        }
+function pick(value, fields) {
+    if (typeof value !== 'object' || value === null)
+        return value;
+    const source = value;
+    const picked = {};
+    for (const field of fields) {
+        if (field in source)
+            picked[field] = source[field];
     }
-    return result;
+    return picked;
 }

package/build/index.js

@@ -11,6 +11,7 @@ import { createDescriptionHelper } from './createDescriptionHelper.js';
 import { loadDescriptionOverrides } from './loadDescriptionOverrides.js';
 import { createBacklogMcpServer } from './createBacklogMcpServer.js';
 import { runHttpMcpServer } from './httpMcpServer.js';
+import { reportUnknownOverrideKeys } from './reportUnknownOverrideKeys.js';
 import { createBacklogClientRegistry, createOAuthBacklogClientRegistry, } from './utils/backlogClientRegistry.js';
 import { logger } from './utils/logger.js';
 import { buildToolsetGroup } from './utils/toolsetUtils.js';
@@ -119,11 +120,6 @@ Available toolsets:
   - git:         Tools for managing Git repositories and pull requests
   - notifications: Tools for managing user notifications`,
     default: env.get('ENABLE_TOOLSETS').default('all').asArray(','),
-})
-    .option('dynamic-toolsets', {
-    type: 'boolean',
-    describe: 'Enable dynamic toolsets such as enable_toolset, list_available_toolsets, etc.',
-    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
@@ -133,6 +129,22 @@ Available toolsets:
 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');
 }
+// Dynamic toolsets are gone. yargs ignores the unknown flag, so without this the
+// server would start with a quietly different tool list: the flag used to drop
+// `all` from the enabled toolsets, so a setup that passed only this one went from
+// no toolsets plus three meta-tools to every toolset enabled.
+//
+// Only worth saying to someone who had it switched on. A setting left at `false`
+// asked for what it now gets, so a notice claiming the tool list changed would be
+// wrong.
+const asksForDynamicToolsets = (value) => value !== undefined &&
+    !['', '0', 'false', 'no'].includes(value.toLowerCase());
+const dynamicToolsetsFlag = hideBin(process.argv).find((arg) => arg.split('=')[0] === '--dynamic-toolsets');
+if ((dynamicToolsetsFlag !== undefined &&
+    asksForDynamicToolsets(dynamicToolsetsFlag.split('=')[1] ?? 'true')) ||
+    asksForDynamicToolsets(process.env.ENABLE_DYNAMIC_TOOLSETS)) {
+    process.stderr.write('Dynamic toolsets have been removed, and --dynamic-toolsets / ENABLE_DYNAMIC_TOOLSETS no longer do anything. Every toolset is enabled unless you narrow it with --enable-toolsets or ENABLE_TOOLSETS.\n');
+}
 const clientRegistry = oauthConfig
     ? createOAuthBacklogClientRegistry(oauthConfig.backlogDomain)
     : createBacklogClientRegistry();
@@ -144,24 +156,28 @@ if (tokenStore) {
     cleanupTimer.unref();
 }
 const useFields = argv.optimizeResponse;
-const descriptionHelper = createDescriptionHelper(loadDescriptionOverrides());
+const descriptionOverrides = loadDescriptionOverrides();
+const descriptionHelper = createDescriptionHelper(descriptionOverrides);
 const maxTokens = argv.maxTokens;
 const prefix = argv.prefix;
-const enabledToolsets = argv.dynamicToolsets
-    ? argv.enableToolsets.filter((a) => a !== 'all')
-    : argv.enableToolsets;
+const enabledToolsets = argv.enableToolsets;
 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.
+// Built once and shared by every server the factory produces. Nothing mutates
+// it, so this is purely to avoid rebuilding the whole tool tree per request under
+// the stateless HTTP model.
 const sharedToolsetGroup = buildToolsetGroup(backlog, descriptionHelper, enabledToolsets);
+reportUnknownOverrideKeys({
+    overrides: descriptionOverrides,
+    version,
+    backlog,
+    clientRegistry,
+    mcpOption,
+});
 // Factory: creates a fresh MCP server with all tools registered.
 // Used once per stdio connection; one fresh instance per HTTP request.
 const createServer = () => createBacklogMcpServer({
@@ -172,7 +188,6 @@ const createServer = () => createBacklogMcpServer({
     descriptionHelper,
     enabledToolsets,
     mcpOption,
-    dynamicToolsets: argv.dynamicToolsets,
     toolsetGroup: sharedToolsetGroup,
 });
 if (argv.exportDescriptions) {
@@ -187,7 +202,6 @@ if (argv.exportDescriptions) {
         descriptionHelper,
         enabledToolsets: ['all'],
         mcpOption,
-        dynamicToolsets: true,
     });
     const data = descriptionHelper.dump();
     // eslint-disable-next-line no-console

package/build/lib.d.ts

@@ -20,6 +20,6 @@ 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 { ToolDefinition, DynamicToolDefinition } from './types/tool.js';
 export type { Toolset, ToolsetGroup, DynamicToolset, DynamicToolsetGroup, } from './types/toolsets.js';
 export type { ErrorLike, SafeResult } from './types/result.js';

package/build/loadDescriptionOverrides.d.ts

@@ -1,16 +1,3 @@
-/**
- * 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;