context-xray 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 BenYang
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,127 @@
+# context-xray
+
+**See what your MCP servers cost you — before you type a word.**
+
+[![CI](https://github.com/Beeeeen/context-xray/actions/workflows/ci.yml/badge.svg)](https://github.com/Beeeeen/context-xray/actions/workflows/ci.yml)
+[![npm](https://img.shields.io/npm/v/context-xray.svg)](https://www.npmjs.com/package/context-xray)
+[![license](https://img.shields.io/npm/l/context-xray.svg)](./LICENSE)
+
+```bash
+npx context-xray
+```
+
+Every MCP server you configure injects its full tool catalog — every name, every description, every JSON schema — into **every single request** your agent makes. You never see this. It happens before your first word, it is resent on every message, and it never shows up itemised on a bill.
+
+context-xray finds every server configured in Claude Desktop, Claude Code, Cursor, Windsurf and VS Code, connects to each one, and weighs exactly what it charges you:
+
+```
+  context-xray  your MCP servers add ~14,443 tokens to every request
+  1 config searched, 4 servers found, 4 measured
+
+  rank  server                host               tools    tokens  share
+  #1    github                Claude Code           26    ~5,123    35%  ######............
+  #2    playwright            Claude Code           24    ~4,785    33%  ######............
+  #3    filesystem            Claude Desktop        14    ~2,333    16%  ###...............
+  #4    everything            Claude Desktop        16    ~2,202    15%  ###...............
+
+  github  github-mcp-server v0.6.2  26 tools, connected in 3523ms
+         513 tok  create_pull_request_review                desc 8, schema 482
+         326 tok  list_pull_requests                        desc 10, schema 296
+         292 tok  create_pull_request                       desc 11, schema 259
+       3,992 tok  … 23 more tools
+
+  playwright  Playwright v1.63.0  24 tools, connected in 3900ms
+         429 tok  browser_take_screenshot                   desc 31, schema 376
+         324 tok  browser_fill_form                         desc 6, schema 297
+       4,032 tok  … 22 more tools
+
+  ------------------------------------------------------------------------
+  ~14,443 tokens on every request = 7.2% of a 200,000 context window, before you type a word
+  at 200 requests/day and $3.00/MTok input: ~$260/month of uncached input spend
+
+  ! over 10% of the window goes to tool definitions -- disable the servers
+    you are not using today
+```
+
+Those are real numbers from real servers — that four-server setup is a perfectly ordinary one, and it spends 7% of the context window on standby.
+
+No install, no config, no account, zero dependencies. It reads the configs you already have.
+
+---
+
+## Why this matters
+
+**Context.** The context window is the scarcest resource an agent has. Tool definitions are pure overhead: they crowd out your conversation, your files, your actual work. Long sessions degrade sooner, and "compact" happens earlier, in direct proportion to this number. Most people have never seen it.
+
+**Money.** Input tokens are billed per request. A 14k-token tool catalog at a few hundred requests a day is real spend — caching softens it but does not erase it, and cache writes bill at a premium. The table above is the line item your invoice never shows.
+
+**Model quality.** Models pick tools by reading their descriptions. A 24-tool server whose every schema looks alike does not just cost tokens — it measurably degrades tool selection. The heaviest tools in the ranking are usually also the ones confusing your agent.
+
+## Usage
+
+```bash
+# find and weigh everything configured on this machine
+npx context-xray
+
+# just one host's config, or one server
+npx context-xray --config ~/.claude.json
+npx context-xray --server github,playwright
+
+# weigh a server that is not configured anywhere yet
+npx context-xray -- npx -y @playwright/mcp@latest
+npx context-xray --url http://localhost:3000/mcp
+```
+
+| flag | |
+|---|---|
+| `--precise` | exact counts via the free Anthropic `count_tokens` API (needs `ANTHROPIC_API_KEY`) |
+| `--json` | machine-readable report |
+| `--requests-per-day <n>` | volume assumption for the cost line (default 200) |
+| `--price <usd>` | $/MTok input for the cost line (default 3.00) |
+| `--top <n>` | tools listed per server (default 3) |
+| `--timeout <ms>` | per-server timeout (default 15000) |
+
+Configs it knows how to read: Claude Desktop, Claude Code (`~/.claude.json`, per-project entries, and `./.mcp.json`), Cursor, Windsurf, and VS Code (both the `mcpServers` and `servers` shapes, including `${input:...}` entries — those are reported as unmeasurable rather than silently skipped). A server configured in several hosts is measured once and attributed to all of them.
+
+## Exact numbers
+
+By default the token counts are estimates from a tokenizer-calibrated character model (JSON weighs heavier than prose, and is marked `~`). For exact numbers:
+
+```bash
+ANTHROPIC_API_KEY=sk-... npx context-xray --precise
+```
+
+This uses the Anthropic [count_tokens](https://docs.anthropic.com/en/api/messages-count-tokens) endpoint, which is free of charge. Only the tool definitions being counted are sent — never your conversation, never your files.
+
+## What it does and does not do
+
+- It connects, performs the MCP handshake, reads the tool/resource/prompt lists, and disconnects. **It never invokes a tool.**
+- Environment values in your configs are passed to the servers they belong to, and are **never printed or transmitted**.
+- Servers that fail to start are reported with the reason (and their stderr), not skipped — a server that cannot start is costing you a different way.
+- The measured tax covers what hosts inject per request: tool definitions plus server `instructions`. Resources and prompts are listed for information but are not part of the per-request tax.
+
+## Programmatic use
+
+```ts
+import { discover, weighAll } from 'context-xray'
+
+const { specs } = discover()
+const weights = await weighAll(specs, {
+  timeoutMs: 15000, precise: false, requestsPerDay: 200,
+  pricePerMTok: 3, top: 3, concurrency: 4,
+})
+for (const w of weights) console.log(w.spec.name, w.taxTokens)
+```
+
+## See also
+
+The rest of the toolchain, built on the same zero-dependency MCP client:
+
+- [**mcp-wtf**](https://github.com/Beeeeen/mcp-wtf) — your MCP server won't connect; find out why in 10 seconds.
+- [**mcp-probe**](https://github.com/Beeeeen/mcp-probe) — conformance and robustness tests for MCP servers, built to run in CI.
+
+mcp-wtf answers "why won't it connect", context-xray answers "what is it costing me", mcp-probe answers "will it break my users".
+
+## License
+
+MIT

package/dist/cli.d.ts

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

package/dist/cli.js

@@ -0,0 +1,224 @@
+#!/usr/bin/env node
+import { existsSync } from 'node:fs';
+import { discover } from './discover.js';
+import { weighAll } from './weigh.js';
+import { renderTerminal } from './report/terminal.js';
+const VERSION = '0.1.0';
+const HELP = `
+  context-xray ${VERSION}
+  See what your MCP servers cost you: the context-window tokens they add to
+  every single request, before you type a word.
+
+  USAGE
+    context-xray                        find and weigh every configured server
+    context-xray --config <file>        weigh the servers in one config file
+    context-xray --server <name>        only the named server(s); repeatable
+    context-xray -- <command> [...]     weigh one stdio server directly
+    context-xray --url <url>            weigh one streamable-HTTP server
+
+  OUTPUT
+    --json                  machine-readable report on stdout
+    --top <n>               tools to list per server (default 3)
+
+  MEASUREMENT
+    --precise               use the free Anthropic count_tokens API for exact
+                            numbers (needs ANTHROPIC_API_KEY; nothing is sent
+                            anywhere except the tool definitions being counted)
+    --timeout <ms>          per-server timeout (default 15000)
+    --concurrency <n>       servers weighed at once (default 4)
+
+  COST PROJECTION
+    --requests-per-day <n>  assumed request volume (default 200)
+    --price <usd>           $ per million input tokens (default 3.00)
+
+  Configs searched: Claude Desktop, Claude Code (~/.claude.json and ./.mcp.json),
+  Cursor, Windsurf, VS Code. Servers appearing in several hosts are measured once.
+
+  context-xray never calls your tools. It connects, reads the tool list, and
+  disconnects. Environment values from your configs are passed to the servers
+  they belong to and are never printed.
+`;
+function parseArgs(argv) {
+    const out = {
+        options: {
+            timeoutMs: 15_000,
+            precise: false,
+            apiKey: process.env['ANTHROPIC_API_KEY'],
+            requestsPerDay: 200,
+            pricePerMTok: 3,
+            top: 3,
+            concurrency: 4,
+        },
+        json: false,
+        top: 3,
+        serverFilter: [],
+        help: false,
+        version: false,
+    };
+    let url = null;
+    let headers = {};
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === '--') {
+            const rest = argv.slice(i + 1);
+            if (rest.length === 0)
+                return { ...out, error: '`--` must be followed by the server command' };
+            out.direct = { name: rest.join(' '), kind: 'stdio', command: rest[0], args: rest.slice(1), sources: ['command line'] };
+            break;
+        }
+        const next = () => argv[++i];
+        const num = (flag) => {
+            const v = Number(next());
+            if (!Number.isFinite(v) || v <= 0) {
+                out.error = `${flag} needs a positive number`;
+                return null;
+            }
+            return v;
+        };
+        switch (arg) {
+            case '-h':
+            case '--help':
+                out.help = true;
+                break;
+            case '-v':
+            case '--version':
+                out.version = true;
+                break;
+            case '--json':
+                out.json = true;
+                break;
+            case '--precise':
+                out.options.precise = true;
+                break;
+            case '--config':
+                out.config = next();
+                break;
+            case '--server':
+                out.serverFilter.push(...(next() ?? '').split(',').filter(Boolean));
+                break;
+            case '--url':
+                url = next() ?? null;
+                break;
+            case '--header': {
+                const raw = next() ?? '';
+                const idx = raw.indexOf(':');
+                if (idx < 1)
+                    return { ...out, error: `--header expects "Name: value", got "${raw}"` };
+                headers[raw.slice(0, idx).trim()] = raw.slice(idx + 1).trim();
+                break;
+            }
+            case '--top': {
+                const v = num('--top');
+                if (v === null)
+                    return out;
+                out.top = Math.floor(v);
+                break;
+            }
+            case '--timeout': {
+                const v = num('--timeout');
+                if (v === null)
+                    return out;
+                out.options.timeoutMs = v;
+                break;
+            }
+            case '--concurrency': {
+                const v = num('--concurrency');
+                if (v === null)
+                    return out;
+                out.options.concurrency = Math.floor(v);
+                break;
+            }
+            case '--requests-per-day': {
+                const v = num('--requests-per-day');
+                if (v === null)
+                    return out;
+                out.options.requestsPerDay = v;
+                break;
+            }
+            case '--price': {
+                const v = num('--price');
+                if (v === null)
+                    return out;
+                out.options.pricePerMTok = v;
+                break;
+            }
+            default:
+                return { ...out, error: `Unknown option "${arg}". Try --help.` };
+        }
+    }
+    if (url) {
+        out.direct = { name: url, kind: 'http', url, headers, sources: ['command line'] };
+    }
+    if (out.options.precise && !out.options.apiKey) {
+        return { ...out, error: '--precise needs ANTHROPIC_API_KEY in the environment' };
+    }
+    return out;
+}
+async function main() {
+    const parsed = parseArgs(process.argv.slice(2));
+    if (parsed.help) {
+        process.stdout.write(HELP);
+        process.exit(0);
+    }
+    if (parsed.version) {
+        process.stdout.write(VERSION + '\n');
+        process.exit(0);
+    }
+    if (parsed.error) {
+        process.stderr.write(`context-xray: ${parsed.error}\n`);
+        process.exit(2);
+    }
+    let specs;
+    let configsSearched;
+    if (parsed.direct) {
+        specs = [parsed.direct];
+        configsSearched = [];
+    }
+    else {
+        if (parsed.config && !existsSync(parsed.config)) {
+            process.stderr.write(`context-xray: no such config file: ${parsed.config}\n`);
+            process.exit(2);
+        }
+        const found = discover(parsed.config);
+        specs = found.specs;
+        configsSearched = found.configsSearched;
+        if (parsed.serverFilter.length > 0) {
+            specs = specs.filter((s) => parsed.serverFilter.includes(s.name));
+            const missing = parsed.serverFilter.filter((f) => !specs.some((s) => s.name === f));
+            if (missing.length > 0) {
+                process.stderr.write(`context-xray: no server named ${missing.map((m) => `"${m}"`).join(', ')} in the discovered configs\n`);
+                process.exit(2);
+            }
+        }
+    }
+    if (specs.length === 0) {
+        process.stderr.write(configsSearched.length === 0
+            ? 'context-xray: no MCP config files found. Point it at one with --config <file>, or at a server with `context-xray -- <command>`.\n'
+            : `context-xray: searched ${configsSearched.length} config file(s) but found no MCP servers in them.\n`);
+        process.exit(2);
+    }
+    const t0 = Date.now();
+    const servers = await weighAll(specs, parsed.options);
+    const measured = servers.filter((s) => s.ok);
+    const methods = new Set(measured.map((s) => s.method));
+    const report = {
+        servers,
+        totalTaxTokens: measured.reduce((sum, s) => sum + s.taxTokens, 0),
+        method: methods.size === 1 ? (methods.has('counted') ? 'counted' : 'estimate') : methods.size === 0 ? 'estimate' : 'mixed',
+        options: { requestsPerDay: parsed.options.requestsPerDay, pricePerMTok: parsed.options.pricePerMTok },
+        configsSearched,
+        durationMs: Date.now() - t0,
+    };
+    if (parsed.json) {
+        process.stdout.write(JSON.stringify(report, null, 2) + '\n');
+    }
+    else {
+        process.stdout.write(renderTerminal(report, parsed.top));
+    }
+    // 0 when everything asked for was measured; 1 when some servers failed.
+    process.exit(measured.length === servers.length ? 0 : 1);
+}
+main().catch((e) => {
+    process.stderr.write(`context-xray: internal error: ${e.stack ?? String(e)}\n`);
+    process.exit(2);
+});

package/dist/client/http.d.ts

@@ -0,0 +1,37 @@
+import type { Transport } from './transport.js';
+import { type JsonRpcResponse } from './jsonrpc.js';
+export interface HttpOptions {
+    url: string;
+    headers?: Record<string, string>;
+}
+/**
+ * Streamable HTTP transport. Each request is a POST; the server may answer
+ * with `application/json` or an SSE stream, and may hand us a session id on
+ * the initialize response that must be echoed on every later call.
+ */
+export declare class HttpTransport implements Transport {
+    private opts;
+    readonly kind = "http";
+    readonly target: string;
+    readonly stdoutNoise: string[];
+    readonly stderr: string[];
+    readonly serverNotifications: JsonRpcResponse[];
+    private nextId;
+    private sessionId;
+    private closed;
+    /** Populated when a response arrives with a shape we could not read. */
+    readonly protocolNotes: string[];
+    constructor(opts: HttpOptions);
+    start(): Promise<void>;
+    private headers;
+    request(method: string, params?: unknown, timeoutMs?: number): Promise<JsonRpcResponse>;
+    requestRaw(payload: Record<string, unknown>, _id: number | string, method: string, timeoutMs?: number): Promise<JsonRpcResponse>;
+    private post;
+    /** Pull the first `data:` frame that carries a JSON-RPC reply. */
+    private parseSse;
+    notify(method: string, params?: unknown): void;
+    writeRaw(text: string): void;
+    isAlive(): boolean;
+    exitInfo(): null;
+    close(): Promise<void>;
+}

package/dist/client/http.js

@@ -0,0 +1,133 @@
+import { TimeoutError, TransportClosedError } from './jsonrpc.js';
+/**
+ * Streamable HTTP transport. Each request is a POST; the server may answer
+ * with `application/json` or an SSE stream, and may hand us a session id on
+ * the initialize response that must be echoed on every later call.
+ */
+export class HttpTransport {
+    opts;
+    kind = 'http';
+    target;
+    stdoutNoise = [];
+    stderr = [];
+    serverNotifications = [];
+    nextId = 1;
+    sessionId = null;
+    closed = false;
+    /** Populated when a response arrives with a shape we could not read. */
+    protocolNotes = [];
+    constructor(opts) {
+        this.opts = opts;
+        this.target = opts.url;
+    }
+    async start() {
+        /* Nothing to spawn; the first POST is the real connection test. */
+    }
+    headers() {
+        const h = {
+            'content-type': 'application/json',
+            accept: 'application/json, text/event-stream',
+            ...this.opts.headers,
+        };
+        if (this.sessionId)
+            h['mcp-session-id'] = this.sessionId;
+        return h;
+    }
+    request(method, params, timeoutMs = 10_000) {
+        const id = this.nextId++;
+        return this.post({ jsonrpc: '2.0', id, method, ...(params !== undefined ? { params } : {}) }, method, timeoutMs);
+    }
+    requestRaw(payload, _id, method, timeoutMs = 10_000) {
+        return this.post(payload, method, timeoutMs);
+    }
+    async post(payload, method, timeoutMs) {
+        if (this.closed)
+            throw new TransportClosedError('Transport already closed');
+        const ac = new AbortController();
+        const timer = setTimeout(() => ac.abort(), timeoutMs);
+        let res;
+        try {
+            res = await fetch(this.opts.url, {
+                method: 'POST',
+                headers: this.headers(),
+                body: JSON.stringify(payload),
+                signal: ac.signal,
+            });
+        }
+        catch (e) {
+            clearTimeout(timer);
+            if (ac.signal.aborted)
+                throw new TimeoutError(method, timeoutMs);
+            throw new TransportClosedError(`POST ${this.opts.url} failed: ${e.message}`);
+        }
+        clearTimeout(timer);
+        const sid = res.headers.get('mcp-session-id');
+        if (sid)
+            this.sessionId = sid;
+        // 202 with no body is the legal answer to a notification.
+        if (res.status === 202)
+            return {};
+        const ctype = res.headers.get('content-type') ?? '';
+        const body = await res.text();
+        if (!res.ok) {
+            throw new TransportClosedError(`HTTP ${res.status} ${res.statusText} from ${this.opts.url}: ${body.slice(0, 400)}`);
+        }
+        if (ctype.includes('text/event-stream'))
+            return this.parseSse(body, method);
+        if (!body.trim())
+            return {};
+        try {
+            return JSON.parse(body);
+        }
+        catch {
+            this.protocolNotes.push(`Non-JSON body for \`${method}\` (content-type: ${ctype || 'none'}): ${body.slice(0, 200)}`);
+            throw new TransportClosedError(`Server returned unparseable body for \`${method}\``);
+        }
+    }
+    /** Pull the first `data:` frame that carries a JSON-RPC reply. */
+    parseSse(body, method) {
+        const frames = body.split(/\n\n/);
+        let last = null;
+        for (const frame of frames) {
+            const data = frame
+                .split('\n')
+                .filter((l) => l.startsWith('data:'))
+                .map((l) => l.slice(5).trim())
+                .join('');
+            if (!data)
+                continue;
+            let msg;
+            try {
+                msg = JSON.parse(data);
+            }
+            catch {
+                this.protocolNotes.push(`Unparseable SSE frame during \`${method}\`: ${data.slice(0, 200)}`);
+                continue;
+            }
+            if (msg.id !== undefined && msg.id !== null)
+                last = msg;
+            else
+                this.serverNotifications.push(msg);
+        }
+        if (!last)
+            throw new TransportClosedError(`SSE stream for \`${method}\` carried no JSON-RPC response`);
+        return last;
+    }
+    notify(method, params) {
+        void this.post({ jsonrpc: '2.0', method, ...(params !== undefined ? { params } : {}) }, method, 5000).catch(() => {
+            /* Notifications are fire-and-forget; a failure here is not a check result. */
+        });
+    }
+    writeRaw(text) {
+        void fetch(this.opts.url, { method: 'POST', headers: this.headers(), body: text }).catch(() => { });
+    }
+    isAlive() {
+        return !this.closed;
+    }
+    exitInfo() {
+        return null;
+    }
+    async close() {
+        this.closed = true;
+    }
+}

package/dist/client/index.d.ts

@@ -0,0 +1,47 @@
+import type { Transport } from './transport.js';
+import type { JsonRpcResponse } from './jsonrpc.js';
+import type { ToolDef } from '../types.js';
+export { StdioTransport } from './stdio.js';
+export { HttpTransport } from './http.js';
+export type { Transport } from './transport.js';
+/** Versions we will negotiate, newest first. */
+export declare const SUPPORTED_PROTOCOL_VERSIONS: string[];
+export interface HandshakeResult {
+    raw: JsonRpcResponse;
+    protocolVersion: string | null;
+    serverInfo: {
+        name?: string;
+        version?: string;
+    } | null;
+    capabilities: Record<string, unknown>;
+    ms: number;
+}
+/**
+ * A thin, unopinionated MCP client. It performs the handshake and exposes the
+ * few calls the checks need -- but never normalises or repairs a response,
+ * because the checks have to see exactly what the server sent.
+ */
+export declare class McpClient {
+    readonly transport: Transport;
+    private timeoutMs;
+    constructor(transport: Transport, timeoutMs?: number);
+    get target(): string;
+    start(): Promise<void>;
+    initialize(protocolVersion?: string): Promise<HandshakeResult>;
+    /** The spec requires this notification before any other request. */
+    notifyInitialized(): void;
+    call(method: string, params?: unknown, timeoutMs?: number): Promise<JsonRpcResponse>;
+    callRaw(payload: Record<string, unknown>, id: number | string, method: string, timeoutMs?: number): Promise<JsonRpcResponse>;
+    /** Walk `nextCursor` so a paginated server does not under-report. */
+    listAll(method: 'tools/list' | 'resources/list' | 'prompts/list', key: string): Promise<{
+        items: unknown[];
+        pages: number;
+        error?: JsonRpcResponse;
+    }>;
+    listTools(): Promise<{
+        tools: ToolDef[];
+        pages: number;
+        error?: JsonRpcResponse;
+    }>;
+    close(): Promise<void>;
+}

package/dist/client/index.js

@@ -0,0 +1,79 @@
+export { StdioTransport } from './stdio.js';
+export { HttpTransport } from './http.js';
+/** Versions we will negotiate, newest first. */
+export const SUPPORTED_PROTOCOL_VERSIONS = ['2025-06-18', '2025-03-26', '2024-11-05'];
+/**
+ * A thin, unopinionated MCP client. It performs the handshake and exposes the
+ * few calls the checks need -- but never normalises or repairs a response,
+ * because the checks have to see exactly what the server sent.
+ */
+export class McpClient {
+    transport;
+    timeoutMs;
+    constructor(transport, timeoutMs = 10_000) {
+        this.transport = transport;
+        this.timeoutMs = timeoutMs;
+    }
+    get target() {
+        return this.transport.target;
+    }
+    async start() {
+        await this.transport.start();
+    }
+    async initialize(protocolVersion = SUPPORTED_PROTOCOL_VERSIONS[0]) {
+        const t0 = Date.now();
+        const raw = await this.transport.request('initialize', {
+            protocolVersion,
+            capabilities: { roots: { listChanged: true }, sampling: {}, elicitation: {} },
+            clientInfo: { name: 'context-xray', version: '0.1.0' },
+        }, this.timeoutMs);
+        const ms = Date.now() - t0;
+        const result = (raw.result ?? {});
+        return {
+            raw,
+            ms,
+            protocolVersion: typeof result['protocolVersion'] === 'string' ? result['protocolVersion'] : null,
+            serverInfo: result['serverInfo'] ?? null,
+            capabilities: result['capabilities'] ?? {},
+        };
+    }
+    /** The spec requires this notification before any other request. */
+    notifyInitialized() {
+        this.transport.notify('notifications/initialized');
+    }
+    call(method, params, timeoutMs) {
+        return this.transport.request(method, params, timeoutMs ?? this.timeoutMs);
+    }
+    callRaw(payload, id, method, timeoutMs) {
+        return this.transport.requestRaw(payload, id, method, timeoutMs ?? this.timeoutMs);
+    }
+    /** Walk `nextCursor` so a paginated server does not under-report. */
+    async listAll(method, key) {
+        const items = [];
+        let cursor;
+        let pages = 0;
+        for (;;) {
+            const res = await this.call(method, cursor ? { cursor } : {});
+            if (res.error)
+                return { items, pages, error: res };
+            pages++;
+            const result = (res.result ?? {});
+            const batch = result[key];
+            if (Array.isArray(batch))
+                items.push(...batch);
+            const next = result['nextCursor'];
+            if (typeof next === 'string' && next && pages < 50)
+                cursor = next;
+            else
+                break;
+        }
+        return { items, pages };
+    }
+    async listTools() {
+        const { items, pages, error } = await this.listAll('tools/list', 'tools');
+        return { tools: items, pages, error };
+    }
+    close() {
+        return this.transport.close();
+    }
+}