@prereason/mcp 0.4.0 → 0.5.0

package/CHANGELOG.md

@@ -1,6 +1,23 @@
 # Changelog
 
-## 0.4.0 (unreleased)
+## 0.5.0 (2026-09-21)
+
+### Removed
+- `@modelcontextprotocol/sdk`, the only dependency. The bridge now installs nothing. It used the SDK for two classes, `StdioServerTransport` and `StreamableHTTPClientTransport`, and paid 91 packages and 25 MB on disk for them: Express, Hono, CORS, `express-rate-limit`, `jose`, `pkce-challenge`, `ajv`, `zod` and the rest are the SDK server and OAuth halves, and a relay calls none of them. The published tarball is 23 KB, `npm ls` is one line, and the code a security review has to read is the code in this repository.
+
+### Added
+- `lib/stdio.js`: newline delimited JSON-RPC over stdin and stdout, with the SDK framing kept exactly, including the 10 MB line ceiling, the carriage return before the newline, and the rule that a line which will not parse is reported and skipped rather than ending the session.
+- `lib/streamable-http.js`: the Streamable HTTP client. POST a frame, read the answer as JSON or as an event stream, carry `Mcp-Session-Id` onto later requests, open the optional GET stream once the session is initialized, and treat a 405 there as the server saying it has none, which is what PreReason answers. Headers are read from `requestInit` on every request rather than copied once, because the claim flow attaches `Authorization` to that same object after the transport has started.
+- `lib/sse.js`: a Server-Sent Events decoder following the same buffering rules as `eventsource-parser`, including the carriage return split across two chunks that would otherwise turn one event into two.
+- `lib/jsonrpc.js`: the shape check that replaces the SDK zod schema. A relay has no reason to validate methods or params, only to be sure it is not writing a bare string to a host that would treat the stream as corrupt.
+- `test/` grows to 71 cases across six files, among them `test/bridge.test.js`, which spawns `bin/cli.js` against a stub server and asserts on the headers that reach the wire. The suite runs on an empty `node_modules`, which is the proof there is nothing left to install.
+
+### Changed
+- `socket.yml` describes this package own code and nothing else, and says in the file what it is for: it configures the Socket GitHub app and CLI for this repository, and has no effect on the public package score.
+- `server.json` registry version 0.8.2, npm package 0.5.0.
+
+
+## 0.4.0 (2026-09-21)
 
 ### Added
 - The bridge gets its own key. With no `PREREASON_API_KEY` and no saved key it asks PreReason for access, prints one link to stderr (`Open https://www.prereason.com/claim/PR-XXXX-XXXX to approve access`), keeps serving the free tools, and polls until the person approves. The key arrives once, is saved to `~/.prereason/credentials.json` (0700 directory, 0600 file on POSIX; Windows has no mode bits), and is attached to the running connection without a restart. While the link is pending, any `AUTH_REQUIRED` tool result starts with `Approve at <link>` so the assistant can relay it, because a person inside Claude Desktop never sees this process's stderr.

package/README.md

@@ -7,6 +7,7 @@
 [![node version](https://img.shields.io/node/v/@prereason/mcp.svg)](https://nodejs.org)
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
 [![Glama Score](https://glama.ai/mcp/servers/PreReason/mcp/badges/score.svg)](https://glama.ai/mcp/servers/PreReason/mcp)
+[![Smithery](https://img.shields.io/badge/Smithery-listed-7c3aed)](https://smithery.ai/servers/prereason/briefings)
 
 **MCP server for [PreReason](https://www.prereason.com).**
 
@@ -14,13 +15,13 @@ Bitcoin and macro market briefings for AI agents: trend signals, regimes, liquid
 
 </div>
 
-PreReason gives an AI agent market context it can reason with, in place of raw numbers. One call returns a briefing on Bitcoin, macro liquidity, FX or the links between assets, and the analysis is already in it: a signal line, trend direction over several windows, a regime label, confidence scores, percentile ranks, correlations and a plain language narrative. The catalogue holds 18 live briefings and 119 individual metrics, covering Bitcoin price and momentum, network and miner health, spot Bitcoin ETF flows, corporate Bitcoin treasuries, the Fed balance sheet, M2, net liquidity, Treasury yields and the dollar. It is served over MCP (a remote server and an npm bridge) and over REST, as Markdown or JSON. The catalogue tools need no key, and an agent can get a free key from inside the session: it shows one link, a person approves it, and the key arrives.
+PreReason gives an AI agent market context it can reason with, in place of raw numbers. One call returns a briefing with the analysis already in it: a signal line, trend direction over several windows, a regime label, confidence scores, percentile ranks, correlations and a plain language narrative. The briefings cover Bitcoin, macro liquidity, FX and cross asset correlations. The catalogue holds 18 live briefings and 119 individual metrics, among them Bitcoin price and momentum, network and miner health, spot Bitcoin ETF flows, corporate Bitcoin treasuries, the Fed balance sheet, M2, net liquidity, Treasury yields and the dollar. It is served over MCP (a remote server and an npm bridge) and over REST, as Markdown or JSON. The catalogue tools need no key, and an agent can get a free key from inside the session: it shows one link, a person approves it, and the key arrives.
 
 ## Quick Start
 
 ### Option 1: Claude Desktop, no key needed
 
-**Requires [Node.js 18+](https://nodejs.org)**
+**Requires [Node.js 18+](https://nodejs.org), and nothing else: the bridge has no dependencies.**
 
 Add this to `claude_desktop_config.json` and restart Claude Desktop:
 
@@ -212,6 +213,12 @@ Key precedence: `PREREASON_API_KEY`, then `--header`, then the credentials file
 
 `mcpb/manifest.json` describes the same bridge as a single click Claude Desktop extension, key optional. To build the bundle: `npm install --omit=dev`, then `npx @anthropic-ai/mcpb pack .` from the package directory, and install the resulting `.mcpb` by double clicking it. Submission to the Claude directory goes through the desktop extension form and is a publisher decision.
 
+## No dependencies
+
+The bridge ships its own transports and installs nothing. `npm ls` on it is one line, `npx @prereason/mcp` fetches one 23 KB tarball and starts, and the code a security review has to read is the code in this repository.
+
+It used to depend on `@modelcontextprotocol/sdk` for two classes, a stdio transport and a Streamable HTTP client. That pulled in 91 packages and 25 MB on disk, nearly all of it the SDK server half: Express, Hono, CORS, a rate limiter, an OAuth client and a schema validator, none of which a relay ever calls. `lib/stdio.js` and `lib/streamable-http.js` replace the two classes the bridge used, keep their framing and their callbacks, and are covered by the suite under `test/`.
+
 ## Links
 
 - [Documentation](https://www.prereason.com/docs#mcp)

package/bin/cli.js

@@ -27,14 +27,14 @@
  */
 
 import { platform } from 'node:os';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+import { StdioServerTransport } from '../lib/stdio.js';
+import { StreamableHttpClientTransport } from '../lib/streamable-http.js';
 import { credentialsPath, deleteCredentials, parseArgs, resolveApiKey } from '../lib/credentials.js';
 import { decorateAuthRequired, runClaimFlow } from '../lib/claim.js';
 
 // Keep in sync with package.json on each release
 const PKG_NAME = '@prereason/mcp';
-const PKG_VERSION = '0.4.0';
+const PKG_VERSION = '0.5.0';
 const DEFAULT_URL = 'https://api.prereason.com/api/mcp';
 const USER_AGENT = `prereason-mcp/${PKG_VERSION} node/${process.versions.node} (${platform()})`;
 
@@ -113,7 +113,7 @@ if (args.login) {
 
 // --- Transports: stdio to the host, Streamable HTTP to PreReason ---
 const stdio = new StdioServerTransport();
-const http = new StreamableHTTPClientTransport(url, { requestInit: { headers } });
+const http = new StreamableHttpClientTransport(url, { requestInit: { headers } });
 
 /** While a claim is pending, the approve link the tool results carry. */
 const pending = { approveUrl: null, claimCode: null };

package/lib/jsonrpc.js

@@ -0,0 +1,60 @@
+/**
+ * The smallest shape check that keeps garbage out of the relay.
+ *
+ * The bridge forwards JSON-RPC frames between a stdio host and PreReason's
+ * HTTP endpoint without reading them, so it has no reason to validate methods
+ * or params, and no reason to carry a schema library to do it. It only has to
+ * be sure that what it forwards is a JSON-RPC object: a host that receives a
+ * bare string or a number on stdout treats the stream as corrupt and drops the
+ * connection, which is the one failure the relay must not cause itself.
+ */
+
+/** A single JSON-RPC 2.0 frame: an object, not an array, tagged "2.0". */
+export function isJsonRpcMessage(value) {
+  return typeof value === 'object' && value !== null && !Array.isArray(value) && value.jsonrpc === '2.0';
+}
+
+/**
+ * Throws on anything that is not one JSON-RPC message.
+ *
+ * Used on the stdio side, which is framed one message per line and has never
+ * carried a batch.
+ */
+export function assertJsonRpcMessage(value) {
+  if (!isJsonRpcMessage(value)) {
+    throw new Error('not a JSON-RPC 2.0 message');
+  }
+  return value;
+}
+
+/**
+ * Throws on anything that is not a JSON-RPC message or an array of them.
+ *
+ * Used on the HTTP side. Batching left the MCP spec in 2025-06-18, but a
+ * server is still free to answer with an array and the relay should pass it
+ * on rather than decide the stream is broken.
+ */
+export function assertJsonRpcPayload(value) {
+  if (Array.isArray(value)) {
+    if (value.length === 0) {
+      throw new Error('empty JSON-RPC batch');
+    }
+    for (const entry of value) {
+      if (!isJsonRpcMessage(entry)) {
+        throw new Error('batch entry is not a JSON-RPC 2.0 message');
+      }
+    }
+    return value;
+  }
+  return assertJsonRpcMessage(value);
+}
+
+/**
+ * True when the frame expects an answer, which is what decides whether a POST
+ * reads a response body or just releases the connection. A notification has a
+ * method and no id; a response has an id and no method.
+ */
+export function expectsResponse(message) {
+  const frames = Array.isArray(message) ? message : [message];
+  return frames.some((frame) => typeof frame === 'object' && frame !== null && 'method' in frame && 'id' in frame && frame.id !== undefined);
+}

package/lib/sse.js

@@ -0,0 +1,170 @@
+/**
+ * A Server-Sent Events decoder, sized for this bridge.
+ *
+ * PreReason's own endpoint answers POST with application/json and 405s a GET,
+ * so nothing here runs against api.prereason.com today. It exists because
+ * PREREASON_URL can point the bridge at any Streamable HTTP server, and the
+ * transport half of that spec is allowed to answer a POST with an event
+ * stream. Keeping the decoder costs forty lines and keeps the bridge honest
+ * against a server that does.
+ *
+ * The field rules are the WHATWG ones, and the buffering rules follow
+ * eventsource-parser, which is what the MCP SDK used before this file
+ * replaced it:
+ *
+ *   a blank line dispatches, and only if data was collected
+ *   data lines join with a newline, and one trailing newline is dropped
+ *   one space after the colon is part of the separator, not the value
+ *   a line with no colon is a field with an empty value
+ *   an id holding a NUL is discarded, and id does not survive a dispatch
+ *   a line starting with a colon is a comment, which is how servers keep alive
+ */
+
+/** Split text into complete lines plus the tail that has not ended yet. */
+function splitLines(chunk) {
+  const lines = [];
+  let index = 0;
+
+  while (index < chunk.length) {
+    const cr = chunk.indexOf('\r', index);
+    const lf = chunk.indexOf('\n', index);
+    let end = -1;
+
+    if (cr !== -1 && lf !== -1) {
+      end = Math.min(cr, lf);
+    } else if (cr !== -1) {
+      // A lone carriage return at the very end may be the first half of a
+      // CRLF that the next chunk completes, so hold the line back.
+      end = cr === chunk.length - 1 ? -1 : cr;
+    } else if (lf !== -1) {
+      end = lf;
+    }
+
+    if (end === -1) {
+      return [lines, chunk.slice(index)];
+    }
+
+    lines.push(chunk.slice(index, end));
+    index = end + 1;
+    if (chunk[index - 1] === '\r' && chunk[index] === '\n') {
+      index += 1;
+    }
+  }
+
+  return [lines, ''];
+}
+
+export class SseDecoder {
+  #incomplete = '';
+  #data = '';
+  #eventType = '';
+  #id;
+  #onRetry;
+
+  constructor({ onRetry } = {}) {
+    this.#onRetry = onRetry;
+  }
+
+  /**
+   * Feed one decoded text chunk and get back the events that completed inside
+   * it. A chunk may end mid line, so the tail is carried to the next call.
+   */
+  push(text) {
+    const [lines, incomplete] = splitLines(this.#incomplete + text);
+    this.#incomplete = incomplete;
+
+    const events = [];
+    for (const line of lines) {
+      const event = this.#readLine(line);
+      if (event) {
+        events.push(event);
+      }
+    }
+    return events;
+  }
+
+  #readLine(line) {
+    if (line === '') {
+      return this.#dispatch();
+    }
+    if (line.startsWith(':')) {
+      return null;
+    }
+
+    const separator = line.indexOf(':');
+    if (separator === -1) {
+      this.#setField(line, '');
+      return null;
+    }
+
+    const offset = line[separator + 1] === ' ' ? 2 : 1;
+    this.#setField(line.slice(0, separator), line.slice(separator + offset));
+    return null;
+  }
+
+  #setField(field, value) {
+    if (field === 'data') {
+      this.#data += `${value}\n`;
+    } else if (field === 'event') {
+      this.#eventType = value;
+    } else if (field === 'id') {
+      this.#id = value.includes('\u0000') ? undefined : value;
+    } else if (field === 'retry' && /^\d+$/.test(value)) {
+      this.#onRetry?.(Number.parseInt(value, 10));
+    }
+    // Any other field is ignored, which is what the spec asks for.
+  }
+
+  #dispatch() {
+    const data = this.#data;
+    const event = this.#eventType;
+    const id = this.#id;
+
+    this.#data = '';
+    this.#eventType = '';
+    this.#id = undefined;
+
+    if (data.length === 0) {
+      return null;
+    }
+    return {
+      id,
+      event: event || undefined,
+      data: data.endsWith('\n') ? data.slice(0, -1) : data,
+    };
+  }
+}
+
+/**
+ * Read an event stream body to the end, handing each event to onEvent.
+ *
+ * Takes the reader rather than the stream so the caller keeps the handle it
+ * needs to cancel, and decodes with TextDecoder rather than piping through a
+ * TextDecoderStream, because a multi byte character may straddle two chunks
+ * and { stream: true } is what carries the partial one across.
+ */
+export async function readEventStream(body, { onEvent, onRetry } = {}) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  const sse = new SseDecoder({ onRetry });
+
+  try {
+    while (true) {
+      const { value, done } = await reader.read();
+      if (done) {
+        break;
+      }
+      for (const event of sse.push(decoder.decode(value, { stream: true }))) {
+        onEvent?.(event);
+      }
+    }
+    // Flush any half decoded character. An event the server never terminated
+    // with a blank line is dropped on purpose: its data is a truncated frame,
+    // and forwarding half a JSON-RPC message is worse than losing it.
+    for (const event of sse.push(decoder.decode())) {
+      onEvent?.(event);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}

package/lib/stdio.js

@@ -0,0 +1,149 @@
+/**
+ * The stdio half of the bridge: newline delimited JSON-RPC over this process's
+ * stdin and stdout, which is the transport Claude Desktop and every other
+ * stdio only host speaks.
+ *
+ * This is a direct replacement for StdioServerTransport in
+ * @modelcontextprotocol/sdk, kept to the same framing and the same callback
+ * surface (onmessage, onerror, onclose) so bin/cli.js wires it up unchanged.
+ * It is here rather than imported because the SDK cannot ship that class on
+ * its own: taking it pulled in 90 packages and 22 MB, every one of them for
+ * the server and OAuth code a relay never reaches.
+ */
+
+import process from 'node:process';
+import { assertJsonRpcMessage } from './jsonrpc.js';
+
+/** One line in, one frame out, throwing on anything that is not a frame. */
+export function deserializeLine(line) {
+  return assertJsonRpcMessage(JSON.parse(line));
+}
+
+/** Ten megabytes, the SDK's ceiling. A line longer than this is not a frame. */
+export const MAX_BUFFER_SIZE = 10 * 1024 * 1024;
+
+/** Buffers a byte stream into whole lines, each of which is one JSON-RPC frame. */
+export class ReadBuffer {
+  #buffer;
+  #maxBufferSize;
+
+  constructor({ maxBufferSize = MAX_BUFFER_SIZE } = {}) {
+    this.#maxBufferSize = maxBufferSize;
+  }
+
+  append(chunk) {
+    const size = (this.#buffer?.length ?? 0) + chunk.length;
+    if (size > this.#maxBufferSize) {
+      this.clear();
+      throw new Error(`ReadBuffer exceeded maximum size of ${this.#maxBufferSize} bytes`);
+    }
+    this.#buffer = this.#buffer ? Buffer.concat([this.#buffer, chunk]) : chunk;
+  }
+
+  /** The next whole line as a parsed frame, or null while one is still arriving. */
+  readMessage(deserialize) {
+    if (!this.#buffer) {
+      return null;
+    }
+    const newline = this.#buffer.indexOf('\n');
+    if (newline === -1) {
+      return null;
+    }
+    const line = this.#buffer.toString('utf8', 0, newline).replace(/\r$/, '');
+    this.#buffer = this.#buffer.subarray(newline + 1);
+    return deserialize(line);
+  }
+
+  clear() {
+    this.#buffer = undefined;
+  }
+}
+
+export class StdioServerTransport {
+  #stdin;
+  #stdout;
+  #readBuffer;
+  #started = false;
+  #deserialize;
+
+  onmessage;
+  onerror;
+  onclose;
+
+  /**
+   * @param deserialize turns one line into a frame and throws on anything
+   *   that is not one. Injected so the shape check lives in one place and the
+   *   tests can drive the framing without it.
+   */
+  constructor({ stdin = process.stdin, stdout = process.stdout, maxBufferSize, deserialize = deserializeLine } = {}) {
+    this.#stdin = stdin;
+    this.#stdout = stdout;
+    this.#readBuffer = new ReadBuffer({ maxBufferSize });
+    this.#deserialize = deserialize;
+  }
+
+  // Arrow properties, so the same function identity comes off the emitter in
+  // close() as went on in start().
+  #ondata = (chunk) => {
+    try {
+      this.#readBuffer.append(chunk);
+      this.#drainReadBuffer();
+    } catch (error) {
+      this.onerror?.(error);
+      this.close().catch(() => {});
+    }
+  };
+
+  #onstdinerror = (error) => {
+    this.onerror?.(error);
+  };
+
+  async start() {
+    if (this.#started) {
+      throw new Error('StdioServerTransport already started');
+    }
+    this.#started = true;
+    this.#stdin.on('data', this.#ondata);
+    this.#stdin.on('error', this.#onstdinerror);
+  }
+
+  /**
+   * A frame that will not parse is reported and skipped, never fatal: one bad
+   * line from the host must not take down a session whose next line is fine.
+   */
+  #drainReadBuffer() {
+    while (true) {
+      try {
+        const message = this.#readBuffer.readMessage(this.#deserialize);
+        if (message === null) {
+          return;
+        }
+        this.onmessage?.(message);
+      } catch (error) {
+        this.onerror?.(error);
+      }
+    }
+  }
+
+  async close() {
+    this.#stdin.off('data', this.#ondata);
+    this.#stdin.off('error', this.#onstdinerror);
+    // Only pause stdin if nothing else is reading it, so the bridge never
+    // stalls a host that shares the descriptor.
+    if (this.#stdin.listenerCount('data') === 0) {
+      this.#stdin.pause();
+    }
+    this.#readBuffer.clear();
+    this.onclose?.();
+  }
+
+  send(message) {
+    return new Promise((resolve) => {
+      if (this.#stdout.write(`${JSON.stringify(message)}\n`)) {
+        resolve();
+      } else {
+        this.#stdout.once('drain', resolve);
+      }
+    });
+  }
+}

package/lib/streamable-http.js

@@ -0,0 +1,302 @@
+/**
+ * The HTTP half of the bridge: MCP Streamable HTTP, client side.
+ *
+ * A direct replacement for StreamableHTTPClientTransport in
+ * @modelcontextprotocol/sdk, narrowed to what a relay does. It POSTs a frame,
+ * reads the answer as JSON or as an event stream, carries Mcp-Session-Id back
+ * on later requests, and opens the optional GET stream once the session is
+ * initialized. The SDK's OAuth client, its schema validation and its session
+ * termination are gone: the bridge authenticates with a bearer header it is
+ * handed, forwards frames without reading them, and is torn down by the host
+ * closing stdin.
+ *
+ * Headers are read from requestInit on every request rather than copied once,
+ * because the claim flow attaches Authorization to that same object minutes
+ * after the transport started, and the next request has to carry it.
+ */
+
+import { assertJsonRpcPayload, expectsResponse } from './jsonrpc.js';
+import { readEventStream } from './sse.js';
+
+/** The SDK's reconnection defaults, kept so a resumable server sees no change. */
+const RECONNECT = {
+  initialDelayMs: 1000,
+  maxDelayMs: 30_000,
+  growthFactor: 1.5,
+  maxRetries: 2,
+};
+
+export class StreamableHttpError extends Error {
+  constructor(code, message) {
+    super(`Streamable HTTP error: ${message}`);
+    this.name = 'StreamableHttpError';
+    this.code = code;
+  }
+}
+
+/** "application/json; charset=utf-8" is the same media type as "application/json". */
+function mediaType(contentType) {
+  return (contentType ?? '').split(';')[0].trim().toLowerCase();
+}
+
+/** Headers arrive as an object, a Headers, or an array of pairs. */
+function toPlainHeaders(headers) {
+  if (!headers) {
+    return {};
+  }
+  if (headers instanceof Headers) {
+    return Object.fromEntries(headers.entries());
+  }
+  if (Array.isArray(headers)) {
+    return Object.fromEntries(headers);
+  }
+  return { ...headers };
+}
+
+/** Release a body we are not going to read, so the socket goes back to the pool. */
+async function discard(response) {
+  try {
+    await response.body?.cancel();
+  } catch {
+    // A body already consumed or already errored needs nothing from us.
+  }
+}
+
+export class StreamableHttpClientTransport {
+  #url;
+  #requestInit;
+  #fetch;
+  #sessionId;
+  #abortController;
+  #reconnectTimer;
+  #serverRetryMs;
+
+  onmessage;
+  onerror;
+  onclose;
+
+  constructor(url, { requestInit, fetch: fetchImpl = fetch, sessionId } = {}) {
+    this.#url = url;
+    this.#requestInit = requestInit;
+    this.#fetch = fetchImpl;
+    this.#sessionId = sessionId;
+  }
+
+  get sessionId() {
+    return this.#sessionId;
+  }
+
+  async start() {
+    if (this.#abortController) {
+      throw new Error('StreamableHttpClientTransport already started');
+    }
+    this.#abortController = new AbortController();
+  }
+
+  async close() {
+    if (this.#reconnectTimer) {
+      clearTimeout(this.#reconnectTimer);
+      this.#reconnectTimer = undefined;
+    }
+    this.#abortController?.abort();
+    this.onclose?.();
+  }
+
+  /**
+   * The session header first, then whatever the caller configured, so a header
+   * passed with --header or set by the claim flow wins over ours.
+   */
+  #headers() {
+    const headers = new Headers();
+    if (this.#sessionId) {
+      headers.set('mcp-session-id', this.#sessionId);
+    }
+    for (const [name, value] of Object.entries(toPlainHeaders(this.#requestInit?.headers))) {
+      if (value !== undefined && value !== null) {
+        headers.set(name, String(value));
+      }
+    }
+    return headers;
+  }
+
+  async send(message) {
+    try {
+      const headers = this.#headers();
+      headers.set('content-type', 'application/json');
+      headers.set('accept', 'application/json, text/event-stream');
+
+      const response = await this.#fetch(this.#url, {
+        ...this.#requestInit,
+        method: 'POST',
+        headers,
+        body: JSON.stringify(message),
+        signal: this.#abortController?.signal,
+      });
+
+      // Stateful servers hand out a session on initialize and expect it back.
+      const sessionId = response.headers.get('mcp-session-id');
+      if (sessionId) {
+        this.#sessionId = sessionId;
+      }
+
+      if (!response.ok) {
+        const body = await response.text().catch(() => null);
+        throw new StreamableHttpError(response.status, `Error POSTing to endpoint: ${body}`);
+      }
+
+      if (response.status === 202) {
+        await discard(response);
+        // The server accepted the notification and said nothing back. Once the
+        // session is initialized, that is the moment to try the GET stream a
+        // server may use to push messages. PreReason 405s it, which is fine.
+        if (!Array.isArray(message) && message?.method === 'notifications/initialized') {
+          this.#openServerStream({}).catch((error) => this.onerror?.(error));
+        }
+        return;
+      }
+
+      if (!expectsResponse(message)) {
+        // Nothing was asked, so nothing is read. The body still has to be
+        // released or the connection is held open until it times out.
+        await discard(response);
+        return;
+      }
+
+      const type = mediaType(response.headers.get('content-type'));
+      if (type === 'application/json') {
+        this.#emit(await response.json());
+        return;
+      }
+      if (type === 'text/event-stream') {
+        // Not awaited: the answer arrives through onmessage as the stream
+        // yields it, and send() should not stay pending for a tool call that
+        // streams for a minute.
+        this.#readStream(response, { reconnectable: false }).catch((error) => this.onerror?.(error));
+        return;
+      }
+
+      await discard(response);
+      throw new StreamableHttpError(-1, `Unexpected content type: ${response.headers.get('content-type')}`);
+    } catch (error) {
+      this.onerror?.(error);
+      throw error;
+    }
+  }
+
+  /** One JSON payload, one or many frames, each forwarded to the host. */
+  #emit(payload) {
+    let frames;
+    try {
+      frames = assertJsonRpcPayload(payload);
+    } catch (error) {
+      this.onerror?.(error);
+      return;
+    }
+    for (const frame of Array.isArray(frames) ? frames : [frames]) {
+      this.onmessage?.(frame);
+    }
+  }
+
+  /**
+   * Read an event stream to the end, forwarding every message event.
+   *
+   * A frame that will not parse is reported and skipped rather than ending the
+   * stream, because the next event is usually fine.
+   */
+  async #readStream(response, { reconnectable, lastEventId: startingEventId }) {
+    let lastEventId = startingEventId;
+    let sawResponse = false;
+    let sawEventId = false;
+
+    try {
+      await readEventStream(response.body, {
+        onRetry: (retryMs) => {
+          this.#serverRetryMs = retryMs;
+        },
+        onEvent: (event) => {
+          if (event.id) {
+            lastEventId = event.id;
+            sawEventId = true;
+          }
+          if (event.event && event.event !== 'message') {
+            return;
+          }
+          let frame;
+          try {
+            frame = assertJsonRpcPayload(JSON.parse(event.data));
+          } catch (error) {
+            this.onerror?.(error);
+            return;
+          }
+          for (const one of Array.isArray(frame) ? frame : [frame]) {
+            if ('result' in one || 'error' in one) {
+              sawResponse = true;
+            }
+            this.onmessage?.(one);
+          }
+        },
+      });
+    } catch (error) {
+      this.onerror?.(new Error(`SSE stream disconnected: ${error}`));
+    }
+
+    // Reconnect the standalone GET stream, and a POST stream that carried an
+    // event id, which is the server saying where to resume from. Never once
+    // the answer has arrived: that request is finished, and reopening the
+    // stream would only replay it.
+    const canResume = reconnectable || sawEventId;
+    if (canResume && !sawResponse && this.#abortController && !this.#abortController.signal.aborted) {
+      this.#scheduleReconnect(lastEventId, 0);
+    }
+  }
+
+  #scheduleReconnect(lastEventId, attempt) {
+    if (attempt >= RECONNECT.maxRetries) {
+      this.onerror?.(new Error(`Maximum reconnection attempts (${RECONNECT.maxRetries}) exceeded.`));
+      return;
+    }
+    const backoff = RECONNECT.initialDelayMs * RECONNECT.growthFactor ** attempt;
+    const delay = this.#serverRetryMs ?? Math.min(backoff, RECONNECT.maxDelayMs);
+
+    this.#reconnectTimer = setTimeout(() => {
+      this.#openServerStream({ lastEventId }).catch((error) => {
+        this.onerror?.(new Error(`Failed to reconnect SSE stream: ${error instanceof Error ? error.message : String(error)}`));
+        this.#scheduleReconnect(lastEventId, attempt + 1);
+      });
+    }, delay);
+  }
+
+  /**
+   * Open the optional GET stream a server may use to push messages.
+   *
+   * 405 is the documented way for a server to say it has no such stream, and
+   * PreReason's endpoint answers exactly that, so it is a quiet return and not
+   * an error.
+   */
+  async #openServerStream({ lastEventId }) {
+    const headers = this.#headers();
+    headers.set('accept', 'text/event-stream');
+    if (lastEventId) {
+      headers.set('last-event-id', lastEventId);
+    }
+
+    const response = await this.#fetch(this.#url, {
+      ...this.#requestInit,
+      method: 'GET',
+      headers,
+      signal: this.#abortController?.signal,
+    });
+
+    if (!response.ok) {
+      await discard(response);
+      if (response.status === 405) {
+        return;
+      }
+      throw new StreamableHttpError(response.status, `Failed to open SSE stream: ${response.statusText}`);
+    }
+
+    // Not awaited: the stream runs for the life of the session while send()
+    // keeps working. Errors inside it go to onerror.
+    this.#readStream(response, { reconnectable: true, lastEventId }).catch((error) => this.onerror?.(error));
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prereason/mcp",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "mcpName": "com.prereason/mcp",
   "type": "module",
   "description": "Bitcoin and macro market briefings for AI agents: trend signals, regimes, liquidity and ETF flows.",
@@ -9,7 +9,7 @@
   },
   "scripts": {
     "build": "echo 'Build complete'",
-    "test": "node --test test/credentials.test.js test/claim.test.js"
+    "test": "node --test test/credentials.test.js test/claim.test.js test/jsonrpc.test.js test/sse.test.js test/stdio.test.js test/streamable-http.test.js test/bridge.test.js"
   },
   "files": [
     "bin",
@@ -19,9 +19,6 @@
     "CHANGELOG.md",
     ".mcp.json"
   ],
-  "dependencies": {
-    "@modelcontextprotocol/sdk": "1.30.0"
-  },
   "engines": {
     "node": ">=18"
   },