@sigrun/ext-mcp 0.1.0 → 0.2.0

package/CHANGELOG.md

@@ -7,6 +7,24 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.2.0] - 2026-10-22
+### Added
+- Remote MCP servers: a `servers` entry may be `{url, headers?, exposure?,
+  toolExposure?, timeout?}` instead of a stdio `{command, args}`. Streamable
+  HTTP is the transport (POST per frame, JSON or SSE reply,
+  `mcp-session-id` captured and echoed); a legacy HTTP+SSE server is adopted
+  automatically — whether it 404/405s the POST or (crawl4ai's shape) answers
+  it with an `endpoint` event — so no supergateway-style adapter is needed.
+- `mcp.json` now resolves from the sigrun config dir
+  (`SIGRUN_CONFIG_DIR/mcp.json`) before the home fallback, matching every
+  other sigrun store.
+
+### Fixed
+- SSE parsing handles CRLF line endings (the spec allows them; live servers
+  emit them).
+- Streamable replies stop at the id-matching frame — servers legitimately
+  hold SSE streams open past the reply.
+
 ## [0.1.0] - 2026-10-13
 ### Added
 - Renamed to `@sigrun/ext-mcp` for the 0.1.0 release (repo stays

package/README.md

@@ -2,8 +2,10 @@
 
 Register MCP server tools as pi-durable tools, named `<server>/<tool>`.
 
-Config: `~/.config/sigrun/mcp.json` (or the `SIGRUN_MCP_CONFIG` env override
-pointing at any path). Each entry under `"servers"` names a stdio MCP server:
+Config: the sigrun config dir's `mcp.json` (`SIGRUN_CONFIG_DIR/mcp.json`; a
+bare user install falls back to `~/.config/sigrun/mcp.json`; the
+`SIGRUN_MCP_CONFIG` env override points at any path). Each entry under
+`"servers"` names an MCP server — stdio or remote:
 
 ```json
 {
@@ -13,6 +15,11 @@ pointing at any path). Each entry under `"servers"` names a stdio MCP server:
 			"args": ["-y", "@modelcontextprotocol/server-github"],
 			"exposure": "codemode",
 			"timeout": 120
+		},
+		"search": {
+			"url": "https://mcp.example.test/mcp",
+			"headers": { "Authorization": "Bearer <token>" },
+			"exposure": "direct"
 		}
 	}
 }
@@ -20,8 +27,14 @@ pointing at any path). Each entry under `"servers"` names a stdio MCP server:
 
 ## Server fields
 
-- `command`, `args` (required) — how to spawn the server.
-- `env` — extra environment variables for the child process.
+- `command`, `args` (stdio) — how to spawn the server.
+- `url` (remote) — the server endpoint (http/https). Streamable HTTP is the
+  transport; a legacy HTTP+SSE server (2024-11-05 shape — GET stream +
+  `endpoint` event + message POSTs) is adopted automatically, so no adapter
+  process is needed.
+- `headers` (remote) — extra request headers (auth etc.), sent on every
+  request.
+- `env` (stdio) — extra environment variables for the child process.
 - `enabled` (default `true`) / `disabled` — skip the server entirely. Set one,
   never both: a server that is simultaneously on and off is a config error and
   fails loudly.
@@ -33,8 +46,9 @@ pointing at any path). Each entry under `"servers"` names a stdio MCP server:
 - `toolExposure` — per-tool overrides of `exposure`: an object mapping tool
   names (exact) or `*`-globs (e.g. `"get-*"`) to exposure words. An exact name
   always wins; among matching patterns the FIRST one in config order wins.
-- `oauth` — the authorization-code (PKCE) flow block; see `sigrun-ext-mcp oauth
-  <server>` (the CLI mints and stores a token; the spawn injects it).
+- `oauth` (stdio) — the authorization-code (PKCE) flow block; see
+  `sigrun-ext-mcp oauth <server>` (the CLI mints and stores a token; the spawn
+  injects it).
 
 ## Exposure: how tools reach callers
 

package/dist/cli.js

@@ -17,7 +17,7 @@
  * flow / 5-minute timeout).
  */
 import { createInterface } from "node:readline";
-import { loadMcpConfig, MCP_CONFIG_ENV } from "./config.js";
+import { isStdioServer, loadMcpConfig, MCP_CONFIG_ENV, } from "./config.js";
 import { startOauth } from "./oauth.js";
 import { resolveMcpTokenPath } from "./tokens.js";
 /** The flow timeout (matches startOauth's default; explicit so the user's
@@ -71,7 +71,7 @@ export async function runCli(argv, io = { stdout: process.stdout, stderr: proces
         io.stderr.write(`error: no server named "${parsed.server}" in the MCP config\n`);
         return 1;
     }
-    if (server.oauth === undefined) {
+    if (!isStdioServer(server) || server.oauth === undefined) {
         io.stderr.write(`error: server "${parsed.server}" has no oauth block in the MCP config\n`);
         return 1;
     }

package/dist/client.d.ts

@@ -1,12 +1,20 @@
 /**
- * Minimal hand-rolled MCP stdio client (ruling 3): JSON-RPC 2.0 over
- * newline-delimited stdio, no pi-mcp dependency.
+ * The MCP client: a transport-neutral JSON-RPC 2.0 engine plus two
+ * transports.
  *
- * Lifecycle: spawn → `initialize` handshake (protocolVersion "2025-06-18",
- * clientInfo, capabilities) → `notifications/initialized` → `tools/list`
- * (discovery) → `tools/call` (execution). Requests correlate by id; the
- * response frame's `id` must match a pending request (a notification is
- * never a reply). A spawn failure or handshake failure rejects `connect`,
+ * stdio (the original transport): newline-delimited JSON-RPC over a spawned
+ * child's pipes. Remote (streamable HTTP): every request POSTs to the
+ * configured URL; the reply is a JSON body OR an SSE stream. A server that
+ * 404/405s the POST (the pre-2025-03-26 "HTTP+SSE" transport — still common,
+ * e.g. many self-hosted servers) falls back to the legacy shape: a GET
+ * stream for server→client frames and a discovered message endpoint for
+ * client→server POSTs.
+ *
+ * Lifecycle (both transports): `initialize` handshake (protocolVersion
+ * "2025-06-18", clientInfo, capabilities) → `notifications/initialized` →
+ * `tools/list` (discovery) → `tools/call` (execution). Requests correlate
+ * by id; the response frame's `id` must match a pending request (a
+ * notification is never a reply). A connect failure rejects `connect`,
  * never affecting any other server (per-server isolation).
  *
  * Per-request timeout (codemode parity, spec slice 3): every request REJECTS
@@ -14,35 +22,21 @@
  * awaiting a hung server forever. A `notifications/progress` frame naming a
  * pending request's id (sent as the request's `progressToken`) RESETS that
  * request's deadline — a server that keeps reporting progress stays alive
- * as long as it works. A timeout rejects the call but never kills the child
- * (per-server isolation: the next request gets a fresh chance).
+ * as long as it works. A timeout rejects the call but never kills the
+ * transport (per-server isolation: the next request gets a fresh chance).
  */
-import { type ChildProcess } from "node:child_process";
 import type { McpServerConfig, McpToolDefinition, McpToolResult } from "./types.js";
-/** One connected MCP server: a live child process speaking JSON-RPC. */
-export declare class McpClient {
-    #private;
-    /** @internal constructed by {@link connectMcpServer}. */
-    constructor(name: string, child: ChildProcess);
-    /**
-     * The MCP handshake: `initialize` then `notifications/initialized`.
-     * The initialize reply is validated to carry the protocol version.
-     */
-    handshake(): Promise<void>;
-    /** Discover the server's tools (`tools/list`). */
+/** The public client surface (what the extension consumes). */
+export interface McpClient {
     listTools(): Promise<McpToolDefinition[]>;
-    /** Execute one tool (`tools/call`); an `isError` result resolves (it is a
-     * valid tool outcome, not a protocol failure). `timeoutSeconds` caps the
-     * wait per request (default 60; progress notifications reset it). */
     callTool(name: string, args: Record<string, unknown>, timeoutSeconds?: number): Promise<McpToolResult>;
-    /** Wait for the child to exit (used by tests / shutdown checks). */
-    exited(): Promise<Error | undefined>;
-    /** Kill the child and tear down (idempotent). */
+    /** Tear the connection down (idempotent). */
     close(): void;
 }
 /**
- * Spawn and connect one configured MCP server. Throws on spawn failure or a
- * failed handshake — per-server isolation is the CALLER's policy (the
- * extension connects all servers with `.catch` per server).
+ * Spawn/connect one configured MCP server (stdio or remote by config
+ * shape). Throws on spawn/connect failure or a failed handshake —
+ * per-server isolation is the CALLER's policy (the extension connects all
+ * servers with `.catch` per server).
  */
 export declare function connectMcpServer(name: string, config: McpServerConfig): Promise<McpClient>;

package/dist/client.js

@@ -1,12 +1,20 @@
 /**
- * Minimal hand-rolled MCP stdio client (ruling 3): JSON-RPC 2.0 over
- * newline-delimited stdio, no pi-mcp dependency.
+ * The MCP client: a transport-neutral JSON-RPC 2.0 engine plus two
+ * transports.
  *
- * Lifecycle: spawn → `initialize` handshake (protocolVersion "2025-06-18",
- * clientInfo, capabilities) → `notifications/initialized` → `tools/list`
- * (discovery) → `tools/call` (execution). Requests correlate by id; the
- * response frame's `id` must match a pending request (a notification is
- * never a reply). A spawn failure or handshake failure rejects `connect`,
+ * stdio (the original transport): newline-delimited JSON-RPC over a spawned
+ * child's pipes. Remote (streamable HTTP): every request POSTs to the
+ * configured URL; the reply is a JSON body OR an SSE stream. A server that
+ * 404/405s the POST (the pre-2025-03-26 "HTTP+SSE" transport — still common,
+ * e.g. many self-hosted servers) falls back to the legacy shape: a GET
+ * stream for server→client frames and a discovered message endpoint for
+ * client→server POSTs.
+ *
+ * Lifecycle (both transports): `initialize` handshake (protocolVersion
+ * "2025-06-18", clientInfo, capabilities) → `notifications/initialized` →
+ * `tools/list` (discovery) → `tools/call` (execution). Requests correlate
+ * by id; the response frame's `id` must match a pending request (a
+ * notification is never a reply). A connect failure rejects `connect`,
  * never affecting any other server (per-server isolation).
  *
  * Per-request timeout (codemode parity, spec slice 3): every request REJECTS
@@ -14,8 +22,8 @@
  * awaiting a hung server forever. A `notifications/progress` frame naming a
  * pending request's id (sent as the request's `progressToken`) RESETS that
  * request's deadline — a server that keeps reporting progress stays alive
- * as long as it works. A timeout rejects the call but never kills the child
- * (per-server isolation: the next request gets a fresh chance).
+ * as long as it works. A timeout rejects the call but never kills the
+ * transport (per-server isolation: the next request gets a fresh chance).
  */
 import { spawn } from "node:child_process";
 import { spawnEnvWithToken } from "./tokens.js";
@@ -24,59 +32,24 @@ const MCP_PROTOCOL_VERSION = "2025-06-18";
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-/** One connected MCP server: a live child process speaking JSON-RPC. */
-export class McpClient {
-    #process;
-    #stdin;
-    #stdout;
+/**
+ * The JSON-RPC engine: id correlation, per-request deadlines, progress
+ * resets, and the handshake/list/call methods. Transport-agnostic — frames
+ * in, frames out, death unwinds pending.
+ */
+class McpEngine {
     #name;
+    #transport;
     #nextId = 1;
-    #buffer = "";
     #pending = new Map();
-    #exitError;
-    /** True when the child exited through an intentional close(). */
-    #exitClean = false;
-    #exitWaiters = [];
+    #dead;
     #closed = false;
-    /** @internal constructed by {@link connectMcpServer}. */
-    constructor(name, child) {
+    constructor(name, transport) {
         this.#name = name;
-        this.#process = child;
-        if (child.stdin === null || child.stdout === null) {
-            throw new Error(`mcp server "${name}" spawned without stdio`);
-        }
-        this.#stdin = child.stdin;
-        this.#stdout = child.stdout;
-        this.#stdout.setEncoding("utf8");
-        this.#stdout.on("data", (chunk) => this.#onData(chunk));
-        this.#stdout.on("error", () => this.#failExits()); // closed pipe: ignore
-        // A broken stdin pipe (server died) must not crash the host with an
-        // unhandled stream error; surface it as the exit error instead.
-        this.#stdin.on("error", () => this.#failExits());
-        this.#process.on("error", (error) => this.#setExitError(error));
-        this.#process.on("exit", () => this.#setExitError(undefined));
-    }
-    #onData(chunk) {
-        this.#buffer += chunk;
-        for (;;) {
-            const newline = this.#buffer.indexOf("\n");
-            if (newline < 0)
-                return;
-            const line = this.#buffer.slice(0, newline).trim();
-            this.#buffer = this.#buffer.slice(newline + 1);
-            if (line === "")
-                continue;
-            this.#onLine(line);
-        }
+        this.#transport = transport;
     }
-    #onLine(line) {
-        let frame;
-        try {
-            frame = JSON.parse(line);
-        }
-        catch {
-            return; // a non-JSON line (server chatter) is not a protocol reply
-        }
+    /** A transport delivered one parsed frame (reply or notification). */
+    handleFrame(frame) {
         if (frame.id === undefined || frame.id === null) {
             // A frame with no id is a server-initiated NOTIFICATION (a reply
             // always carries the request's id). A `notifications/progress`
@@ -107,43 +80,18 @@ export class McpClient {
             pending.resolve(frame.result);
         }
     }
-    #setExitError(error) {
-        if (this.#exitError !== undefined)
+    /** The transport died (once): unwind everything pending with the error. */
+    handleDeath(error) {
+        if (this.#dead !== undefined)
             return;
-        // An INTENTIONAL close() is a clean shutdown: resolve waiters with no
-        // error (a close is a shutdown, never a failure).
-        if (this.#closed)
-            this.#exitClean = true;
-        const waiters = this.#exitWaiters;
-        this.#exitWaiters = [];
-        if (!this.#exitClean) {
-            this.#exitError =
-                error ??
-                    new Error(`mcp server "${this.#name}" exited early (code ${this.#process.exitCode ?? "?"})`);
-        }
-        for (const waiter of waiters)
-            waiter(this.#exitError);
-        this.#rejectPending();
-    }
-    #failExits() {
-        // stdout closed: surface as an exit error if the process has not yet
-        // reported one, so a hung `tools/call` unwinds.
-        this.#setExitError(undefined);
-    }
-    #rejectPending() {
+        this.#dead = error;
         const pending = [...this.#pending.values()];
         this.#pending.clear();
         for (const entry of pending) {
             entry.clearTimeout();
-            entry.reject(this.#exitError ?? new Error("mcp server closed"));
+            entry.reject(error);
         }
     }
-    /** Write one frame as a single newline-terminated line. */
-    #write(frame) {
-        if (this.#closed)
-            throw new Error(`mcp server "${this.#name}" is closed`);
-        this.#stdin.write(JSON.stringify(frame) + "\n");
-    }
     /**
      * Send a request and await its reply (id-correlated) under a per-request
      * deadline. `timeoutSeconds` defaults to 60; the request's id doubles as
@@ -151,6 +99,8 @@ export class McpClient {
      * convention), so progress notifications can name it.
      */
     #request(method, params, timeoutSeconds) {
+        if (this.#dead !== undefined)
+            return Promise.reject(this.#dead);
         const id = this.#nextId++;
         const seconds = timeoutSeconds ?? DEFAULT_TIMEOUT_SECONDS;
         return new Promise((resolve, reject) => {
@@ -176,30 +126,20 @@ export class McpClient {
             };
             const deadline = () => fail(new Error(`mcp server "${this.#name}" ${method} timed out after ${seconds}s`));
             this.#pending.set(id, entry);
-            try {
-                // MCP convention: the progressToken rides in params._meta (a
-                // spec-conforming server reads/echoes it from there). params is
-                // merged (never mutated) so an object request keeps its fields;
-                // a null-params request (tools/list) gets params just for _meta.
-                const requestParams = isRecord(params)
-                    ? { ...params, _meta: { progressToken: id } }
-                    : { _meta: { progressToken: id } };
-                this.#write({
-                    jsonrpc: "2.0",
-                    id,
-                    method,
-                    params: requestParams,
-                });
-            }
-            catch (error) {
-                fail(error instanceof Error ? error : new Error(String(error)));
+            // MCP convention: the progressToken rides in params._meta (a
+            // spec-conforming server reads/echoes it from there). params is
+            // merged (never mutated) so an object request keeps its fields;
+            // a null-params request (tools/list) gets params just for _meta.
+            const requestParams = isRecord(params)
+                ? { ...params, _meta: { progressToken: id } }
+                : { _meta: { progressToken: id } };
+            this.#transport
+                .send({ jsonrpc: "2.0", id, method, params: requestParams })
+                .catch((cause) => {
+                fail(cause instanceof Error ? cause : new Error(String(cause)));
                 return;
-            }
+            });
             timer = setTimeout(deadline, seconds * 1000);
-            if (this.#exitError !== undefined) {
-                // The server already died: unwind this request too.
-                fail(this.#exitError);
-            }
         });
     }
     /**
@@ -210,12 +150,15 @@ export class McpClient {
         const result = (await this.#request("initialize", {
             protocolVersion: MCP_PROTOCOL_VERSION,
             capabilities: {},
-            clientInfo: { name: "sigrun-ext-mcp", version: "0.1.0" },
+            clientInfo: { name: "sigrun-ext-mcp", version: "0.2.0" },
         }, undefined));
         if (typeof result?.protocolVersion !== "string") {
             throw new Error(`mcp server "${this.#name}" handshake reply lacks protocolVersion`);
         }
-        this.#write({ jsonrpc: "2.0", method: "notifications/initialized" });
+        await this.#transport.send({
+            jsonrpc: "2.0",
+            method: "notifications/initialized",
+        });
     }
     /** Discover the server's tools (`tools/list`). */
     async listTools() {
@@ -232,48 +175,511 @@ export class McpClient {
         }
         return result;
     }
-    /** Wait for the child to exit (used by tests / shutdown checks). */
-    async exited() {
-        if (this.#exitError !== undefined)
-            return this.#exitError;
-        if (this.#process.exitCode !== null || this.#process.signalCode !== null) {
-            return undefined; // exited cleanly; already unwound pending
+    close() {
+        if (this.#closed)
+            return;
+        this.#closed = true;
+        this.#transport.close();
+        this.handleDeath(new Error("mcp client closed"));
+    }
+}
+// ---------------------------------------------------------------------------
+// stdio transport (the original): today's behavior, moved verbatim in shape.
+// ---------------------------------------------------------------------------
+/** One connected stdio MCP server: a live child process speaking JSON-RPC. */
+class StdioTransport {
+    #engine;
+    #process;
+    #stdin;
+    #stdout;
+    #buffer = "";
+    #closed = false;
+    constructor(name, command, args, env) {
+        // The engine is constructed with this transport; handleFrame/handleDeath
+        // route the child's output back into it.
+        this.#process = spawn(command, [...args], {
+            stdio: ["pipe", "pipe", "pipe"],
+            env,
+        });
+        this.#engine = new McpEngine(name, this);
+        if (this.#process.stdin === null || this.#process.stdout === null) {
+            this.#process.kill("SIGKILL");
+            throw new Error(`mcp server "${name}" spawned without stdio`);
         }
-        return new Promise((resolve) => {
-            this.#exitWaiters.push(resolve);
+        this.#stdin = this.#process.stdin;
+        this.#stdout = this.#process.stdout;
+        this.#stdout.setEncoding("utf8");
+        this.#stdout.on("data", (chunk) => this.#onData(chunk));
+        // A closed pipe is transport death (never an unhandled stream error).
+        this.#stdout.on("error", () => this.#die());
+        this.#stdin.on("error", () => this.#die());
+        this.#process.on("error", (error) => this.#die(error));
+        this.#process.on("exit", () => this.#die());
+    }
+    get engine() {
+        return this.#engine;
+    }
+    #onData(chunk) {
+        this.#buffer += chunk;
+        for (;;) {
+            const newline = this.#buffer.indexOf("\n");
+            if (newline < 0)
+                return;
+            const line = this.#buffer.slice(0, newline).trim();
+            this.#buffer = this.#buffer.slice(newline + 1);
+            if (line === "")
+                continue;
+            let frame;
+            try {
+                frame = JSON.parse(line);
+            }
+            catch {
+                continue; // a non-JSON line (server chatter) is not a protocol reply
+            }
+            this.#engine.handleFrame(frame);
+        }
+    }
+    #die(error) {
+        if (this.#closed)
+            return;
+        this.#closed = true;
+        this.#engine.handleDeath(error ??
+            new Error(`mcp server exited early (code ${this.#process.exitCode ?? "?"})`));
+    }
+    send(frame) {
+        if (this.#closed) {
+            return Promise.reject(new Error("mcp stdio transport is closed"));
+        }
+        return new Promise((resolve, reject) => {
+            this.#stdin.write(JSON.stringify(frame) + "\n", (error) => {
+                if (error === undefined || error === null)
+                    resolve();
+                else
+                    reject(error instanceof Error ? error : new Error(String(error)));
+            });
         });
     }
-    /** Kill the child and tear down (idempotent). */
     close() {
         if (this.#closed)
             return;
         this.#closed = true;
         this.#process.kill("SIGTERM");
-        this.#rejectPending();
+        this.#engine.handleDeath(new Error("mcp client closed"));
+    }
+}
+// ---------------------------------------------------------------------------
+// Remote transport: streamable HTTP with a legacy-SSE fallback.
+// ---------------------------------------------------------------------------
+/**
+ * Hand-rolled SSE parsing (no EventSource dependency — this is Node, and
+ * the stream is a fetch body, not a DOM event target): buffer bytes, split
+ * complete events on a blank line, read `data:` lines, JSON-parse each
+ * data payload as one JSON-RPC message per event. Non-`message` event
+ * names are read for transport control (the legacy `endpoint` event) and
+ * otherwise ignored.
+ */
+class SseParser {
+    #buffer = "";
+    #pendingData = [];
+    #pendingEvent = "";
+    /** Feed bytes; emits complete parsed frames through `onFrame` and
+     * legacy `endpoint` events through `onEndpoint`. */
+    feed(chunk, onFrame, onEndpoint) {
+        this.#buffer += chunk;
+        for (;;) {
+            // The SSE spec allows \r\n, \n, or \r line endings; live servers
+            // (e.g. behind certain proxies) emit CRLF, so a plain \n\n split
+            // never finds the event boundary. Normalize the whole buffer's line
+            // endings FIRST, then split events on blank lines.
+            this.#buffer = this.#buffer.replaceAll("\r\n", "\n").replaceAll("\r", "\n");
+            const boundary = this.#buffer.indexOf("\n\n");
+            if (boundary < 0)
+                return;
+            const raw = this.#buffer.slice(0, boundary);
+            this.#buffer = this.#buffer.slice(boundary + 2);
+            const dataLines = [];
+            let eventName = "";
+            for (const line of raw.split("\n")) {
+                if (line.startsWith("data:")) {
+                    // One leading space after the colon is per-spec optional.
+                    const value = line.slice(5);
+                    dataLines.push(value.startsWith(" ") ? value.slice(1) : value);
+                }
+                else if (line.startsWith("event:")) {
+                    const value = line.slice(6);
+                    eventName = (value.startsWith(" ") ? value.slice(1) : value).trim();
+                }
+            }
+            if (dataLines.length === 0)
+                continue;
+            const payload = dataLines.join("\n");
+            if (eventName === "endpoint") {
+                onEndpoint?.(payload.trim());
+                continue;
+            }
+            try {
+                onFrame(JSON.parse(payload));
+            }
+            catch {
+                // A non-JSON data payload is not a protocol frame; skip it.
+            }
+        }
+    }
+}
+/**
+ * The remote transport. Starts in STREAMABLE mode: every frame POSTs to the
+ * configured URL; replies arrive as the POST response body (JSON or SSE).
+ * If the INITIAL POST answers 404/405 (a legacy HTTP+SSE server), the
+ * transport switches to LEGACY mode: a long-lived GET SSE stream delivers
+ * every server→client frame, and client→server frames POST to the message
+ * endpoint the server announces via an `endpoint` event.
+ */
+class HttpTransport {
+    #engine;
+    #name;
+    #url;
+    #headers;
+    /** Legacy mode's message endpoint (absolute); streamable mode's POST target stays #url. */
+    #messageUrl;
+    /** Streamable HTTP session id (echoed on every request once seen). */
+    #sessionId;
+    /** Legacy GET stream bookkeeping. */
+    #getController;
+    #mode = "streamable";
+    #closed = false;
+    constructor(name, config) {
+        this.#name = name;
+        this.#url = config.url;
+        this.#headers = { ...(config.headers ?? {}) };
+        this.#engine = new McpEngine(name, this);
+    }
+    get engine() {
+        return this.#engine;
+    }
+    #requestHeaders(extra) {
+        const headers = {
+            "content-type": "application/json",
+            accept: "application/json, text/event-stream",
+            ...this.#headers,
+            ...extra,
+        };
+        if (this.#sessionId !== undefined) {
+            headers["mcp-session-id"] = this.#sessionId;
+        }
+        return headers;
+    }
+    send(frame) {
+        if (this.#closed) {
+            return Promise.reject(new Error(`mcp server "${this.#name}" is closed`));
+        }
+        // A reply-bearing REQUEST: the reply may be the POST response body or
+        // (legacy) arrive on the GET stream — this send resolves when the POST
+        // is accepted; the ENGINE's pending entry settles when the frame lands.
+        // A NOTIFICATION never expects a body reply (202/204 are fine).
+        return this.#post(frame);
+    }
+    async #post(frame) {
+        const url = this.#messageUrl ?? this.#url;
+        const body = JSON.stringify(frame);
+        const controller = new AbortController();
+        const abortOnClose = () => controller.abort();
+        this.#closeHooks.add(abortOnClose);
+        try {
+            const response = await fetch(url, {
+                method: "POST",
+                headers: this.#requestHeaders({}),
+                body,
+                signal: controller.signal,
+            });
+            const sessionHeader = response.headers.get("mcp-session-id");
+            if (sessionHeader !== null && sessionHeader !== "") {
+                this.#sessionId = sessionHeader;
+            }
+            if (response.status === 404 || response.status === 405) {
+                if (this.#mode === "streamable" && frame.method === "initialize") {
+                    // The legacy negotiation point: only on the FIRST request.
+                    // Later 404/405s are ordinary errors (below).
+                    await this.#startLegacy();
+                    // The initialize POST must now go to the legacy message
+                    // endpoint; the endpoint event has set #messageUrl.
+                    if (this.#messageUrl === undefined) {
+                        throw new Error(`mcp server "${this.#name}" legacy SSE stream announced no endpoint`);
+                    }
+                    return this.#post(frame);
+                }
+                throw new Error(`mcp server "${this.#name}" POST ${url} failed: ${response.status} ${response.statusText}`);
+            }
+            if (!response.ok) {
+                const snippet = (await response.text()).slice(0, 200);
+                throw new Error(`mcp server "${this.#name}" POST ${url} failed: ${response.status} ${response.statusText} ${snippet}`.trim());
+            }
+            // A notification needs no body processing; a request's reply may
+            // be here (streamable) or on the GET stream (legacy — where the
+            // body is typically empty 202). 202/204 carry no reply body per
+            // spec — and a legacy server may 202 WITHOUT ever ending the
+            // response stream, so awaiting the body would hang: treat them as
+            // accepted-and-done (the reply, if any, rides the GET stream).
+            const contentType = response.headers.get("content-type") ?? "";
+            if (response.status === 202 || response.status === 204) {
+                // Nothing to read; cancel any body the server left open.
+                response.body?.cancel().catch(() => {
+                    // A cancel failure (already-closed stream) needs no handling.
+                });
+            }
+            else if (contentType.includes("text/event-stream")) {
+                // Streamable SSE: the reply to THIS request arrives as an event
+                // on the response stream — but the stream legitimately STAYS OPEN
+                // after it (the server may push notifications). Read until the
+                // id-matching reply frame lands, then cancel the stream; a
+                // notification POST (no id) has no reply to wait for, so it just
+                // cancels. Reading past the reply would hang on servers that
+                // hold the stream open (e.g. searmcp).
+                //
+                // LEGACY DETECTION (generalized): some legacy servers (crawl4ai's
+                // shape) answer the initial POST itself with 200 + SSE + an
+                // `endpoint` event — no 404/405 ever fires. The endpoint event is
+                // unambiguous (streamable HTTP never sends one), so on the FIRST
+                // request an endpoint event means legacy: adopt this stream as
+                // the server→client channel and re-POST to the message endpoint.
+                if (this.#mode === "streamable" && frame.method === "initialize") {
+                    const legacy = await this.#maybeAdoptLegacyFromPost(response);
+                    if (legacy) {
+                        if (this.#messageUrl === undefined) {
+                            throw new Error(`mcp server "${this.#name}" legacy SSE stream announced no endpoint`);
+                        }
+                        return this.#post(frame);
+                    }
+                    // Not legacy: fall through to the reply-wait drain.
+                }
+                const waitForId = typeof frame.id === "number" ? frame.id : undefined;
+                await this.#drainSseBody(response, (parsed) => {
+                    this.#engine.handleFrame(parsed);
+                }, waitForId);
+            }
+            else if (frame.id !== undefined && frame.id !== null) {
+                const text = await response.text();
+                if (text !== "") {
+                    try {
+                        this.#engine.handleFrame(JSON.parse(text));
+                    }
+                    catch {
+                        // A non-JSON body for a request is a protocol break on
+                        // this reply; the engine's deadline will surface it.
+                    }
+                }
+            }
+            else {
+                // Drain (and discard) notification bodies.
+                await response.text().catch(() => "");
+            }
+        }
+        finally {
+            this.#closeHooks.delete(abortOnClose);
+        }
+    }
+    /** On the INITIAL POST's SSE response: read events until either the
+     * id-matching reply arrives (streamable — report not-legacy) or an
+     * `endpoint` event appears (legacy — adopt the stream as the
+     * server→client channel, set #messageUrl, report legacy). */
+    async #maybeAdoptLegacyFromPost(response) {
+        const parser = new SseParser();
+        const reader = response.body?.getReader();
+        if (reader === undefined)
+            return false;
+        const decoder = new TextDecoder();
+        const self = this;
+        let sawReply = false;
+        const deliver = (parsed) => {
+            if (parsed.id !== undefined && parsed.id !== null)
+                sawReply = true;
+            this.#engine.handleFrame(parsed);
+        };
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                return false; // stream ended with no endpoint event
+            let sawEndpoint = false;
+            parser.feed(decoder.decode(value, { stream: true }), deliver, (endpoint) => {
+                sawEndpoint = true;
+                self.#messageUrl = new URL(endpoint, self.#url).toString();
+            });
+            if (sawEndpoint) {
+                // Adopt this stream as the legacy server→client channel: legacy
+                // mode from here; a background reader keeps feeding frames.
+                this.#mode = "legacy";
+                const controller = new AbortController();
+                this.#getController = controller;
+                const abortOnClose = () => controller.abort();
+                this.#closeHooks.add(abortOnClose);
+                const engine = this.#engine;
+                void (async () => {
+                    try {
+                        for (;;) {
+                            const next = await reader.read();
+                            if (next.done)
+                                break;
+                            parser.feed(decoder.decode(next.value, { stream: true }), (frame2) => engine.handleFrame(frame2));
+                        }
+                        engine.handleDeath(new Error(`mcp server "${self.#name}" legacy SSE stream ended`));
+                    }
+                    catch (cause) {
+                        if (self.#closed)
+                            return;
+                        engine.handleDeath(cause instanceof Error
+                            ? cause
+                            : new Error(`mcp server "${self.#name}" SSE stream failed`));
+                    }
+                })();
+                return true;
+            }
+            if (sawReply)
+                return false; // a reply already arrived: streamable
+        }
+    }
+    /** Read a fetch response whose body is an SSE stream. When `waitForId`
+     * is set, stop (cancel the stream) once a reply frame with that id has
+     * been delivered — the streamable transport keeps streams open past the
+     * reply; without a wait the stream reads to completion. */
+    async #drainSseBody(response, onFrame, waitForId) {
+        const parser = new SseParser();
+        const reader = response.body?.getReader();
+        if (reader === undefined)
+            return;
+        const decoder = new TextDecoder();
+        let seen = false;
+        const deliver = (frame) => {
+            onFrame(frame);
+            if (waitForId !== undefined && frame.id === waitForId) {
+                seen = true;
+            }
+        };
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            parser.feed(decoder.decode(value, { stream: true }), deliver);
+            if (seen) {
+                await reader.cancel().catch(() => {
+                    // Already-closed streams cancel noisily; harmless.
+                });
+                return;
+            }
+        }
+        parser.feed(decoder.decode(), deliver);
+    }
+    /** Switch to the legacy transport: open the GET SSE stream and wait for
+     * the server's `endpoint` event naming the message POST URL. */
+    async #startLegacy() {
+        this.#mode = "legacy";
+        const controller = new AbortController();
+        this.#getController = controller;
+        const abortOnClose = () => controller.abort();
+        this.#closeHooks.add(abortOnClose);
+        const response = await fetch(this.#url, {
+            method: "GET",
+            headers: {
+                accept: "text/event-stream",
+                ...this.#headers,
+            },
+            signal: controller.signal,
+        });
+        if (!response.ok || !(response.headers.get("content-type") ?? "").includes("text/event-stream")) {
+            controller.abort();
+            throw new Error(`mcp server "${this.#name}" legacy SSE stream failed: ${response.status} ${response.statusText}`);
+        }
+        const sessionHeader = response.headers.get("mcp-session-id");
+        if (sessionHeader !== null && sessionHeader !== "") {
+            this.#sessionId = sessionHeader;
+        }
+        // Read the stream; the endpoint event flips #messageUrl, frames feed
+        // the engine, stream end is transport death.
+        const reader = response.body?.getReader();
+        if (reader === undefined) {
+            throw new Error(`mcp server "${this.#name}" legacy SSE stream has no body`);
+        }
+        const parser = new SseParser();
+        const decoder = new TextDecoder();
+        const engine = this.#engine;
+        const self = this;
+        // The endpoint usually arrives first; race a bounded wait so a
+        // silent server cannot hang the connect forever (the engine's own
+        // initialize deadline still applies on top).
+        const endpointSeen = new Promise((resolveEndpoint) => {
+            void (async () => {
+                try {
+                    for (;;) {
+                        const { done, value } = await reader.read();
+                        if (done)
+                            break;
+                        parser.feed(decoder.decode(value, { stream: true }), (frame) => engine.handleFrame(frame), (endpoint) => {
+                            self.#messageUrl = new URL(endpoint, self.#url).toString();
+                            resolveEndpoint();
+                        });
+                    }
+                    const tail = decoder.decode();
+                    if (tail !== "") {
+                        parser.feed(tail, (frame) => engine.handleFrame(frame), (endpoint) => {
+                            self.#messageUrl = new URL(endpoint, self.#url).toString();
+                            resolveEndpoint();
+                        });
+                    }
+                    engine.handleDeath(new Error(`mcp server "${self.#name}" legacy SSE stream ended`));
+                }
+                catch (cause) {
+                    if (self.#closed)
+                        return; // our own abort: not a failure
+                    engine.handleDeath(cause instanceof Error
+                        ? cause
+                        : new Error(`mcp server "${self.#name}" SSE stream failed`));
+                }
+            })();
+        });
+        // A 15s cap on waiting for the endpoint event — plenty for any
+        // compliant server, and short enough to fail loud on a broken one.
+        await Promise.race([
+            endpointSeen,
+            new Promise((_resolve, reject) => setTimeout(() => reject(new Error(`mcp server "${this.#name}" legacy SSE stream announced no endpoint within 15s`)), 15_000)),
+        ]);
+    }
+    #closeHooks = new Set();
+    close() {
+        if (this.#closed)
+            return;
+        this.#closed = true;
+        for (const hook of this.#closeHooks)
+            hook();
+        this.#closeHooks.clear();
+        this.#getController?.abort();
+        this.#engine.handleDeath(new Error("mcp client closed"));
     }
 }
 /**
- * Spawn and connect one configured MCP server. Throws on spawn failure or a
- * failed handshake — per-server isolation is the CALLER's policy (the
- * extension connects all servers with `.catch` per server).
+ * Spawn/connect one configured MCP server (stdio or remote by config
+ * shape). Throws on spawn/connect failure or a failed handshake —
+ * per-server isolation is the CALLER's policy (the extension connects all
+ * servers with `.catch` per server).
  */
 export async function connectMcpServer(name, config) {
-    const child = spawn(config.command, [...config.args], {
-        stdio: ["pipe", "pipe", "pipe"],
+    let engine;
+    if ("url" in config) {
+        const transport = new HttpTransport(name, config);
+        engine = transport.engine;
+    }
+    else {
         // Token injection (ruling 3): a server with an oauth block AND a stored
         // token gets it as MCP_ACCESS_TOKEN, merged over the server's own env.
-        env: { ...process.env, ...spawnEnvWithToken(name, config) },
-    });
-    const client = new McpClient(name, child);
+        const env = { ...process.env, ...spawnEnvWithToken(name, config) };
+        const transport = new StdioTransport(name, config.command, config.args, env);
+        engine = transport.engine;
+    }
     try {
-        await client.handshake();
+        await engine.handshake();
     }
     catch (cause) {
-        client.close();
-        child.kill("SIGKILL");
+        engine.close();
         throw cause instanceof Error
             ? cause
             : new Error(`mcp server "${name}" handshake failed`);
     }
-    return client;
+    return engine;
 }

package/dist/config.d.ts

@@ -34,14 +34,8 @@ export declare function resolveToolExposure(server: McpServerConfig, toolName: s
  * `disabled: true` both skip it (parse-time validation rejects
  * contradictions, so either false simply means off). */
 export declare function serverEnabled(server: McpServerConfig): boolean;
-/** One configured MCP server (stdio transport). */
-export interface McpServerConfig {
-    /** The executable to spawn. */
-    readonly command: string;
-    /** Arguments to the executable. */
-    readonly args: readonly string[];
-    /** Extra environment variables for the child process. */
-    readonly env?: Readonly<Record<string, string>>;
+/** Fields every server variant carries regardless of transport. */
+interface McpServerCommon {
     /** Skip this server entirely (default false). */
     readonly disabled?: boolean;
     /** Skip this server entirely (default true; contradicts `disabled`). */
@@ -53,10 +47,31 @@ export interface McpServerConfig {
     readonly toolExposure?: Readonly<Record<string, McpExposure>>;
     /** Per-request wire timeout in seconds (default 60). */
     readonly timeout?: number;
+}
+/** One configured MCP server (stdio transport). */
+export interface McpStdioServerConfig extends McpServerCommon {
+    /** The executable to spawn. */
+    readonly command: string;
+    /** Arguments to the executable. */
+    readonly args: readonly string[];
+    /** Extra environment variables for the child process. */
+    readonly env?: Readonly<Record<string, string>>;
     /** OAuth (T3c): when present, `sigrun-ext-mcp oauth <name>` can mint a
      * token and spawn injects it as `MCP_ACCESS_TOKEN` (see tokens.ts). */
     readonly oauth?: McpOAuthConfig;
 }
+/** One configured MCP server (remote transport: streamable HTTP, with a
+ * legacy-SSE fallback negotiated on first contact). */
+export interface McpUrlServerConfig extends McpServerCommon {
+    /** The server endpoint (http/https). */
+    readonly url: string;
+    /** Extra request headers (auth etc.), sent on every request. */
+    readonly headers?: Readonly<Record<string, string>>;
+}
+/** One configured MCP server: stdio OR remote. */
+export type McpServerConfig = McpStdioServerConfig | McpUrlServerConfig;
+/** Narrow to the stdio variant (the spawn path). */
+export declare function isStdioServer(server: McpServerConfig): server is McpStdioServerConfig;
 /** OAuth block for one server: how to run the authorization-code flow. */
 export interface McpOAuthConfig {
     /** The AS's authorize endpoint (GET; the user opens this in a browser). */
@@ -76,7 +91,13 @@ export interface McpConfig {
 }
 /** The env override the config store reads. */
 export declare const MCP_CONFIG_ENV = "SIGRUN_MCP_CONFIG";
-/** Resolve the config path without reading it (for diagnostics). */
+/** Resolve the config path without reading it (for diagnostics).
+ *
+ * Resolution order: the `SIGRUN_MCP_CONFIG` override → the sigrun config
+ * dir (`SIGRUN_CONFIG_DIR`, the SAME root every sigrun store resolves
+ * through — a deployment setting one sets them all) → `~/.config/sigrun`
+ * (the pre-deployment fallback, kept so a bare user install keeps
+ * working). */
 export declare function resolveMcpConfigPath(env?: NodeJS.ProcessEnv): string;
 /**
  * Parse and validate an `mcp.json` body. Throws a clear error naming the
@@ -89,3 +110,4 @@ export declare function parseMcpConfig(text: string, source: string): McpConfig;
  * nothing); an existing-but-malformed file throws.
  */
 export declare function loadMcpConfig(env?: NodeJS.ProcessEnv): McpConfig;
+export {};

package/dist/config.js

@@ -16,7 +16,7 @@
  */
 import { existsSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
-import { isAbsolute, resolve } from "node:path";
+import { isAbsolute, join, resolve } from "node:path";
 /** Config-level exposure words: the four real ones plus pi's `codemode-deferred`
  * alias (normalized to "codemode" at parse time — pi compat). */
 const EXPOSURE_WORDS = [
@@ -85,15 +85,29 @@ export function resolveToolExposure(server, toolName) {
 export function serverEnabled(server) {
     return server.enabled !== false && server.disabled !== true;
 }
+/** Narrow to the stdio variant (the spawn path). */
+export function isStdioServer(server) {
+    return "command" in server;
+}
 /** The env override the config store reads. */
 export const MCP_CONFIG_ENV = "SIGRUN_MCP_CONFIG";
-/** Resolve the config path without reading it (for diagnostics). */
+/** Resolve the config path without reading it (for diagnostics).
+ *
+ * Resolution order: the `SIGRUN_MCP_CONFIG` override → the sigrun config
+ * dir (`SIGRUN_CONFIG_DIR`, the SAME root every sigrun store resolves
+ * through — a deployment setting one sets them all) → `~/.config/sigrun`
+ * (the pre-deployment fallback, kept so a bare user install keeps
+ * working). */
 export function resolveMcpConfigPath(env = process.env) {
     const override = env[MCP_CONFIG_ENV];
     if (override !== undefined && override !== "") {
         // A relative override resolves against cwd, like sigrun's other paths.
         return isAbsolute(override) ? override : resolve(override);
     }
+    const configDir = env.SIGRUN_CONFIG_DIR;
+    if (configDir !== undefined && configDir !== "") {
+        return join(configDir, "mcp.json");
+    }
     return resolve(homedir(), ".config", "sigrun", "mcp.json");
 }
 function isRecord(value) {
@@ -123,7 +137,28 @@ export function parseMcpConfig(text, source) {
         if (!isRecord(entry)) {
             throw new Error(`mcp config ${source}: server "${name}" must be an object`);
         }
-        if (typeof entry.command !== "string" ||
+        // Transport dispatch: a server is EITHER a stdio child or a remote
+        // endpoint. Both arms share the optional fields below; each arm then
+        // validates its own required fields.
+        const hasCommand = entry.command !== undefined || entry.args !== undefined;
+        const hasUrl = entry.url !== undefined;
+        if (hasCommand && hasUrl) {
+            throw new Error(`mcp config ${source}: server "${name}" cannot carry both "command" (stdio) and "url" (remote) — pick one transport`);
+        }
+        if (!hasCommand && !hasUrl) {
+            throw new Error(`mcp config ${source}: server "${name}" needs either "command"+"args" (stdio) or "url" (remote)`);
+        }
+        if (hasUrl) {
+            if (typeof entry.url !== "string" || !/^https?:\/\//.test(entry.url)) {
+                throw new Error(`mcp config ${source}: server "${name}" url must be an http(s) URL`);
+            }
+            if (entry.headers !== undefined &&
+                (!isRecord(entry.headers) ||
+                    Object.values(entry.headers).some((v) => typeof v !== "string"))) {
+                throw new Error(`mcp config ${source}: server "${name}" headers must map strings to strings`);
+            }
+        }
+        else if (typeof entry.command !== "string" ||
             !Array.isArray(entry.args) ||
             entry.args.some((arg) => typeof arg !== "string")) {
             throw new Error(`mcp config ${source}: server "${name}" needs a string "command" and a string[] "args"`);
@@ -169,19 +204,33 @@ export function parseMcpConfig(text, source) {
         const oauth = entry.oauth === undefined
             ? undefined
             : parseOauthEntry(entry.oauth, source, name);
-        servers[name] = {
-            command: entry.command,
-            args: entry.args,
-            ...(entry.env === undefined
-                ? {}
-                : { env: entry.env }),
-            ...(entry.disabled === undefined ? {} : { disabled: entry.disabled }),
-            ...(entry.enabled === undefined ? {} : { enabled: entry.enabled }),
-            ...(exposure === undefined ? {} : { exposure }),
-            ...(toolExposure === undefined ? {} : { toolExposure }),
-            ...(entry.timeout === undefined ? {} : { timeout: entry.timeout }),
-            ...(oauth === undefined ? {} : { oauth }),
-        };
+        // The common optionals first, then the transport arm's own fields —
+        // the union stays discriminable by "command" vs "url" presence.
+        servers[name] = hasUrl
+            ? {
+                url: entry.url,
+                ...(entry.headers === undefined
+                    ? {}
+                    : { headers: entry.headers }),
+                ...(entry.disabled === undefined ? {} : { disabled: entry.disabled }),
+                ...(entry.enabled === undefined ? {} : { enabled: entry.enabled }),
+                ...(exposure === undefined ? {} : { exposure }),
+                ...(toolExposure === undefined ? {} : { toolExposure }),
+                ...(entry.timeout === undefined ? {} : { timeout: entry.timeout }),
+            }
+            : {
+                command: entry.command,
+                args: entry.args,
+                ...(entry.env === undefined
+                    ? {}
+                    : { env: entry.env }),
+                ...(entry.disabled === undefined ? {} : { disabled: entry.disabled }),
+                ...(entry.enabled === undefined ? {} : { enabled: entry.enabled }),
+                ...(exposure === undefined ? {} : { exposure }),
+                ...(toolExposure === undefined ? {} : { toolExposure }),
+                ...(entry.timeout === undefined ? {} : { timeout: entry.timeout }),
+                ...(oauth === undefined ? {} : { oauth }),
+            };
     }
     return { servers };
 }

package/dist/extension.js

@@ -27,7 +27,7 @@
 import { Type } from "@earendil-works/pi-ai";
 import { defineExtension, defineTool, } from "@earendil-works/pi-durable";
 import { connectMcpServer } from "./client.js";
-import { loadMcpConfig, resolveToolExposure, serverEnabled, } from "./config.js";
+import { isStdioServer, loadMcpConfig, resolveToolExposure, serverEnabled, } from "./config.js";
 import { MCP_SERVERS_SECTION_KEY, partitionForSection, renderMcpServersSection, } from "./section.js";
 /** The extension's pi-durable registry name. */
 export const MCP_EXTENSION_NAME = "sigrun.mcp";
@@ -132,9 +132,12 @@ export function createMcpExtension() {
                     tools.push(mcpTool(name, tool, client, exposure, server.timeout));
                 }
                 if (mix.count > 0 && (mix.codemode || mix.deferred)) {
+                    const origin = isStdioServer(server)
+                        ? `${server.command} ${server.args.join(" ")}`.trim()
+                        : server.url;
                     serverExposures.set(name, {
                         ...mix,
-                        description: `${mix.count} tool${mix.count === 1 ? "" : "s"} from ${server.command} ${server.args.join(" ")}`.trim(),
+                        description: `${mix.count} tool${mix.count === 1 ? "" : "s"} from ${origin}`.trim(),
                     });
                 }
             }

package/dist/index.js

@@ -1,6 +1,6 @@
 /** sigrun-ext-mcp: register MCP server tools as pi-durable tools. */
 export { createMcpExtension, MCP_EXTENSION_NAME } from "./extension.js";
-export { connectMcpServer, McpClient } from "./client.js";
+export { connectMcpServer } from "./client.js";
 export { loadMcpConfig, MCP_CONFIG_ENV, parseMcpConfig, resolveMcpConfigPath, } from "./config.js";
 export { loadMcpTokens, MCP_ACCESS_TOKEN_ENV, parseMcpTokenStore, resolveMcpTokenPath, saveMcpTokens, spawnEnvWithToken, storeMcpToken, } from "./tokens.js";
 export { buildAuthorizeUrl, exchangeCode, extractCode, makePkcePair, startOauth, } from "./oauth.js";

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@sigrun/ext-mcp",
-	"version": "0.1.0",
+	"version": "0.2.0",
 	"description": "MCP extension for sigrun (pi-durable): registers MCP server tools as <server>/<toolname> tools",
 	"type": "module",
 	"engines": {