@prereason/mcp 0.3.2 → 0.5.0

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,25 +1,24 @@
 {
   "name": "@prereason/mcp",
-  "version": "0.3.2",
-  "mcpName": "io.github.PreReason/mcp",
+  "version": "0.5.0",
+  "mcpName": "com.prereason/mcp",
   "type": "module",
-  "description": "MCP server for PreReason — the Context API for financial agents. 18 pre-reasoned market briefings with trend signals, regime classification, confidence scores, and cross-asset correlations.",
+  "description": "Bitcoin and macro market briefings for AI agents: trend signals, regimes, liquidity and ETF flows.",
   "bin": {
     "prereason-mcp": "./bin/cli.js"
   },
   "scripts": {
-    "build": "echo 'Build complete'"
+    "build": "echo 'Build complete'",
+    "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",
+    "lib",
     "README.md",
     "LICENSE",
     "CHANGELOG.md",
     ".mcp.json"
   ],
-  "dependencies": {
-    "@modelcontextprotocol/sdk": "1.27.1"
-  },
   "engines": {
     "node": ">=18"
   },
@@ -46,7 +45,7 @@
     "url": "https://www.prereason.com"
   },
   "license": "MIT",
-  "homepage": "https://www.prereason.com/docs#mcp",
+  "homepage": "https://www.prereason.com/docs#mcp-integration",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/PreReason/mcp.git"