mcpcost 0.0.0-stage → 0.2.0

package/dist/configs.js

@@ -0,0 +1,127 @@
+import { readFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import path from 'node:path';
+/** Expands ${VAR} and ${VAR:-default} the way Claude Code does in .mcp.json. */
+export function expand(value, env) {
+    return value.replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)(?::-([^}]*))?\}/g, (whole, name, fallback) => {
+        const v = env[name];
+        if (v !== undefined)
+            return v;
+        if (fallback !== undefined)
+            return fallback;
+        return whole;
+    });
+}
+function expandRecord(record, env) {
+    if (!record)
+        return undefined;
+    const out = {};
+    for (const [k, v] of Object.entries(record))
+        if (typeof v === 'string')
+            out[k] = expand(v, env);
+    return out;
+}
+function remoteType(raw, url) {
+    const t = String(raw.type ?? raw.transport ?? '').toLowerCase();
+    if (t === 'sse')
+        return 'sse';
+    if (t === 'http' || t === 'streamable-http' || t === 'streamablehttp' || t === 'streamable_http')
+        return 'streamable-http';
+    return /\/sse\/?$/.test(url) ? 'sse' : 'streamable-http';
+}
+/** Normalises one `{ name: {...} }` map of servers. Accepts the shapes Claude, Cursor, Windsurf and VS Code write. */
+export function normalizeServers(map, source, env = process.env) {
+    if (!map || typeof map !== 'object')
+        return [];
+    const out = [];
+    for (const [name, value] of Object.entries(map)) {
+        if (!value || typeof value !== 'object')
+            continue;
+        const raw = value;
+        const disabled = raw.disabled === true || raw.enabled === false;
+        const url = typeof raw.url === 'string' ? expand(raw.url, env) : typeof raw.serverUrl === 'string' ? expand(raw.serverUrl, env) : undefined;
+        if (url && String(raw.type ?? '').toLowerCase() !== 'stdio') {
+            out.push({ name, source, kind: 'remote', url, type: remoteType(raw, url), headers: expandRecord(raw.headers, env), disabled });
+            continue;
+        }
+        if (typeof raw.command === 'string') {
+            const args = Array.isArray(raw.args) ? raw.args.filter((a) => typeof a === 'string').map((a) => expand(a, env)) : [];
+            out.push({
+                name,
+                source,
+                kind: 'stdio',
+                command: expand(raw.command, env),
+                args,
+                env: expandRecord(raw.env, env),
+                cwd: typeof raw.cwd === 'string' ? expand(raw.cwd, env) : undefined,
+                disabled
+            });
+        }
+    }
+    return out;
+}
+async function readJson(file) {
+    try {
+        return JSON.parse(await readFile(file, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+/** Parses one config file of a known client. Returns null when the file is missing or not JSON. */
+export async function readConfigFile(file, client, options = {}) {
+    const env = options.env ?? process.env;
+    const json = await readJson(file);
+    if (!json)
+        return null;
+    const servers = [];
+    if (client === 'Claude Code (user)') {
+        servers.push(...normalizeServers(json.mcpServers, `${file} (user)`, env));
+        const projects = (json.projects ?? {});
+        const cwd = options.cwd ?? process.cwd();
+        for (const [projectPath, project] of Object.entries(projects)) {
+            if (projectPath === cwd || cwd.startsWith(projectPath.replace(/\/?$/, '/'))) {
+                servers.push(...normalizeServers(project.mcpServers, `${file} (project ${projectPath})`, env));
+            }
+        }
+    }
+    else if (json.servers && typeof json.servers === 'object') {
+        servers.push(...normalizeServers(json.servers, file, env));
+    }
+    else {
+        servers.push(...normalizeServers(json.mcpServers, file, env));
+    }
+    return { path: file, client, servers };
+}
+/** The places the common clients keep their MCP config. */
+export function knownConfigPaths(options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    const home = options.home ?? homedir();
+    const platform = options.platform ?? process.platform;
+    const env = options.env ?? process.env;
+    const desktop = platform === 'darwin'
+        ? path.join(home, 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json')
+        : platform === 'win32'
+            ? path.join(env.APPDATA ?? path.join(home, 'AppData', 'Roaming'), 'Claude', 'claude_desktop_config.json')
+            : path.join(home, '.config', 'Claude', 'claude_desktop_config.json');
+    return [
+        { path: path.join(cwd, '.mcp.json'), client: 'Claude Code (project)' },
+        { path: path.join(home, '.claude.json'), client: 'Claude Code (user)' },
+        { path: desktop, client: 'Claude Desktop' },
+        { path: path.join(cwd, '.cursor', 'mcp.json'), client: 'Cursor (project)' },
+        { path: path.join(home, '.cursor', 'mcp.json'), client: 'Cursor (user)' },
+        { path: path.join(cwd, '.vscode', 'mcp.json'), client: 'VS Code (workspace)' },
+        { path: path.join(home, '.codeium', 'windsurf', 'mcp_config.json'), client: 'Windsurf' },
+        { path: path.join(home, '.gemini', 'settings.json'), client: 'Gemini CLI' }
+    ];
+}
+/** Reads every known config file that exists. */
+export async function discoverConfigs(options = {}) {
+    const found = [];
+    for (const { path: file, client } of knownConfigPaths(options)) {
+        const cfg = await readConfigFile(file, client, options);
+        if (cfg)
+            found.push(cfg);
+    }
+    return found;
+}

package/dist/core.d.ts

@@ -0,0 +1,34 @@
+import type { Transport } from '@modelcontextprotocol/sdk/shared/transport.js';
+import type { ProbeResult, ProbeStatus, RemoteTransport } from './types.js';
+export declare const VERSION = "0.2.0";
+export declare const USER_AGENT = "mcpcost/0.2.0 (mcpcost; +https://github.com/ondraulehla/mcpcost)";
+export interface RawTool {
+    name: string;
+    description?: string;
+    inputSchema?: unknown;
+}
+export interface CoreOptions {
+    /** Timeout for the whole probe and for each request. Default 15 000 ms. */
+    timeoutMs?: number;
+    /** Extra request headers, for example an Authorization header from your config. */
+    headers?: Record<string, string>;
+    fetch?: typeof fetch;
+}
+export interface RawProbe {
+    result: ProbeResult;
+    tools: RawTool[];
+}
+interface Observed {
+    status: number;
+    headers: Headers;
+    url: string;
+}
+export declare function emptyResult(url: string, transport: ProbeResult['transport']): ProbeResult;
+/** Connects to a remote MCP server and lists its tools. No token counting. */
+export declare function probeRemoteRaw(remote: {
+    url: string;
+    type: RemoteTransport;
+}, options?: CoreOptions): Promise<RawProbe>;
+export declare function measure(transport: Transport, result: ProbeResult, timeoutMs: number): Promise<RawTool[]>;
+export declare function classify(message: string | undefined, first: Observed | undefined): ProbeStatus;
+export {};

package/dist/core.js

@@ -0,0 +1,162 @@
+/**
+ * The transport-level probe without token counting. The board's Worker imports
+ * this file, so it must not pull in the tokenizer (its tables take CPU to load).
+ * probe.ts and stdio.ts add the token costs on top.
+ */
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
+export const VERSION = '0.2.0';
+export const USER_AGENT = `mcpcost/${VERSION} (mcpcost; +https://github.com/ondraulehla/mcpcost)`;
+export function emptyResult(url, transport) {
+    return { url, transport, probedAt: new Date().toISOString(), status: 'error', latencyMs: {} };
+}
+/** Connects to a remote MCP server and lists its tools. No token counting. */
+export async function probeRemoteRaw(remote, options = {}) {
+    const timeoutMs = options.timeoutMs ?? 15_000;
+    const baseFetch = options.fetch ?? fetch;
+    const result = emptyResult(remote.url, remote.type);
+    let url;
+    try {
+        url = new URL(remote.url);
+    }
+    catch {
+        result.error = 'invalid URL';
+        return { result, tools: [] };
+    }
+    let first;
+    const observingFetch = async (input, init) => {
+        // The probe needs no server-initiated messages. Answering 405 to the standalone
+        // GET makes the SDK skip that stream, which otherwise stalls tools/list on some
+        // servers (DeepWiki held it for 15 s and never answered the POST meanwhile).
+        if (remote.type !== 'sse' && (init?.method ?? 'GET') === 'GET') {
+            return new Response(null, { status: 405 });
+        }
+        const signal = init?.signal
+            ? AbortSignal.any([init.signal, AbortSignal.timeout(timeoutMs)])
+            : AbortSignal.timeout(timeoutMs);
+        const headers = new Headers(init?.headers);
+        headers.set('user-agent', USER_AGENT);
+        const res = await baseFetch(input, { ...init, headers, signal });
+        first ??= { status: res.status, headers: res.headers, url: String(input instanceof Request ? input.url : input) };
+        return res;
+    };
+    // Follow redirects across origins too: a server that moved should be measured where it lives.
+    const requestInit = { headers: options.headers };
+    const transport = remote.type === 'sse'
+        ? new SSEClientTransport(url, { fetch: observingFetch, requestInit, redirectPolicy: 'follow' })
+        : new StreamableHTTPClientTransport(url, { fetch: observingFetch, requestInit, redirectPolicy: 'follow' });
+    const tools = await measure(transport, result, timeoutMs);
+    if (result.status === 'ok') {
+        result.httpStatus = first?.status;
+    }
+    else {
+        result.status = classify(result.error, first);
+        if (first) {
+            result.httpStatus = first.status;
+            const www = first.headers.get('www-authenticate');
+            if (www) {
+                result.authScheme = www.split(/[\s,]/)[0];
+                const m = /resource_metadata="([^"]+)"/i.exec(www);
+                if (m)
+                    result.authResourceMetadata = m[1];
+            }
+        }
+    }
+    return { result, tools };
+}
+/** The part every transport shares: initialize, read the server info, list the tools. */
+/**
+ * The probe never calls a tool, so it never validates a tool result. A no-op
+ * validator skips the SDK's default, which compiles schemas with new Function
+ * and is refused inside Cloudflare Workers.
+ */
+const noValidation = {
+    getValidator() {
+        return (input) => ({ valid: true, data: input, errorMessage: undefined });
+    }
+};
+export async function measure(transport, result, timeoutMs) {
+    const client = new Client({ name: 'mcpcost', version: VERSION }, { capabilities: {}, jsonSchemaValidator: noValidation });
+    let timer;
+    const deadline = new Promise((_, reject) => {
+        timer = setTimeout(() => reject(Object.assign(new Error(`probe timed out after ${timeoutMs} ms`), { name: 'TimeoutError' })), timeoutMs);
+        timer.unref?.();
+    });
+    const tools = [];
+    try {
+        const t0 = performance.now();
+        await Promise.race([client.connect(transport, { timeout: timeoutMs }), deadline]);
+        result.latencyMs.initialize = Math.round(performance.now() - t0);
+        const info = client.getServerVersion();
+        if (info)
+            result.serverInfo = { name: info.name, version: info.version, title: info.title };
+        const caps = client.getServerCapabilities() ?? {};
+        result.capabilities = Object.keys(caps).sort();
+        result.instructionsChars = client.getInstructions()?.length ?? 0;
+        result.protocolVersion = transport.protocolVersion;
+        if (caps.tools) {
+            let cursor;
+            const t1 = performance.now();
+            do {
+                const page = await Promise.race([client.listTools(cursor ? { cursor } : undefined, { timeout: timeoutMs }), deadline]);
+                tools.push(...page.tools);
+                cursor = page.nextCursor;
+            } while (cursor && tools.length < 2_000);
+            result.latencyMs.toolsList = Math.round(performance.now() - t1);
+        }
+        result.toolCount = tools.length;
+        result.status = 'ok';
+    }
+    catch (err) {
+        const e = err;
+        result.error = [e?.message ?? String(err), e?.cause?.message, e?.cause?.code].filter(Boolean).join(' | ').slice(0, 400);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+        await client.close().catch(() => undefined);
+    }
+    return tools;
+}
+export function classify(message, first) {
+    const text = message ?? '';
+    // The server speaks a protocol version that this SDK does not support yet.
+    if (/protocol version is not supported/i.test(text))
+        return 'newer_protocol';
+    if (first) {
+        if (first.status === 401 || first.status === 403)
+            return 'auth';
+        if (first.status === 402)
+            return 'payment';
+        if (first.status === 404 || first.status === 405 || first.status === 410)
+            return 'not_found';
+        if (first.status === 429)
+            return 'rate_limited';
+        // Inside Cloudflare Workers a failed origin fetch comes back as a 52x/530 page.
+        if (first.status === 530 || /error code: 10(00|16)/.test(text))
+            return 'dns';
+        if (first.status === 522 || first.status === 524)
+            return 'timeout';
+        if (first.status === 521 || first.status === 523)
+            return 'refused';
+        if (first.status === 525 || first.status === 526)
+            return 'tls';
+        if (first.status >= 500)
+            return 'server_error';
+        if (first.status >= 200 && first.status < 300) {
+            if (/timed? ?out|TimeoutError/i.test(text))
+                return 'timeout';
+            return 'protocol_error';
+        }
+    }
+    if (/timed? ?out|TimeoutError|UND_ERR_CONNECT_TIMEOUT|UND_ERR_HEADERS_TIMEOUT/i.test(text))
+        return 'timeout';
+    if (/ENOTFOUND|EAI_AGAIN|getaddrinfo/i.test(text))
+        return 'dns';
+    if (/CERT_|certificate|TLS|SSL|ERR_TLS/i.test(text))
+        return 'tls';
+    if (/ECONNREFUSED|ECONNRESET|EHOSTUNREACH|ENETUNREACH|UND_ERR_SOCKET/i.test(text))
+        return 'refused';
+    return 'error';
+}

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+export { fetchRegistry, primaryRemote, hostOf, REGISTRY_URL } from './registry.js';
+export { probeRemote, USER_AGENT, VERSION } from './probe.js';
+export type { ProbeOptions, ClaudeOptions } from './probe.js';
+export { probeStdio, probeStdioRaw } from './stdio.js';
+export { measure, emptyResult } from './core.js';
+export type { RawTool } from './core.js';
+export type { StdioTarget } from './stdio.js';
+export { discoverConfigs, readConfigFile, normalizeServers, knownConfigPaths, expand } from './configs.js';
+export type { ConfiguredServer, ConfigFile, DiscoverOptions } from './configs.js';
+export { toolCost, toolsCost, toolPayload, countTokens, TOKENIZER } from './tokens.js';
+export type { ToolLike } from './tokens.js';
+export { countClaudeTokens, countForServer, claudeCodePrefix, toApiTools, createLimiter, ClaudeCountError, CLAUDE_MODEL } from './claude.js';
+export type { ClaudeCountOptions, ClaudeCount, Limiter } from './claude.js';
+export type * from './types.js';
+export { GATED_STATUSES } from './types.js';
+export { buildServer } from './mcp.js';

package/dist/index.js

@@ -0,0 +1,9 @@
+export { fetchRegistry, primaryRemote, hostOf, REGISTRY_URL } from './registry.js';
+export { probeRemote, USER_AGENT, VERSION } from './probe.js';
+export { probeStdio, probeStdioRaw } from './stdio.js';
+export { measure, emptyResult } from './core.js';
+export { discoverConfigs, readConfigFile, normalizeServers, knownConfigPaths, expand } from './configs.js';
+export { toolCost, toolsCost, toolPayload, countTokens, TOKENIZER } from './tokens.js';
+export { countClaudeTokens, countForServer, claudeCodePrefix, toApiTools, createLimiter, ClaudeCountError, CLAUDE_MODEL } from './claude.js';
+export { GATED_STATUSES } from './types.js';
+export { buildServer } from './mcp.js';

package/dist/mcp.d.ts

@@ -0,0 +1,10 @@
+/**
+ * mcpcost as an MCP server over stdio: the same measurements as the CLI, for
+ * an agent that wants to know what a server costs before it is added to a
+ * config. Two tools work offline (they probe the server themselves); two ask
+ * the public board for registry data.
+ */
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+export declare function buildServer(): Server;
+/** Serves the tools over stdio until the client closes the pipe. */
+export declare function serveStdio(): Promise<void>;

package/dist/mcp.js

@@ -0,0 +1,173 @@
+/**
+ * mcpcost as an MCP server over stdio: the same measurements as the CLI, for
+ * an agent that wants to know what a server costs before it is added to a
+ * config. Two tools work offline (they probe the server themselves); two ask
+ * the public board for registry data.
+ */
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { VERSION, probeRemote } from './probe.js';
+import { probeStdio } from './stdio.js';
+import { readConfigFile } from './configs.js';
+const BOARD = 'https://mcpcost.ulehla.dev';
+function compact(r, window) {
+    return {
+        status: r.status,
+        error: r.error,
+        protocolVersion: r.protocolVersion,
+        serverInfo: r.serverInfo,
+        toolCount: r.toolCount,
+        toolsTokensEstimate: r.toolsTokens,
+        claudeTokens: r.claude?.tokens,
+        claudeTokensClaudeCode: r.claude?.tokensClaudeCode,
+        claudeError: r.claude?.error,
+        shareOfWindow: r.toolsTokens != null ? Number((((r.claude?.tokens ?? r.toolsTokens) / window) * 100).toFixed(2)) : undefined,
+        latencyMs: r.latencyMs,
+        topTools: r.tools ? [...r.tools].sort((a, b) => b.tokens - a.tokens).slice(0, 10).map((t) => ({ name: t.name, tokens: t.tokens })) : undefined
+    };
+}
+const claudeOptions = (serverName) => (process.env.ANTHROPIC_API_KEY ? { apiKey: process.env.ANTHROPIC_API_KEY, serverName } : undefined);
+const text = (value) => ({ content: [{ type: 'text', text: JSON.stringify(value, null, 2) }], structuredContent: value });
+const TOOLS = [
+    {
+        name: 'measure_server',
+        title: 'Measure one server',
+        description: 'Starts or connects to one MCP server, lists its tools and reports the result, the protocol version and the token cost of its tool definitions. Give either a remote URL or a local command.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                url: { type: 'string', description: 'Remote endpoint, https://…/mcp or an SSE URL' },
+                command: { type: 'string', description: 'Local server command with its arguments, for example "npx -y @modelcontextprotocol/server-filesystem /tmp"' },
+                window: { type: 'integer', minimum: 1, description: 'Context window for the share, default 200000' }
+            }
+        }
+    },
+    {
+        name: 'measure_config',
+        title: 'Measure a config file',
+        description: 'Measures every server in an MCP config file (.mcp.json, Claude Desktop, Cursor, VS Code or Windsurf format): starts each one the way the client would and reports tokens per server and in total.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                path: { type: 'string', description: 'Path to the config file' },
+                window: { type: 'integer', minimum: 1 },
+                noStdio: { type: 'boolean', description: 'Measure remote servers only, do not start local ones' }
+            },
+            required: ['path']
+        }
+    },
+    {
+        name: 'lookup_server',
+        title: 'Look up a registry server on the board',
+        description: 'Latest daily probe of a server in the official MCP registry: status, exact token cost in Claude, tool count, latency, history. Accepts the registry name (io.github.owner/name) or the server URL.',
+        inputSchema: { type: 'object', properties: { nameOrUrl: { type: 'string' } }, required: ['nameOrUrl'] }
+    },
+    {
+        name: 'search_servers',
+        title: 'Search the board',
+        description: 'Finds registry servers by words in their name, title, description or host, sorted by exact Claude token cost by default. Twenty per page.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: { type: 'string' },
+                status: { type: 'string', enum: ['ok', 'auth', 'payment', 'newer_protocol', 'down'] },
+                sort: { type: 'string', enum: ['claude', 'claude-asc', 'tokens', 'tools', 'latency', 'name', 'updated'] },
+                page: { type: 'integer', minimum: 1, maximum: 20 }
+            }
+        }
+    }
+];
+const str = (a, k) => (typeof a[k] === 'string' ? a[k] : undefined);
+const num = (a, k) => (typeof a[k] === 'number' ? a[k] : undefined);
+const fail = (message) => ({ content: [{ type: 'text', text: message }], isError: true });
+async function call(name, a) {
+    const w = num(a, 'window') ?? 200_000;
+    switch (name) {
+        case 'measure_server': {
+            const url = str(a, 'url');
+            const command = str(a, 'command');
+            if (url) {
+                const r = await probeRemote({ url, type: /\/sse\/?$/.test(url) ? 'sse' : 'streamable-http' }, { timeoutMs: 15_000, claude: claudeOptions(new URL(url).hostname) });
+                return text({ target: url, ...compact(r, w) });
+            }
+            if (command) {
+                const [cmd, ...args] = command.trim().split(/\s+/);
+                const r = await probeStdio({ command: cmd, args }, { timeoutMs: 20_000, claude: claudeOptions(cmd) });
+                return text({ target: command, ...compact(r, w) });
+            }
+            return fail('Give url or command.');
+        }
+        case 'measure_config': {
+            const path = str(a, 'path');
+            if (!path)
+                return fail('Give path.');
+            const cfg = await readConfigFile(path, 'config');
+            if (!cfg)
+                return fail(`Cannot read ${path}`);
+            const noStdio = a.noStdio === true;
+            const servers = await Promise.all(cfg.servers.map(async (s) => {
+                if (s.disabled)
+                    return { name: s.name, skipped: 'disabled in config' };
+                if (s.kind === 'stdio' && noStdio)
+                    return { name: s.name, skipped: 'local server, noStdio' };
+                const r = s.kind === 'remote'
+                    ? await probeRemote({ url: s.url, type: s.type ?? 'streamable-http' }, { timeoutMs: 15_000, headers: s.headers, claude: claudeOptions(s.name) })
+                    : await probeStdio({ command: s.command, args: s.args, env: s.env, cwd: s.cwd }, { timeoutMs: 20_000, claude: claudeOptions(s.name) });
+                return { name: s.name, kind: s.kind, ...compact(r, w) };
+            }));
+            const measured = servers.filter((s) => 'status' in s && s.status === 'ok');
+            const total = measured.reduce((t, s) => t + (s.claudeTokens ?? s.toolsTokensEstimate ?? 0), 0);
+            return text({ path, total: { servers: measured.length, tokens: total, shareOfWindow: Number(((total / w) * 100).toFixed(2)) }, servers });
+        }
+        case 'lookup_server': {
+            const nameOrUrl = str(a, 'nameOrUrl');
+            if (!nameOrUrl)
+                return fail('Give nameOrUrl.');
+            const url = /^https?:\/\//.test(nameOrUrl) ? `${BOARD}/api/check.json?url=${encodeURIComponent(nameOrUrl)}` : `${BOARD}/api/s/${nameOrUrl}.json`;
+            const res = await fetch(url, { headers: { accept: 'application/json', 'user-agent': `mcpcost/${VERSION}` } });
+            if (!res.ok)
+                return fail(`The board has no server ${nameOrUrl} (HTTP ${res.status}). Use measure_server to probe it now.`);
+            return text(await res.json());
+        }
+        case 'search_servers': {
+            const u = new URL(`${BOARD}/api/servers.json`);
+            const query = str(a, 'query');
+            if (query)
+                u.searchParams.set('q', query);
+            const status = str(a, 'status');
+            if (status)
+                u.searchParams.set('status', status);
+            u.searchParams.set('sort', str(a, 'sort') ?? 'claude');
+            u.searchParams.set('page', String(num(a, 'page') ?? 1));
+            u.searchParams.set('per_page', '20');
+            const res = await fetch(u, { headers: { accept: 'application/json', 'user-agent': `mcpcost/${VERSION}` } });
+            if (!res.ok)
+                return fail(`The board did not answer (HTTP ${res.status}).`);
+            return text(await res.json());
+        }
+        default:
+            return fail(`Unknown tool ${name}`);
+    }
+}
+export function buildServer() {
+    const server = new Server({ name: 'mcpcost', version: VERSION }, {
+        capabilities: { tools: {} },
+        instructions: 'Measures what MCP servers cost in context tokens. measure_server probes one server (remote URL or local command) now. measure_config measures every server in a config file. lookup_server and search_servers read the public board at mcpcost.ulehla.dev, which probes the whole registry daily. Token numbers are o200k_base estimates; with ANTHROPIC_API_KEY set, claudeTokens is the exact count from the free count_tokens endpoint.'
+    });
+    server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOLS.map((t) => ({ ...t })) }));
+    server.setRequestHandler(CallToolRequestSchema, async (req) => {
+        try {
+            return await call(req.params.name, (req.params.arguments ?? {}));
+        }
+        catch (e) {
+            return fail(e instanceof Error ? e.message : String(e));
+        }
+    });
+    return server;
+}
+/** Serves the tools over stdio until the client closes the pipe. */
+export async function serveStdio() {
+    const server = buildServer();
+    await server.connect(new StdioServerTransport());
+}

package/dist/payload.d.ts

@@ -0,0 +1,16 @@
+/** The shape a tool takes when a client hands it to a model. No tokenizer here, so the Worker can import it. */
+export interface ToolLike {
+    name: string;
+    description?: string;
+    inputSchema?: unknown;
+    outputSchema?: unknown;
+}
+/**
+ * Serialises a tool the way a client sends it to a model: name, description and
+ * input schema, as compact JSON. Different clients wrap this differently, so the
+ * count is an estimate, and it is the same estimate for every server.
+ */
+export declare function toolPayload(tool: ToolLike): string;
+export declare function payloadBytes(tool: ToolLike): number;
+/** Median bytes per token over 12 968 measured servers (p10 4.03, p90 4.62). For estimates without the tokenizer. */
+export declare const BYTES_PER_TOKEN = 4.42;

package/dist/payload.js

@@ -0,0 +1,17 @@
+/**
+ * Serialises a tool the way a client sends it to a model: name, description and
+ * input schema, as compact JSON. Different clients wrap this differently, so the
+ * count is an estimate, and it is the same estimate for every server.
+ */
+export function toolPayload(tool) {
+    return JSON.stringify({
+        name: tool.name,
+        description: tool.description ?? '',
+        input_schema: tool.inputSchema ?? { type: 'object' }
+    });
+}
+export function payloadBytes(tool) {
+    return new TextEncoder().encode(toolPayload(tool)).length;
+}
+/** Median bytes per token over 12 968 measured servers (p10 4.03, p90 4.62). For estimates without the tokenizer. */
+export const BYTES_PER_TOKEN = 4.42;

package/dist/probe.d.ts

@@ -0,0 +1,27 @@
+import { type CoreOptions, type RawTool } from './core.js';
+import type { ProbeResult, RemoteTransport } from './types.js';
+export { VERSION, USER_AGENT, emptyResult, measure, classify } from './core.js';
+export type { RawTool, RawProbe } from './core.js';
+export interface ClaudeOptions {
+    /** Anthropic API key. Only the free count_tokens endpoint is called. */
+    apiKey: string;
+    /** Model id. Default claude-opus-5-5. */
+    model?: string;
+    /** The server key in the client config, for the Claude Code mcp__<server>__ prefix. Default: the host or the command. */
+    serverName?: string;
+}
+export interface ProbeOptions extends CoreOptions {
+    /** Keep the per-tool list in the result. Default true. */
+    includeTools?: boolean;
+    /** Also ask the Anthropic count_tokens endpoint for the exact count. */
+    claude?: ClaudeOptions;
+}
+/** Adds the exact Claude count to an alive result. A refused schema becomes `claude.error`; a transport failure leaves `claude` empty. */
+export declare function attachClaude(result: ProbeResult, tools: RawTool[], claude: ClaudeOptions | undefined): Promise<ProbeResult>;
+/** Adds the token cost of the listed tools to a probe result. */
+export declare function priceTools(result: ProbeResult, tools: RawTool[], includeTools?: boolean): ProbeResult;
+/** Connects to a remote MCP server, lists its tools and measures what it costs. */
+export declare function probeRemote(remote: {
+    url: string;
+    type: RemoteTransport;
+}, options?: ProbeOptions): Promise<ProbeResult>;

package/dist/probe.js

@@ -0,0 +1,39 @@
+import { probeRemoteRaw } from './core.js';
+import { toolsCost } from './tokens.js';
+import { countForServer, ClaudeCountError, CLAUDE_MODEL } from './claude.js';
+export { VERSION, USER_AGENT, emptyResult, measure, classify } from './core.js';
+/** Adds the exact Claude count to an alive result. A refused schema becomes `claude.error`; a transport failure leaves `claude` empty. */
+export async function attachClaude(result, tools, claude) {
+    if (!claude || result.status !== 'ok')
+        return result;
+    const measuredAt = new Date().toISOString();
+    const serverName = claude.serverName ?? result.url.replace(/^stdio:/, '').replace(/^https?:\/\//, '').split(/[/\s]/)[0];
+    try {
+        const c = await countForServer(tools, serverName, { apiKey: claude.apiKey, model: claude.model });
+        result.claude = { model: c.model, tokens: c.tokens, tokensClaudeCode: c.tokensClaudeCode, measuredAt };
+    }
+    catch (e) {
+        const message = e instanceof Error ? e.message : String(e);
+        if (e instanceof ClaudeCountError && e.status >= 400 && e.status < 500 && e.status !== 429)
+            result.claude = { model: claude.model ?? CLAUDE_MODEL, measuredAt, error: message };
+    }
+    return result;
+}
+/** Adds the token cost of the listed tools to a probe result. */
+export function priceTools(result, tools, includeTools = true) {
+    if (result.status !== 'ok')
+        return result;
+    const cost = toolsCost(tools);
+    result.toolCount = tools.length;
+    result.toolsTokens = cost.tokens;
+    result.toolsBytes = cost.bytes;
+    if (includeTools)
+        result.tools = cost.tools;
+    return result;
+}
+/** Connects to a remote MCP server, lists its tools and measures what it costs. */
+export async function probeRemote(remote, options = {}) {
+    const { result, tools } = await probeRemoteRaw(remote, options);
+    priceTools(result, tools, options.includeTools ?? true);
+    return attachClaude(result, tools, options.claude);
+}

package/dist/registry.d.ts

@@ -0,0 +1,17 @@
+import type { RegistryEntry, RegistryRemote } from './types.js';
+export declare const REGISTRY_URL = "https://registry.modelcontextprotocol.io/v0/servers";
+export interface FetchRegistryOptions {
+    /** Only the latest version of each server. Default true. */
+    latest?: boolean;
+    /** Page size, max 100. */
+    limit?: number;
+    /** Stop after this many entries (for tests and samples). */
+    max?: number;
+    fetch?: typeof fetch;
+    onPage?: (loaded: number) => void;
+}
+/** Downloads the registry listing page by page. */
+export declare function fetchRegistry(options?: FetchRegistryOptions): Promise<RegistryEntry[]>;
+/** Picks the remote endpoint to probe: streamable-http first, then sse. */
+export declare function primaryRemote(entry: RegistryEntry): RegistryRemote | undefined;
+export declare function hostOf(url: string): string;