backlog-mcp-server 0.15.0 → 0.16.0

package/README.ja.md

@@ -303,10 +303,14 @@ PROJECT-KEYプロジェクトの「repo-name」リポジトリで、ブランチ
 私がウォッチしているすべてのアイテムを表示してください。
 ```
 
-### i18n / 説明のオーバーライド
+### ツール説明のオーバーライド
 
 **ホームディレクトリ** に `.backlog-mcp-serverrc.json` ファイルを作成することで、ツールの説明をオーバーライドできます。
 
+これらの文字列のほとんどは、モデルがどのツールを呼ぶか、引数に何を入れるかを判断するために読むツール説明・パラメータ説明です。したがってオーバーライドは、似た2つのツールを区別させたり、チームの運用ルールを添えたりしてツール選択を誘導するための手段であり、応答の言語を変えるためのものではありません。モデルは説明が何語で書かれていても、質問された言語で応答します。
+
+一部のキーは、これとは別にバリデーションエラーのメッセージです（例：`PROJECT_ID_OR_KEY_REQUIRED`）。呼び出しが弾かれたときにツールの実行結果として返るため、モデルの応答を経由してユーザーの目に触れることがあります。
+
 ファイルには、ツール名をキーとし、新しい説明を値とするJSONオブジェクトを含める必要があります。
 例：
 
@@ -321,7 +325,9 @@ PROJECT-KEYプロジェクトの「repo-name」リポジトリで、ブランチ
 
 1. 環境変数（例：`BACKLOG_MCP_TOOL_ADD_ISSUE_COMMENT_DESCRIPTION`）
 2. `.backlog-mcp-serverrc.json` 内のエントリ - サポートされる設定ファイル形式：.json、.yaml、.yml
-3. 組み込みのフォールバック値（英語）
+3. 組み込みのデフォルト値
+
+空文字列または文字列以外の値は、どの段階でも無視され、組み込みのデフォルト値が使われます。
 
 サンプル設定：
 
@@ -351,22 +357,24 @@ PROJECT-KEYプロジェクトの「repo-name」リポジトリで、ブランチ
 }
 ```
 
-### 現在の翻訳のエクスポート
+### 現在の説明のエクスポート
 
-`--export-translations` フラグを指定してバイナリを実行することで、現在のデフォルト翻訳（オーバーライドを含む）をエクスポートできます。
+`--export-descriptions` フラグを指定してバイナリを実行することで、現在の説明（オーバーライドを含む）をエクスポートできます。このフラグは以前 `--export-translations` という名前でした。旧名も当面は動作しますが、非推奨の警告を出力し、将来のリリースで削除されます。
 
-これにより、行ったカスタマイズを含むすべてのツール説明が標準出力に出力されます。
+ツール一覧の構築時に解決されるすべてのキーと現在の値が、行ったカスタマイズを含めて標準出力に出力されます。ツール説明・パラメータ説明はすべて含まれるため、キー名を調べる用途にはこれを使ってください。
+
+バリデーションエラーのメッセージは含まれません。これらのキーは、実際に呼び出しが弾かれたときにはじめて解決されるためです。オーバーライド自体は同じ規則で可能ですが、キー名はソースを読んで調べる必要があります。
 
 例：
 
 ```bash
-docker run -i --rm ghcr.io/nulab/backlog-mcp-server node build/index.js --export-translations
+docker run -i --rm ghcr.io/nulab/backlog-mcp-server node build/index.js --export-descriptions
 ```
 
 または
 
 ```bash
-npx github:nulab/backlog-mcp-server --export-translations
+npx github:nulab/backlog-mcp-server --export-descriptions
 ```
 
 ### 環境変数の使用
@@ -537,7 +545,7 @@ pnpm test
 
 サーバーはいくつかのコマンドラインオプションをサポートしています：
 
-- `--export-translations`: すべての翻訳キーと値をエクスポート
+- `--export-descriptions`: ツール一覧の構築時に解決される説明キーと値をエクスポート。旧名は `--export-translations` で、非推奨エイリアスとして当面動作しますが、将来のリリースで削除されます
 - `--optimize-response`: GraphQLスタイルのフィールド選択を有効にする
 - `--max-tokens=NUMBER`: レスポンスの最大トークン制限を設定
 - `--prefix=STRING`: すべてのツール名に付加するオプションの文字列プレフィックス（デフォルト：""）
@@ -596,7 +604,9 @@ BACKLOG_API_KEY=your-api-key
 
 ### ツールの使い方
 
-通常のツールはすべて、任意の`organization`入力フィールドを受け付けます。指定した場合、そのBacklog組織に対してツールが実行されます。
+マルチ組織用の環境変数が設定されている場合、通常のツールはすべて任意の`organization`入力フィールドを受け付けます。指定した場合、そのBacklog組織に対してツールが実行されます。
+
+単一組織モードでは、ルーティング先が1つしかないためこのフィールドは公開されません。これにより`tools/list`のレスポンスから約8KBのスキーマが削減されます。
 
 例：
 
@@ -614,7 +624,7 @@ BACKLOG_API_KEY=your-api-key
 
 ### 組織一覧の確認
 
-サーバーは `list_organizations` ツールを提供しており、設定済みの組織名、ドメイン、デフォルト組織かどうかを返します。
+マルチ組織モードでは、サーバーは `list_organizations` ツールを提供しており、設定済みの組織名、ドメイン、デフォルト組織かどうかを返します。単一組織モードでは登録されません。
 
 レスポンス例：
 

package/README.md

@@ -418,10 +418,14 @@ Create a new pull request from branch "feature/new-feature" to "main" in the rep
 Show me all items I'm watching
 ```
 
-### i18n / Overriding Descriptions
+### Overriding Tool Descriptions
 
 You can override the descriptions of tools by creating a `.backlog-mcp-serverrc.json` file in your **home directory**.
 
+Almost all of these strings are the tool and parameter descriptions the model reads when it decides which tool to call and how to fill in its arguments, so overriding them is a way to steer tool selection — for example to disambiguate two similar tools, or to add a rule your team follows — rather than a way to change the language of the answers you get. The model answers in whatever language you ask in, regardless of the language these descriptions are written in.
+
+A small number of keys are validation error messages instead (for example `PROJECT_ID_OR_KEY_REQUIRED`). Those are returned in the tool result when a call is rejected, so they can reach you by way of the model's reply.
+
 The file should contain a JSON object with the tool names as keys and the new descriptions as values.  
 For example:
 
@@ -436,7 +440,9 @@ When the server starts, it determines the final description for each tool based
 
 1. Environment variables (e.g., `BACKLOG_MCP_TOOL_ADD_ISSUE_COMMENT_DESCRIPTION`)
 2. Entries in `.backlog-mcp-serverrc.json` - Supported configuration file formats: .json, .yaml, .yml
-3. Built-in fallback values (English)
+3. Built-in defaults
+
+Empty or non-string values are ignored at every level, and the built-in default is used instead.
 
 Sample config:
 
@@ -466,22 +472,24 @@ Sample config:
 }
 ```
 
-### Exporting Current Translations
+### Exporting Current Descriptions
 
-You can export the current default translations (including any overrides) by running the binary with the --export-translations flag.
+You can export the current descriptions (including any overrides) by running the binary with the `--export-descriptions` flag. This flag was previously called `--export-translations`; the old name still works but prints a deprecation notice and will be removed in a future release.
 
-This will print all tool descriptions to stdout, including any customizations you have made.
+This prints every key that is resolved while the tool list is built, with its current value, including any customizations you have made. That covers all tool and parameter descriptions, and it is the practical way to discover key names.
+
+It does not cover the validation error messages, because those keys are only resolved when a call is actually rejected. They are still overridable by the same rules; you just have to read them out of the source.
 
 Example:
 
 ```bash
-docker run -i --rm ghcr.io/nulab/backlog-mcp-server node build/index.js --export-translations
+docker run -i --rm ghcr.io/nulab/backlog-mcp-server node build/index.js --export-descriptions
 ```
 
 or
 
 ```bash
-npx github:nulab/backlog-mcp-server --export-translations
+npx github:nulab/backlog-mcp-server --export-descriptions
 ```
 
 ### Using Environment Variables
@@ -654,7 +662,7 @@ The server supports several command line options:
 - `--http-json-response`: Prefer JSON responses over SSE. Applies to `2026-07-28` clients only; the backward-compatible `2025-11-25` path is served with the SDK's default response shaping.
 - `--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-translations`: Export all translation keys and values
+- `--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
 - `--max-tokens=NUMBER`: Set maximum token limit for responses
 - `--prefix=STRING`: Optional string prefix to prepend to all tool names (default: "")
@@ -715,7 +723,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 +743,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 { DescriptionHelper } from './createDescriptionHelper.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;
+    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.
+     */
+    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, descriptionHelper, enabledToolsets, mcpOption, dynamicToolsets, toolsetGroup: sharedToolsetGroup, }: CreateBacklogMcpServerConfig): BacklogMCPServer;

package/build/createBacklogMcpServer.js

@@ -17,19 +17,24 @@ 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, transHelper, enabledToolsets, mcpOption, dynamicToolsets, toolsetGroup: sharedToolsetGroup, }) {
+export function createBacklogMcpServer({ version, useFields, backlog, clientRegistry, descriptionHelper, enabledToolsets, mcpOption, dynamicToolsets, toolsetGroup: sharedToolsetGroup, }) {
     const server = wrapServerWithToolRegistry(new McpServer({
         name: 'backlog',
         title: useFields ? 'backlog (field selection enabled)' : 'backlog',
         version,
     }, dynamicToolsets ? undefined : { cacheHints: TOOL_LIST_CACHE_HINT }));
     const toolsetGroup = sharedToolsetGroup ??
-        buildToolsetGroup(backlog, transHelper, enabledToolsets);
+        buildToolsetGroup(backlog, descriptionHelper, 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, descriptionHelper), mcpOption.prefix);
+    }
     if (dynamicToolsets) {
         const registrar = createToolRegistrar(server, toolsetGroup, mcpOption);
-        const dynamicToolsetGroup = dynamicTools(registrar, transHelper, toolsetGroup);
+        const dynamicToolsetGroup = dynamicTools(registrar, descriptionHelper, toolsetGroup);
         registerDynamicTools(server, dynamicToolsetGroup, mcpOption.prefix);
     }
     return server;

package/build/createDescriptionHelper.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Resolves the strings every tool definition passes through `t()`. Almost all of
+ * them are tool and parameter descriptions, read by the model when it picks a
+ * tool and fills in arguments. A few are validation error messages — `deleteVersion`
+ * and `resolveIdOrField` throw them — which do surface, as the text of a failed
+ * tool result.
+ *
+ * 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
+ * `loadDescriptionOverrides` and the CLI passes the result in.
+ */
+export interface DescriptionHelper {
+    t: (key: string, fallback: string) => string;
+    dump: () => Record<string, string>;
+}
+export declare function createDescriptionHelper(overrides?: Record<string, string>): DescriptionHelper;

package/build/createDescriptionHelper.js

@@ -0,0 +1,24 @@
+export function createDescriptionHelper(overrides = {}) {
+    const usedKeys = {};
+    function toEnvKey(key) {
+        return `BACKLOG_MCP_${key}`;
+    }
+    function t(key, fallback) {
+        const upperKey = key.toUpperCase();
+        if (usedKeys[upperKey]) {
+            return usedKeys[upperKey];
+        }
+        // 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;
+    }
+    function dump() {
+        return { ...usedKeys };
+    }
+    return { t, dump };
+}

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 {};