@wrongstack/mcp 1.0.17 → 1.0.24

package/dist/client-capabilities.d.ts

@@ -0,0 +1,15 @@
+import type { MCPPageOptions, MCPRequestOptions } from './client-types.js';
+import { type MCPGetPromptResult, type MCPListPromptsResult, type MCPListResourcesResult, type MCPListResourceTemplatesResult, type MCPReadResourceResult } from './protocol.js';
+export declare class MCPCapabilityClient {
+    private readonly requestCapability;
+    private readonly requireResourceSubscriptions;
+    constructor(requestCapability: <T>(capability: 'resources' | 'prompts', method: string, params: unknown, parse: (value: unknown) => T, opts: MCPRequestOptions) => Promise<T>, requireResourceSubscriptions: (method: string) => void);
+    listResources(opts?: MCPPageOptions): Promise<MCPListResourcesResult>;
+    listResourceTemplates(opts?: MCPPageOptions): Promise<MCPListResourceTemplatesResult>;
+    readResource(uri: string, opts?: MCPRequestOptions): Promise<MCPReadResourceResult>;
+    subscribeResource(uri: string, opts?: MCPRequestOptions): Promise<void>;
+    unsubscribeResource(uri: string, opts?: MCPRequestOptions): Promise<void>;
+    listPrompts(opts?: MCPPageOptions): Promise<MCPListPromptsResult>;
+    getPrompt(name: string, args?: Record<string, string> | undefined, opts?: MCPRequestOptions): Promise<MCPGetPromptResult>;
+}
+//# sourceMappingURL=client-capabilities.d.ts.map

package/dist/client-process.d.ts

@@ -1,4 +1,10 @@
 import { type ChildProcess } from 'node:child_process';
+/** Resolve an HTTP Bearer token without ever persisting the secret itself. */
+export declare function resolveHttpBearerHeaders(options: {
+    headers?: Record<string, string> | undefined;
+    bearerTokenEnv?: string | undefined;
+    name: string;
+}, env?: NodeJS.ProcessEnv): Record<string, string> | undefined;
 /**
  * Force-kill a child and its descendants. On Windows a stdio server is launched
  * through a `.cmd` shim with `shell: true`, so `child` is the `cmd.exe` wrapper

package/dist/client-types.d.ts

@@ -0,0 +1,62 @@
+import type { MCPAuthorizationProvider } from './authorization.js';
+import type { MCPTool } from './contracts.js';
+export type Transport = 'stdio' | 'sse' | 'streamable-http';
+export interface MCPClientOptions {
+    name: string;
+    transport: Transport;
+    command?: string | undefined;
+    args?: string[] | undefined;
+    env?: Record<string, string> | undefined;
+    url?: string | undefined;
+    headers?: Record<string, string> | undefined;
+    /** Resolve an HTTP Bearer token from this environment variable at connect time. */
+    bearerTokenEnv?: string | undefined;
+    startupTimeoutMs?: number | undefined;
+    requestTimeoutMs?: number | undefined;
+    /**
+     * Working directory for a stdio server process. Presets address the project
+     * as `--project-root .` / `server-filesystem .`, which resolve against the
+     * spawn cwd — without this the child inherited WrongStack's PROCESS cwd, so
+     * a host serving a project from elsewhere (WebUI, ACP sessions with their
+     * own cwd) pointed those servers at the wrong directory.
+     */
+    cwd?: string | undefined;
+    /** Host-owned, vault-backed authorization for HTTP transports. */
+    authorizationProvider?: MCPAuthorizationProvider | undefined;
+    /**
+     * Allowlist of env var names to forward from the parent process (process.env)
+     * to the child. Values are resolved at spawn time and merged into `env`
+     * via the `extra` path of `buildChildEnv` (unfiltered). This is how built-in
+     * MCP server presets (GitHub, Slack, Brave Search, …) get their API tokens
+     * without storing them in config.json or being scrubbed by the secret filter.
+     */
+    passthroughEnv?: string[] | undefined;
+    /**
+     * Resolution-bound private-network policy for HTTP transports. Default:
+     * private/LAN targets are blocked at dial time (DNS-rebinding safe); the
+     * flag opts this server in. See MCPServerConfig.allowPrivateNetworks.
+     */
+    allowPrivateNetworks?: boolean | undefined;
+}
+export interface MCPRequestOptions {
+    signal?: AbortSignal | undefined;
+}
+export interface MCPPageOptions extends MCPRequestOptions {
+    cursor?: string | undefined;
+}
+export interface JsonRpcRequest {
+    jsonrpc: '2.0';
+    id: number;
+    method: string;
+    params?: unknown | undefined;
+}
+export type JsonRpcServerRequest = {
+    jsonrpc: '2.0';
+    id: number | string;
+    method: string;
+    params?: unknown | undefined;
+};
+export type ExitListener = (name: string, code: number | null, signal: string | null) => void;
+export type ToolsChangedListener = (name: string, tools: MCPTool[]) => void;
+export type MCPListChangedListener = (name: string) => void;
+//# sourceMappingURL=client-types.d.ts.map

package/dist/client.d.ts

@@ -1,56 +1,12 @@
-import type { MCPAuthorizationProvider } from './authorization.js';
+import type { ExitListener, MCPClientOptions, MCPListChangedListener, MCPPageOptions, MCPRequestOptions, ToolsChangedListener } from './client-types.js';
+import type { ConnectionState, JsonRpcResponse, MCPTool, ToolCallResult } from './contracts.js';
 import { type MCPGetPromptResult, type MCPListPromptsResult, type MCPListResourcesResult, type MCPListResourceTemplatesResult, type MCPReadResourceResult, type MCPServerMetadata } from './protocol.js';
 export { forceKillTree } from './client-process.js';
 export { quoteWindowsArg } from './client-protocol-helpers.js';
-export type Transport = 'stdio' | 'sse' | 'streamable-http';
-export interface MCPClientOptions {
-    name: string;
-    transport: Transport;
-    command?: string | undefined;
-    args?: string[] | undefined;
-    env?: Record<string, string> | undefined;
-    url?: string | undefined;
-    headers?: Record<string, string> | undefined;
-    startupTimeoutMs?: number | undefined;
-    requestTimeoutMs?: number | undefined;
-    /**
-     * Working directory for a stdio server process. Presets address the project
-     * as `--project-root .` / `server-filesystem .`, which resolve against the
-     * spawn cwd — without this the child inherited WrongStack's PROCESS cwd, so
-     * a host serving a project from elsewhere (WebUI, ACP sessions with their
-     * own cwd) pointed those servers at the wrong directory.
-     */
-    cwd?: string | undefined;
-    /** Host-owned, vault-backed authorization for HTTP transports. */
-    authorizationProvider?: MCPAuthorizationProvider | undefined;
-    /**
-     * Allowlist of env var names to forward from the parent process (process.env)
-     * to the child. Values are resolved at spawn time and merged into `env`
-     * via the `extra` path of `buildChildEnv` (unfiltered). This is how built-in
-     * MCP server presets (GitHub, Slack, Brave Search, …) get their API tokens
-     * without storing them in config.json or being scrubbed by the secret filter.
-     */
-    passthroughEnv?: string[] | undefined;
-    /**
-     * Resolution-bound private-network policy for HTTP transports. Default:
-     * private/LAN targets are blocked at dial time (DNS-rebinding safe); the
-     * flag opts this server in. See MCPServerConfig.allowPrivateNetworks.
-     */
-    allowPrivateNetworks?: boolean | undefined;
-}
-import type { ConnectionState, JsonRpcResponse, MCPTool, ToolCallResult } from './contracts.js';
 export type { ConnectionState, JsonRpcResponse, MCPTool, ToolCallResult };
-export interface MCPRequestOptions {
-    signal?: AbortSignal | undefined;
-}
-export interface MCPPageOptions extends MCPRequestOptions {
-    cursor?: string | undefined;
-}
-type ExitListener = (name: string, code: number | null, signal: string | null) => void;
-type ToolsChangedListener = (name: string, tools: MCPTool[]) => void;
-export type MCPListChangedListener = (name: string) => void;
 export declare class MCPClient {
     readonly opts: MCPClientOptions;
+    private readonly capabilityClient;
     /**
      * Maximum bytes the rx buffer may accumulate before the connection is
      * forcefully closed. A well-behaved JSON-RPC server emits newline-delimited
@@ -161,4 +117,5 @@ export declare class MCPClient {
     removePromptsChangedListener(listener: MCPListChangedListener): void;
     private emitCapabilityChanged;
 }
+export type { MCPClientOptions, MCPListChangedListener, MCPPageOptions, MCPRequestOptions, Transport, } from './client-types.js';
 //# sourceMappingURL=client.d.ts.map

package/dist/index.js

@@ -831,40 +831,6 @@ import { spawn as spawn2 } from "node:child_process";
 import { StringDecoder } from "node:string_decoder";
 import { buildChildEnv as buildChildEnv2, buildWin32CmdShimInvocation, toErrorMessage } from "@wrongstack/core/utils";
 
-// src/client-process.ts
-import { spawn } from "node:child_process";
-import { buildChildEnv } from "@wrongstack/core/utils";
-function forceKillTree(child) {
-  if (child.pid === void 0) {
-    try {
-      child.kill("SIGKILL");
-    } catch {
-    }
-    return;
-  }
-  if (process.platform === "win32") {
-    const killer = spawn("taskkill", ["/pid", String(child.pid), "/T", "/F"], {
-      stdio: "ignore",
-      // H-8 convention (spawn-convention test): taskkill needs PATH only —
-      // do not hand it the credential-bearing parent environment.
-      env: buildChildEnv(),
-      windowsHide: true
-    });
-    killer.once("error", () => {
-      try {
-        child.kill("SIGKILL");
-      } catch {
-      }
-    });
-    killer.unref();
-    return;
-  }
-  try {
-    child.kill("SIGKILL");
-  } catch {
-  }
-}
-
 // src/client-protocol-helpers.ts
 var MAX_PROTOCOL_INPUT_CHARS = 8192;
 function validateProtocolString(value, label, allowEmpty = false) {
@@ -886,57 +852,6 @@ function parseEmptyResult(value) {
   }
 }
 
-// src/constants.ts
-var SUPPORTED_PROTOCOL_VERSIONS = Object.freeze(["2024-11-05"]);
-function negotiateProtocolVersion(requested) {
-  if (typeof requested === "string" && SUPPORTED_PROTOCOL_VERSIONS.includes(requested)) {
-    return requested;
-  }
-  return MCP_CONSTANTS.PROTOCOL_VERSION;
-}
-var MCP_CONSTANTS = Object.freeze({
-  /** MCP protocol version advertised during handshake: the newest we implement. */
-  PROTOCOL_VERSION: SUPPORTED_PROTOCOL_VERSIONS[0],
-  /** Identity announced to MCP servers during `initialize`. */
-  CLIENT_INFO: Object.freeze({
-    name: "wrongstack",
-    version: "0.1.10"
-  }),
-  /** Reconnection behaviour when a transport disconnects. */
-  RECONNECT: Object.freeze({
-    /** Max full reconnect cycles before the slot is marked `failed`. */
-    MAX_CYCLES: 5,
-    /** Base delay between cycles (exponential backoff applied on top). */
-    BASE_DELAY_MS: 1e3,
-    /** Jitter factor applied to the backoff (0 = no jitter, 1 = full). */
-    JITTER_FACTOR: 0.2,
-    /** Max connection attempts within a single cycle. */
-    MAX_ATTEMPTS: 3,
-    /** Base multiplier for the exponential backoff formula (`delay = BASE * multiplier^attempt`). */
-    BACKOFF_MULTIPLIER: 2
-  }),
-  /** Timing for graceful / forced disconnect. */
-  DISCONNECT: Object.freeze({
-    /** Ms to wait for in-flight requests to complete before force-closing. */
-    GRACEFUL_MS: 800,
-    /** Ms after which the force disconnect is triggered. */
-    FORCE_TIMEOUT_MS: 1200
-  }),
-  /** Lazy-connect idle lifecycle. */
-  IDLE: Object.freeze({
-    /** Default ms a lazy server stays connected with no tool calls before auto-sleep. */
-    DEFAULT_TIMEOUT_MS: 3e5,
-    /** How often the idle sweep runs (kept well below the timeout). */
-    SWEEP_INTERVAL_MS: 3e4
-  }),
-  /** JSON-RPC response timeout for outstanding requests. */
-  RESPONSE_TIMEOUT_MS: 500,
-  /** Max buffer size for the SSE reader. */
-  SSE_READER_MAX_BUFFER: 256 * 1024,
-  /** Max characters logged from a request body. */
-  REQUEST_LOG_CAP: 1024
-});
-
 // src/protocol.ts
 function record2(value, label) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
@@ -1138,6 +1053,192 @@ function parseGetPromptResult(value) {
   };
 }
 
+// src/client-capabilities.ts
+var MCPCapabilityClient = class {
+  constructor(requestCapability, requireResourceSubscriptions) {
+    this.requestCapability = requestCapability;
+    this.requireResourceSubscriptions = requireResourceSubscriptions;
+  }
+  requestCapability;
+  requireResourceSubscriptions;
+  async listResources(opts = {}) {
+    const params = pageParams(opts.cursor, "resources/list cursor");
+    return this.requestCapability(
+      "resources",
+      "resources/list",
+      params,
+      parseListResourcesResult,
+      opts
+    );
+  }
+  async listResourceTemplates(opts = {}) {
+    const params = pageParams(opts.cursor, "resources/templates/list cursor");
+    return this.requestCapability(
+      "resources",
+      "resources/templates/list",
+      params,
+      parseListResourceTemplatesResult,
+      opts
+    );
+  }
+  async readResource(uri, opts = {}) {
+    validateProtocolString(uri, "resource URI");
+    return this.requestCapability(
+      "resources",
+      "resources/read",
+      { uri },
+      parseReadResourceResult,
+      opts
+    );
+  }
+  async subscribeResource(uri, opts = {}) {
+    validateProtocolString(uri, "resource URI");
+    this.requireResourceSubscriptions("resources/subscribe");
+    await this.requestCapability(
+      "resources",
+      "resources/subscribe",
+      { uri },
+      parseEmptyResult,
+      opts
+    );
+  }
+  async unsubscribeResource(uri, opts = {}) {
+    validateProtocolString(uri, "resource URI");
+    this.requireResourceSubscriptions("resources/unsubscribe");
+    await this.requestCapability(
+      "resources",
+      "resources/unsubscribe",
+      { uri },
+      parseEmptyResult,
+      opts
+    );
+  }
+  async listPrompts(opts = {}) {
+    const params = pageParams(opts.cursor, "prompts/list cursor");
+    return this.requestCapability("prompts", "prompts/list", params, parseListPromptsResult, opts);
+  }
+  async getPrompt(name, args, opts = {}) {
+    validateProtocolString(name, "prompt name");
+    if (args && Object.keys(args).length > 64) {
+      throw new Error("MCP prompt arguments exceed the limit of 64");
+    }
+    for (const [key, value] of Object.entries(args ?? {})) {
+      validateProtocolString(key, "prompt argument name");
+      validateProtocolString(value, `prompt argument "${key}"`, true);
+    }
+    return this.requestCapability(
+      "prompts",
+      "prompts/get",
+      args === void 0 ? { name } : { name, arguments: args },
+      parseGetPromptResult,
+      opts
+    );
+  }
+};
+
+// src/client-process.ts
+import { spawn } from "node:child_process";
+import { buildChildEnv } from "@wrongstack/core/utils";
+function resolveHttpBearerHeaders(options, env = process.env) {
+  const envName = options.bearerTokenEnv?.trim();
+  if (!envName) return options.headers;
+  if (!/^[A-Za-z_][A-Za-z0-9_]{0,127}$/.test(envName)) {
+    throw new Error(`MCP bearerTokenEnv "${envName}" is not a valid environment variable name`);
+  }
+  const token = env[envName];
+  if (!token) throw new Error(`MCP "${options.name}" requires environment variable ${envName}`);
+  if (token.length > 16384 || /[\r\n]/.test(token)) {
+    throw new Error(`MCP "${options.name}" bearer token is oversized or contains newlines`);
+  }
+  const resolved = { ...options.headers };
+  for (const key of Object.keys(resolved)) {
+    if (key.toLowerCase() === "authorization") delete resolved[key];
+  }
+  resolved.Authorization = `Bearer ${token}`;
+  return resolved;
+}
+function forceKillTree(child) {
+  if (child.pid === void 0) {
+    try {
+      child.kill("SIGKILL");
+    } catch {
+    }
+    return;
+  }
+  if (process.platform === "win32") {
+    const killer = spawn("taskkill", ["/pid", String(child.pid), "/T", "/F"], {
+      stdio: "ignore",
+      // H-8 convention (spawn-convention test): taskkill needs PATH only —
+      // do not hand it the credential-bearing parent environment.
+      env: buildChildEnv(),
+      windowsHide: true
+    });
+    killer.once("error", () => {
+      try {
+        child.kill("SIGKILL");
+      } catch {
+      }
+    });
+    killer.unref();
+    return;
+  }
+  try {
+    child.kill("SIGKILL");
+  } catch {
+  }
+}
+
+// src/constants.ts
+var SUPPORTED_PROTOCOL_VERSIONS = Object.freeze(["2024-11-05"]);
+function negotiateProtocolVersion(requested) {
+  if (typeof requested === "string" && SUPPORTED_PROTOCOL_VERSIONS.includes(requested)) {
+    return requested;
+  }
+  return MCP_CONSTANTS.PROTOCOL_VERSION;
+}
+var MCP_CONSTANTS = Object.freeze({
+  /** MCP protocol version advertised during handshake: the newest we implement. */
+  PROTOCOL_VERSION: SUPPORTED_PROTOCOL_VERSIONS[0],
+  /** Identity announced to MCP servers during `initialize`. */
+  CLIENT_INFO: Object.freeze({
+    name: "wrongstack",
+    version: "0.1.10"
+  }),
+  /** Reconnection behaviour when a transport disconnects. */
+  RECONNECT: Object.freeze({
+    /** Max full reconnect cycles before the slot is marked `failed`. */
+    MAX_CYCLES: 5,
+    /** Base delay between cycles (exponential backoff applied on top). */
+    BASE_DELAY_MS: 1e3,
+    /** Jitter factor applied to the backoff (0 = no jitter, 1 = full). */
+    JITTER_FACTOR: 0.2,
+    /** Max connection attempts within a single cycle. */
+    MAX_ATTEMPTS: 3,
+    /** Base multiplier for the exponential backoff formula (`delay = BASE * multiplier^attempt`). */
+    BACKOFF_MULTIPLIER: 2
+  }),
+  /** Timing for graceful / forced disconnect. */
+  DISCONNECT: Object.freeze({
+    /** Ms to wait for in-flight requests to complete before force-closing. */
+    GRACEFUL_MS: 800,
+    /** Ms after which the force disconnect is triggered. */
+    FORCE_TIMEOUT_MS: 1200
+  }),
+  /** Lazy-connect idle lifecycle. */
+  IDLE: Object.freeze({
+    /** Default ms a lazy server stays connected with no tool calls before auto-sleep. */
+    DEFAULT_TIMEOUT_MS: 3e5,
+    /** How often the idle sweep runs (kept well below the timeout). */
+    SWEEP_INTERVAL_MS: 3e4
+  }),
+  /** JSON-RPC response timeout for outstanding requests. */
+  RESPONSE_TIMEOUT_MS: 500,
+  /** Max buffer size for the SSE reader. */
+  SSE_READER_MAX_BUFFER: 256 * 1024,
+  /** Max characters logged from a request body. */
+  REQUEST_LOG_CAP: 1024
+});
+
 // src/tool-schema.ts
 var MAX_TOOL_PAGES = 100;
 var MAX_TOOLS = 1e4;
@@ -1331,7 +1432,6 @@ var SSEReader = class {
 // src/transport-base.ts
 import * as https2 from "node:https";
 import { ConfigError as ConfigError2 } from "@wrongstack/core/types";
-import { Agent as UndiciAgent, fetch as undiciFetch } from "undici";
 
 // src/transport-security.ts
 import * as dns2 from "node:dns/promises";
@@ -1362,19 +1462,9 @@ function validateTransportUrl(rawUrl) {
   const hostname = url.hostname;
   const host = hostname.startsWith("[") && hostname.endsWith("]") ? hostname.slice(1, -1) : hostname;
   const ipVersion = net2.isIP(host);
-  if (ipVersion === 4) {
-    const parts = host.split(".").map(Number);
-    if (parts[0] === 169 && parts[1] === 254) {
-      throw new ConfigError({
-        message: `MCP transport: blocked link-local/IMDS address "${hostname}" \u2014 likely not a valid MCP server`,
-        code: "CONFIG_INVALID",
-        context: { field: "url", rawUrl, hostname }
-      });
-    }
-  } else if (ipVersion === 6) {
-    const lower = host.toLowerCase();
-    const linkLocal = /^fe[89ab]/.test(lower);
-    if (linkLocal || lower === "fd00:ec2::254") {
+  if (ipVersion !== 0) {
+    const classification = classifyTransportAddress(host, ipVersion);
+    if (classification === "blocked") {
       throw new ConfigError({
         message: `MCP transport: blocked link-local/IMDS address "${hostname}" \u2014 likely not a valid MCP server`,
         code: "CONFIG_INVALID",
@@ -1383,7 +1473,7 @@ function validateTransportUrl(rawUrl) {
     }
   }
   if (url.protocol === "http:") {
-    const isLoopback = hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1" || hostname === "[::1]";
+    const isLoopback = host === "localhost" || ipVersion !== 0 && classifyTransportAddress(host, ipVersion) === "loopback";
     if (!isLoopback) {
       throw new ConfigError({
         message: `MCP transport: http:// is only allowed for loopback addresses; use https:// for "${hostname}"`,
@@ -1491,6 +1581,14 @@ function transportPinnedLookup(options) {
 // src/transport-base.ts
 var MAX_TRANSPORT_REDIRECTS = 5;
 var nativeGlobalFetch = globalThis.fetch;
+var undiciModule;
+var undiciLoad;
+async function ensureUndici() {
+  if (undiciModule) return undiciModule;
+  undiciLoad ??= import("undici");
+  undiciModule = await undiciLoad;
+  return undiciModule;
+}
 var pinnedAgents = /* @__PURE__ */ new Set();
 var pinnedAgentsCleanupRegistered = false;
 if (!pinnedAgentsCleanupRegistered) {
@@ -1608,8 +1706,8 @@ var BaseHTTPTransport = class {
       let hopHeaders = headers;
       for (let hop = 0; hop < MAX_TRANSPORT_REDIRECTS; hop++) {
         const fetchOpts = { ...init, headers: hopHeaders, redirect: "manual" };
-        this.applyPinnedDispatcher(fetchOpts);
-        const res = await this.dispatcherFetch()(currentUrl, fetchOpts);
+        await this.applyPinnedDispatcher(fetchOpts);
+        const res = await (await this.dispatcherFetch())(currentUrl, fetchOpts);
         if (res.status !== 301 && res.status !== 302 && res.status !== 303 && res.status !== 307 && res.status !== 308) {
           return res;
         }
@@ -1704,13 +1802,16 @@ var BaseHTTPTransport = class {
       }
     }
   }
-  dispatcherFetch() {
-    return globalThis.fetch === nativeGlobalFetch ? undiciFetch : globalThis.fetch;
+  async dispatcherFetch() {
+    if (globalThis.fetch !== nativeGlobalFetch) return globalThis.fetch;
+    const undici = await ensureUndici();
+    return undici.fetch;
   }
-  pinnedDispatcher() {
+  async pinnedDispatcher() {
+    const undici = await ensureUndici();
     if (!this.pinnedAgent) {
       const tls = this.tlsOptions;
-      this.pinnedAgent = new UndiciAgent({
+      this.pinnedAgent = new undici.Agent({
         allowH2: false,
         connect: {
           ...tls ? { ca: tls.ca, rejectUnauthorized: tls.rejectUnauthorized } : {},
@@ -1724,8 +1825,8 @@ var BaseHTTPTransport = class {
     }
     return this.pinnedAgent;
   }
-  applyPinnedDispatcher(fetchOpts) {
-    fetchOpts.dispatcher = this.pinnedDispatcher();
+  async applyPinnedDispatcher(fetchOpts) {
+    fetchOpts.dispatcher = await this.pinnedDispatcher();
   }
   /**
    * Destroy this transport's pinned Agent and its connection pool. Idempotent.
@@ -2525,6 +2626,10 @@ var MCPClient = class _MCPClient {
     this.opts = opts;
   }
   opts;
+  capabilityClient = new MCPCapabilityClient(
+    this.requestCapability.bind(this),
+    this.requireResourceSubscriptions.bind(this)
+  );
   /**
    * Maximum bytes the rx buffer may accumulate before the connection is
    * forcefully closed. A well-behaved JSON-RPC server emits newline-delimited
@@ -2750,7 +2855,7 @@ var MCPClient = class _MCPClient {
     const httpOpts = {
       name: this.opts.name,
       url: this.opts.url,
-      headers: this.opts.headers,
+      headers: resolveHttpBearerHeaders(this.opts),
       startupTimeoutMs: this.opts.startupTimeoutMs,
       requestTimeoutMs: this.opts.requestTimeoutMs,
       authorizationProvider: this.opts.authorizationProvider,
@@ -2801,7 +2906,7 @@ var MCPClient = class _MCPClient {
     const httpOpts = {
       name: this.opts.name,
       url: this.opts.url,
-      headers: this.opts.headers,
+      headers: resolveHttpBearerHeaders(this.opts),
       startupTimeoutMs: this.opts.startupTimeoutMs,
       requestTimeoutMs: this.opts.requestTimeoutMs,
       authorizationProvider: this.opts.authorizationProvider,
@@ -2865,77 +2970,25 @@ var MCPClient = class _MCPClient {
     };
   }
   async listResources(opts = {}) {
-    const params = pageParams(opts.cursor, "resources/list cursor");
-    return this.requestCapability(
-      "resources",
-      "resources/list",
-      params,
-      parseListResourcesResult,
-      opts
-    );
+    return this.capabilityClient.listResources(opts);
   }
   async listResourceTemplates(opts = {}) {
-    const params = pageParams(opts.cursor, "resources/templates/list cursor");
-    return this.requestCapability(
-      "resources",
-      "resources/templates/list",
-      params,
-      parseListResourceTemplatesResult,
-      opts
-    );
+    return this.capabilityClient.listResourceTemplates(opts);
   }
   async readResource(uri, opts = {}) {
-    validateProtocolString(uri, "resource URI");
-    return this.requestCapability(
-      "resources",
-      "resources/read",
-      { uri },
-      parseReadResourceResult,
-      opts
-    );
+    return this.capabilityClient.readResource(uri, opts);
   }
   async subscribeResource(uri, opts = {}) {
-    validateProtocolString(uri, "resource URI");
-    this.requireResourceSubscriptions("resources/subscribe");
-    await this.requestCapability(
-      "resources",
-      "resources/subscribe",
-      { uri },
-      parseEmptyResult,
-      opts
-    );
+    return this.capabilityClient.subscribeResource(uri, opts);
   }
   async unsubscribeResource(uri, opts = {}) {
-    validateProtocolString(uri, "resource URI");
-    this.requireResourceSubscriptions("resources/unsubscribe");
-    await this.requestCapability(
-      "resources",
-      "resources/unsubscribe",
-      { uri },
-      parseEmptyResult,
-      opts
-    );
+    return this.capabilityClient.unsubscribeResource(uri, opts);
   }
   async listPrompts(opts = {}) {
-    const params = pageParams(opts.cursor, "prompts/list cursor");
-    return this.requestCapability("prompts", "prompts/list", params, parseListPromptsResult, opts);
+    return this.capabilityClient.listPrompts(opts);
   }
   async getPrompt(name, args, opts = {}) {
-    validateProtocolString(name, "prompt name");
-    if (args && Object.keys(args).length > 64) {
-      throw new Error("MCP prompt arguments exceed the limit of 64");
-    }
-    for (const [key, value] of Object.entries(args ?? {})) {
-      validateProtocolString(key, "prompt argument name");
-      validateProtocolString(value, `prompt argument "${key}"`, true);
-    }
-    return this.requestCapability(
-      "prompts",
-      "prompts/get",
-      args === void 0 ? { name } : { name, arguments: args },
-      parseGetPromptResult,
-      opts
-    );
+    return this.capabilityClient.getPrompt(name, args, opts);
   }
   async close() {
     if (this.closePromise) return this.closePromise;
@@ -3423,11 +3476,25 @@ function requireIdentity(value, label) {
 import { randomBytes as randomBytes3 } from "node:crypto";
 import * as fs from "node:fs/promises";
 async function readConfig(path2) {
+  let raw;
   try {
-    return JSON.parse(await fs.readFile(path2, "utf8"));
+    raw = await fs.readFile(path2, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") return {};
+    throw error;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
   } catch {
-    return {};
+    throw new Error(
+      `Profile config "${path2}" is not valid JSON \u2014 fix or remove it before changing MCP servers`
+    );
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`Profile config "${path2}" must contain a JSON object`);
   }
+  return parsed;
 }
 async function writeConfig(path2, cfg) {
   const raw = JSON.stringify(cfg, null, 2);
@@ -3499,6 +3566,8 @@ function buildConfig(input, base) {
   if (url !== void 0) cfg.url = url;
   const headers = input.headers ?? base?.headers;
   if (headers !== void 0) cfg.headers = headers;
+  const bearerTokenEnv = input.bearerTokenEnv ?? base?.bearerTokenEnv;
+  if (bearerTokenEnv !== void 0) cfg.bearerTokenEnv = bearerTokenEnv;
   const allowedTools = input.allowedTools ?? base?.allowedTools;
   if (allowedTools !== void 0) cfg.allowedTools = allowedTools;
   const permission = input.permission ?? base?.permission;
@@ -3743,6 +3812,7 @@ function manifestConfigHash(cfg) {
     url: cfg.url ?? null,
     env: sortedEntries(cfg.env),
     headers: sortedEntries(cfg.headers),
+    bearerTokenEnv: cfg.bearerTokenEnv ?? null,
     passthroughEnv: passthroughEntries(cfg.passthroughEnv)
   });
   return createHash2("sha256").update(basis).digest("hex").slice(0, 16);
@@ -4060,7 +4130,7 @@ function renderContentBlock(item) {
   if (type === "image" || type === "audio") {
     const mime = typeof item["mimeType"] === "string" ? item["mimeType"] : "unknown type";
     const data = typeof item["data"] === "string" ? item["data"] : "";
-    const kb = Math.max(1, Math.round(data.length * 3 / 4 / 1024));
+    const kb = data.length === 0 ? 0 : Math.max(1, Math.round(data.length * 3 / 4 / 1024));
     return `[${type} content: ${mime}, ~${kb} KB \u2014 binary payload not inlined]`;
   }
   if (type === "resource" && item["resource"] && typeof item["resource"] === "object") {
@@ -4077,6 +4147,9 @@ ${resource["text"]}`;
   if (type === "resource_link" && typeof item["uri"] === "string") {
     return `[resource link: ${item["uri"]}]`;
   }
+  if ("text" in item) {
+    return String(item["text"] ?? "");
+  }
   return JSON.stringify(item);
 }
 function stringify(c) {
@@ -4090,10 +4163,7 @@ function stringify(c) {
     }).join("\n");
   }
   if (c && typeof c === "object") {
-    if ("text" in c) {
-      return String(c.text);
-    }
-    return JSON.stringify(c);
+    return renderContentBlock(c);
   }
   return String(c ?? "");
 }
@@ -4240,6 +4310,7 @@ async function attemptConnectSlot(ctx, slot) {
         env: slot.cfg.env,
         url: slot.cfg.url,
         headers: slot.cfg.headers,
+        bearerTokenEnv: slot.cfg.bearerTokenEnv,
         startupTimeoutMs: slot.cfg.startupTimeoutMs,
         requestTimeoutMs: slot.cfg.requestTimeoutMs,
         cwd: ctx.cwd,
@@ -4451,8 +4522,10 @@ async function sleepIdleSlot(ctx, slot) {
     clearTimeout(slot.reconnectTimer);
     slot.reconnectTimer = void 0;
   }
-  if (slot.client) {
-    const client = slot.client;
+  slot.state = "dormant";
+  const client = slot.client;
+  slot.client = void 0;
+  if (client) {
     client.removeExitListener?.(ctx.onChildExit);
     if (slot.onDisconnect) client.removeDisconnectListener?.(slot.onDisconnect);
     client.removeToolsChangedListener?.(ctx.onToolsChanged);
@@ -4462,10 +4535,8 @@ async function sleepIdleSlot(ctx, slot) {
     } catch (err) {
       ctx.log.warn(`MCP server "${slot.cfg.name}" error during idle sleep close`, err);
     }
-    slot.client = void 0;
   }
   slot.onDisconnect = void 0;
-  slot.state = "dormant";
   slot.operations.sleepCount++;
   ctx.recordOperation(slot, "sleep", "idle-timeout");
   ctx.log.info(`MCP server "${slot.cfg.name}" idle \u2014 sleeping (tools stay registered)`);
@@ -5230,6 +5301,7 @@ var MCPServer = class {
   logger;
   resources;
   prompts;
+  inFlightRequests = /* @__PURE__ */ new Map();
   constructor(opts) {
     this.host = opts.host;
     this.serverInfo = opts.serverInfo ?? {
@@ -5254,32 +5326,44 @@ var MCPServer = class {
     } catch {
       return this.encodeError(null, PARSE_ERROR, "Parse error");
     }
-    if (typeof msg !== "object" || msg === null || typeof msg.method !== "string") {
+    const validId = msg?.id === void 0 || msg.id === null || typeof msg.id === "string" || typeof msg.id === "number";
+    if (typeof msg !== "object" || msg === null || msg.jsonrpc !== "2.0" || typeof msg.method !== "string" || !validId) {
       const id = msg && typeof msg === "object" ? msg.id ?? null : null;
       return this.encodeError(id ?? null, INVALID_REQUEST, "Invalid Request");
     }
     const isNotification = msg.id === void 0 || msg.id === null;
     if (isNotification) {
+      if (msg.method === "notifications/cancelled") {
+        const input = paramsRecord(msg.params);
+        const requestId2 = input["requestId"];
+        if (typeof requestId2 === "number" || typeof requestId2 === "string") {
+          const reason = typeof input["reason"] === "string" && input["reason"].trim().length > 0 ? input["reason"].trim().slice(0, 500) : "MCP request cancelled by client";
+          this.inFlightRequests.get(requestId2)?.abort(new Error(reason));
+        }
+      }
       return null;
     }
+    const requestId = expectDefined3(msg.id);
+    const controller = new AbortController();
+    this.inFlightRequests.set(requestId, controller);
     try {
-      const result = await this.dispatch(msg.method, msg.params);
+      const result = await this.dispatch(msg.method, msg.params, controller.signal);
       if (result === METHOD_NOT_FOUND_SENTINEL) {
-        return this.encodeError(
-          expectDefined3(msg.id),
-          METHOD_NOT_FOUND,
-          `Method not found: ${msg.method}`
-        );
+        return this.encodeError(requestId, METHOD_NOT_FOUND, `Method not found: ${msg.method}`);
       }
       return JSON.stringify({ jsonrpc: "2.0", id: msg.id, result });
     } catch (err) {
       const message = toErrorMessage2(err);
       this.logger?.warn?.(`MCP server: method "${msg.method}" threw: ${message}`);
       const code = err instanceof InvalidToolArgumentsError ? INVALID_PARAMS : INTERNAL_ERROR;
-      return this.encodeError(expectDefined3(msg.id), code, message);
+      return this.encodeError(requestId, code, message);
+    } finally {
+      if (this.inFlightRequests.get(requestId) === controller) {
+        this.inFlightRequests.delete(requestId);
+      }
     }
   }
-  async dispatch(method, params) {
+  async dispatch(method, params, signal) {
     switch (method) {
       case "initialize":
         return {
@@ -5306,7 +5390,7 @@ var MCPServer = class {
         }
         const args = p.arguments && typeof p.arguments === "object" && !Array.isArray(p.arguments) ? p.arguments : {};
         await this.assertArgumentsMatchSchema(p.name, args);
-        const res = await this.host.callTool(p.name, args);
+        const res = await this.host.callTool(p.name, args, { signal });
         return { content: toContentBlocks(res.content), isError: res.isError };
       }
       case "resources/list": {
@@ -5463,16 +5547,22 @@ function renderPromptTemplate(template, args) {
   });
 }
 var METHOD_NOT_FOUND_SENTINEL = /* @__PURE__ */ Symbol("method-not-found");
+function isMCPContentBlock(c) {
+  if (!c || typeof c !== "object") return false;
+  const type = c["type"];
+  return type === "text" || type === "image" || type === "audio" || type === "resource" || type === "resource_link";
+}
 function toContentBlocks(content) {
   if (typeof content === "string") return [{ type: "text", text: content }];
   if (Array.isArray(content)) {
-    const allBlocks = content.every(
-      (c) => c && typeof c === "object" && c.type === "text"
-    );
+    const allBlocks = content.every(isMCPContentBlock);
     if (allBlocks) return content;
     return [{ type: "text", text: content.map((c) => stringifyItem(c)).join("\n") }];
   }
   if (content === void 0 || content === null) return [{ type: "text", text: "" }];
+  if (isMCPContentBlock(content)) {
+    return [content];
+  }
   return [{ type: "text", text: stringifyItem(content) }];
 }
 function stringifyItem(c) {

package/dist/manage.d.ts

@@ -14,6 +14,7 @@ export interface McpServerInput {
     env?: Record<string, string> | undefined;
     url?: string | undefined;
     headers?: Record<string, string> | undefined;
+    bearerTokenEnv?: string | undefined;
     allowedTools?: string[] | undefined;
     permission?: Permission | undefined;
     /** Lazy connect — spawn the process only on first tool call (see config). */

package/dist/manifest-cache.d.ts

@@ -15,6 +15,7 @@ export declare function manifestConfigHash(cfg: {
     url?: string | undefined;
     env?: Record<string, string> | undefined;
     headers?: Record<string, string> | undefined;
+    bearerTokenEnv?: string | undefined;
     passthroughEnv?: string[] | undefined;
 }): string;
 /**

package/dist/server.d.ts

@@ -29,7 +29,9 @@ export interface MCPServerCallResult {
  */
 export interface MCPServerToolHost {
     listTools(): MCPServerTool[] | Promise<MCPServerTool[]>;
-    callTool(name: string, args: Record<string, unknown>): Promise<MCPServerCallResult>;
+    callTool(name: string, args: Record<string, unknown>, opts?: {
+        signal?: AbortSignal | undefined;
+    }): Promise<MCPServerCallResult>;
 }
 export interface MCPServerResource {
     uri: string;
@@ -72,6 +74,7 @@ export declare class MCPServer {
     private readonly logger?;
     private readonly resources;
     private readonly prompts;
+    private readonly inFlightRequests;
     constructor(opts: MCPServerOptions);
     /**
      * Handle one raw JSON-RPC line. Returns the response JSON string for
@@ -121,8 +124,8 @@ export declare class InvalidToolArgumentsError extends Error {
 }
 /** Normalize a host result's content into MCP content blocks. */
 export declare function toContentBlocks(content: unknown): Array<{
-    type: 'text';
-    text: string;
+    type: string;
+    [key: string]: unknown;
 }>;
 export interface ServeStdioHandle {
     /** Stop reading and detach listeners. Does not exit the process. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wrongstack/mcp",
-  "version": "1.0.17",
+  "version": "1.0.24",
   "license": "MIT",
   "description": "WrongStack Model Context Protocol client and registry: stdio, SSE, and streamable HTTP transports.",
   "repository": {
@@ -26,7 +26,7 @@
     "!dist/**/*.map"
   ],
   "dependencies": {
-    "@wrongstack/core": "1.0.17",
+    "@wrongstack/core": "1.0.24",
     "undici": "^8.10.2"
   },
   "devDependencies": {