@thotischner/observability-mcp 1.8.1 → 3.0.1

package/dist/transport/sessionStore.js

@@ -0,0 +1,138 @@
+// Shared session store — abstract backend for any short-lived state
+// the gateway needs to keep across replicas: MCP Streamable HTTP
+// session metadata, OIDC flow state (PKCE verifier, nonce, redirect
+// target), DCR-registered client metadata, federation upstream
+// catalogue cache.
+//
+// Two implementations ship in v2.0:
+//
+//   InMemorySessionStore — the default; preserves the pre-F8 behaviour
+//     (single-replica, ephemeral on restart). No new dep, no new env.
+//
+//   RedisSessionStore — opt-in via OMCP_REDIS_URL. Backs all consumers
+//     with a shared Redis so multi-replica deployments stop losing
+//     sessions on rollouts and so federated upstreams can share a
+//     cache. Driver loaded via dynamic import so the `redis` package
+//     only loads when the store is configured.
+//
+// Consumers MUST treat returns as eventually-consistent across
+// replicas: a get() right after a set() on a different replica may
+// return undefined while replication catches up. Use TTLs for any
+// state that must self-cleanup (the store's `setEx` honours the
+// requested ttl seconds; `set` is no-expiry).
+/** Single-process, in-memory store. Default when OMCP_REDIS_URL is
+ *  unset. Lazy expiry — entries are evicted on the next access. */
+export class InMemorySessionStore {
+    backend = "memory";
+    map = new Map();
+    async get(key) {
+        const entry = this.map.get(key);
+        if (!entry)
+            return undefined;
+        if (entry.expiresAt <= Date.now()) {
+            this.map.delete(key);
+            return undefined;
+        }
+        return entry.value;
+    }
+    async set(key, value) {
+        this.map.set(key, { value, expiresAt: Number.POSITIVE_INFINITY });
+    }
+    async setEx(key, ttlSeconds, value) {
+        this.map.set(key, { value, expiresAt: Date.now() + ttlSeconds * 1000 });
+    }
+    async del(key) {
+        this.map.delete(key);
+    }
+    async keys(prefix) {
+        const out = [];
+        const now = Date.now();
+        for (const [k, v] of this.map) {
+            if (v.expiresAt <= now) {
+                this.map.delete(k);
+                continue;
+            }
+            if (k.startsWith(prefix))
+                out.push(k);
+        }
+        return out;
+    }
+    async close() {
+        this.map.clear();
+    }
+    /** Test-only: introspect size. */
+    size() {
+        return this.map.size;
+    }
+}
+/** Redis-backed store. Constructed lazily via `connectRedisStore` so
+ *  the `redis` driver only loads when actually used. */
+export class RedisSessionStore {
+    backend = "redis";
+    client;
+    prefix;
+    constructor(client, prefix = "omcp:") {
+        this.client = client;
+        this.prefix = prefix;
+    }
+    k(key) {
+        return `${this.prefix}${key}`;
+    }
+    async get(key) {
+        const raw = await this.client.get(this.k(key));
+        if (raw == null)
+            return undefined;
+        try {
+            return JSON.parse(raw);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async set(key, value) {
+        await this.client.set(this.k(key), JSON.stringify(value));
+    }
+    async setEx(key, ttlSeconds, value) {
+        await this.client.set(this.k(key), JSON.stringify(value), {
+            EX: ttlSeconds,
+        });
+    }
+    async del(key) {
+        await this.client.del(this.k(key));
+    }
+    async keys(prefix) {
+        const found = await this.client.keys(`${this.k(prefix)}*`);
+        return found.map((k) => k.slice(this.prefix.length));
+    }
+    async close() {
+        try {
+            await this.client.quit();
+        }
+        catch {
+            /* socket may already be down */
+        }
+    }
+}
+/**
+ * Resolve the session store from env. Default: InMemorySessionStore.
+ * When OMCP_REDIS_URL is set: load `redis` dynamically, connect, and
+ * return a RedisSessionStore. On any connect failure, log + fall back
+ * to InMemory (the gateway must boot even when Redis is down).
+ */
+export async function resolveSessionStore(env = process.env) {
+    const url = env.OMCP_REDIS_URL?.trim();
+    if (!url)
+        return new InMemorySessionStore();
+    try {
+        const { createClient } = await import("redis");
+        const client = createClient({ url });
+        client.on("error", (err) => console.warn("RedisSessionStore: client error: %s", err instanceof Error ? err.message : String(err)));
+        await client.connect();
+        console.log("RedisSessionStore: connected (url scheme=%s, prefix=%s)", new URL(url).protocol.replace(/:$/, ""), env.OMCP_REDIS_KEY_PREFIX ?? "omcp:");
+        return new RedisSessionStore(client, env.OMCP_REDIS_KEY_PREFIX ?? "omcp:");
+    }
+    catch (err) {
+        console.warn("RedisSessionStore: connect failed, falling back to in-memory store: %s", err instanceof Error ? err.message : String(err));
+        return new InMemorySessionStore();
+    }
+}

package/dist/transport/sessionStore.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/transport/sessionStore.test.js

@@ -0,0 +1,118 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { InMemorySessionStore, RedisSessionStore, } from "./sessionStore.js";
+test("InMemorySessionStore: backend identifier is 'memory'", () => {
+    const s = new InMemorySessionStore();
+    assert.equal(s.backend, "memory");
+});
+test("InMemorySessionStore: set + get round-trips JSON-serialisable values", async () => {
+    const s = new InMemorySessionStore();
+    await s.set("k", { a: 1, b: ["x", "y"] });
+    assert.deepEqual(await s.get("k"), { a: 1, b: ["x", "y"] });
+});
+test("InMemorySessionStore: missing key returns undefined", async () => {
+    const s = new InMemorySessionStore();
+    assert.equal(await s.get("nope"), undefined);
+});
+test("InMemorySessionStore: del removes a key", async () => {
+    const s = new InMemorySessionStore();
+    await s.set("k", "v");
+    await s.del("k");
+    assert.equal(await s.get("k"), undefined);
+});
+test("InMemorySessionStore: setEx expires after ttl", async () => {
+    const s = new InMemorySessionStore();
+    await s.setEx("k", 0.05, "soon-gone"); // 50ms
+    assert.equal(await s.get("k"), "soon-gone");
+    await new Promise((r) => setTimeout(r, 80));
+    assert.equal(await s.get("k"), undefined);
+});
+test("InMemorySessionStore: keys(prefix) returns matching keys, drops expired ones", async () => {
+    const s = new InMemorySessionStore();
+    await s.set("oidc:flow:a", 1);
+    await s.set("oidc:flow:b", 2);
+    await s.set("mcp:session:c", 3);
+    await s.setEx("oidc:flow:expired", 0.02, 4);
+    await new Promise((r) => setTimeout(r, 50));
+    const oidc = await s.keys("oidc:flow:");
+    assert.deepEqual(oidc.sort(), ["oidc:flow:a", "oidc:flow:b"]);
+    assert.deepEqual(await s.keys("mcp:"), ["mcp:session:c"]);
+});
+test("InMemorySessionStore: close() clears state", async () => {
+    const s = new InMemorySessionStore();
+    await s.set("k", 1);
+    await s.close();
+    assert.equal(await s.get("k"), undefined);
+    assert.equal(s.size(), 0);
+});
+// FakeRedis: tiny in-memory implementation of the RedisClientLike
+// surface, lets us test RedisSessionStore without a real broker.
+class FakeRedis {
+    store = new Map();
+    quitCalled = false;
+    async get(key) {
+        return this.store.get(key) ?? null;
+    }
+    async set(key, value, _opts) {
+        this.store.set(key, value);
+        return "OK";
+    }
+    async del(key) {
+        return this.store.delete(key) ? 1 : 0;
+    }
+    async keys(pattern) {
+        // FakeRedis only supports prefix*.
+        const prefix = pattern.replace(/\*$/, "");
+        return [...this.store.keys()].filter((k) => k.startsWith(prefix));
+    }
+    async quit() {
+        this.quitCalled = true;
+        return "OK";
+    }
+}
+test("RedisSessionStore: applies prefix on set/get/del/keys", async () => {
+    const fake = new FakeRedis();
+    const s = new RedisSessionStore(fake, "test:");
+    await s.set("k", { hello: "world" });
+    assert.ok(fake.store.has("test:k"));
+    assert.deepEqual(await s.get("k"), { hello: "world" });
+    await s.del("k");
+    assert.equal(await s.get("k"), undefined);
+});
+test("RedisSessionStore: keys() strips the prefix before returning", async () => {
+    const fake = new FakeRedis();
+    const s = new RedisSessionStore(fake, "test:");
+    await s.set("oidc:a", 1);
+    await s.set("oidc:b", 2);
+    const found = await s.keys("oidc:");
+    assert.deepEqual(found.sort(), ["oidc:a", "oidc:b"]);
+});
+test("RedisSessionStore: setEx forwards EX to the driver", async () => {
+    const fake = new FakeRedis();
+    let seenOpts;
+    fake.set = async (key, value, opts) => {
+        seenOpts = opts;
+        fake.store.set(key, value);
+        return "OK";
+    };
+    const s = new RedisSessionStore(fake, "");
+    await s.setEx("k", 30, "v");
+    assert.deepEqual(seenOpts, { EX: 30 });
+});
+test("RedisSessionStore: malformed JSON in store returns undefined", async () => {
+    const fake = new FakeRedis();
+    fake.store.set("test:bad", "not-json{");
+    const s = new RedisSessionStore(fake, "test:");
+    assert.equal(await s.get("bad"), undefined);
+});
+test("RedisSessionStore: close() calls quit()", async () => {
+    const fake = new FakeRedis();
+    const s = new RedisSessionStore(fake, "test:");
+    await s.close();
+    assert.equal(fake.quitCalled, true);
+});
+test("RedisSessionStore: backend identifier is 'redis'", () => {
+    const fake = new FakeRedis();
+    const s = new RedisSessionStore(fake);
+    assert.equal(s.backend, "redis");
+});

package/dist/transport/transportSessionMap.d.ts

@@ -0,0 +1,70 @@
+import type { SessionStore } from "./sessionStore.js";
+export interface TransportSessionMeta {
+    /** Stable id of the replica that owns the underlying SDK
+     *  Transport object. Set on creation. */
+    ownerReplica: string;
+    /** Optional virtual-server product slug. Undefined for the
+     *  root /mcp surface. */
+    product?: string;
+    /** Epoch ms — bumped on every successful request. */
+    lastActive: number;
+}
+export interface TransportSessionMap {
+    /** Stable backend identifier (used in /api/info diagnostics). */
+    readonly backend: string;
+    /** True iff there's a metadata entry — does NOT imply a local
+     *  Transport exists. */
+    has(sessionId: string): Promise<boolean>;
+    get(sessionId: string): Promise<TransportSessionMeta | undefined>;
+    set(sessionId: string, meta: TransportSessionMeta, ttlSeconds?: number): Promise<void>;
+    /** Convenience: bump lastActive while preserving the rest. */
+    touch(sessionId: string, ttlSeconds?: number): Promise<void>;
+    delete(sessionId: string): Promise<void>;
+    /** Return every session id this map knows about. Used for the
+     *  cleanup tick. Implementations MAY cap; in-memory returns the
+     *  full set, Redis pages via SCAN under the prefix. */
+    keys(): Promise<string[]>;
+    /** Evict entries with lastActive older than `maxIdleMs`. Returns
+     *  the evicted ids (caller logs / records metrics). */
+    cleanup(maxIdleMs: number): Promise<string[]>;
+}
+export declare class InMemoryTransportSessionMap implements TransportSessionMap {
+    readonly backend = "memory";
+    private readonly map;
+    has(id: string): Promise<boolean>;
+    get(id: string): Promise<TransportSessionMeta | undefined>;
+    set(id: string, meta: TransportSessionMeta): Promise<void>;
+    touch(id: string): Promise<void>;
+    delete(id: string): Promise<void>;
+    keys(): Promise<string[]>;
+    cleanup(maxIdleMs: number): Promise<string[]>;
+}
+/**
+ * Wraps an existing SessionStore so the per-session metadata lives
+ * wherever the SessionStore decided — InMemorySessionStore (no
+ * cross-replica visibility, identical to InMemoryTransportSessionMap
+ * but useful for tests / when a future backend is plugged in) or
+ * RedisSessionStore (cross-replica safe).
+ *
+ * Each entry stored at `<KEY_PREFIX><sessionId>` as JSON.
+ */
+export declare class SessionStoreBackedTransportSessionMap implements TransportSessionMap {
+    readonly backend: string;
+    private readonly store;
+    private readonly defaultTtlSeconds;
+    constructor(store: SessionStore, defaultTtlSeconds?: number);
+    has(id: string): Promise<boolean>;
+    get(id: string): Promise<TransportSessionMeta | undefined>;
+    set(id: string, meta: TransportSessionMeta, ttlSeconds?: number): Promise<void>;
+    touch(id: string, ttlSeconds?: number): Promise<void>;
+    delete(id: string): Promise<void>;
+    keys(): Promise<string[]>;
+    cleanup(maxIdleMs: number): Promise<string[]>;
+}
+/**
+ * Pick the right implementation. When `sessionStore` is the
+ * in-memory default, return InMemoryTransportSessionMap so we
+ * avoid the (synchronous → async) layering tax. Otherwise wrap
+ * the supplied store.
+ */
+export declare function createTransportSessionMap(sessionStore?: SessionStore): TransportSessionMap;

package/dist/transport/transportSessionMap.js

@@ -0,0 +1,128 @@
+// Multi-replica-safe MCP transport session metadata.
+//
+// The actual SDK `StreamableHTTPServerTransport` object MUST live in
+// the replica that originated the session — it owns the open HTTP
+// response handles. What CAN be shared across replicas is the
+// per-session metadata (last-active timestamp, virtual-server
+// product slug, owner-replica id). This module promotes that map
+// from a process-local `Map` to a small `TransportSessionMap` KV
+// surface backed by either in-memory state (default) or the existing
+// SessionStore Redis backend (opt-in via OMCP_REDIS_URL).
+//
+// Multi-replica behaviour:
+//   - Replica A creates session S. Writes metadata {ownerReplica:A,
+//     lastActive, product} to the shared map.
+//   - Subsequent request lands on Replica B with the same S header.
+//     B consults the shared map, sees ownerReplica:A, replies 410
+//     so the load balancer rehashes or the client retries.
+//   - This keeps the gateway functional even when sticky ingress
+//     drops the affinity — the worst case is a single 410 retry,
+//     not a silent NEW transport (which today races against the
+//     real one).
+//
+// The TTL on each entry mirrors SESSION_TTL_MS so the map doesn't
+// grow unbounded if a replica disappears without graceful
+// shutdown — TTL-based eviction is the safety net.
+// ---------------------------------------------------------------- in-memory
+export class InMemoryTransportSessionMap {
+    backend = "memory";
+    map = new Map();
+    async has(id) { return this.map.has(id); }
+    async get(id) {
+        return this.map.get(id);
+    }
+    async set(id, meta) {
+        this.map.set(id, meta);
+    }
+    async touch(id) {
+        const cur = this.map.get(id);
+        if (!cur)
+            return;
+        cur.lastActive = Date.now();
+    }
+    async delete(id) { this.map.delete(id); }
+    async keys() { return [...this.map.keys()]; }
+    async cleanup(maxIdleMs) {
+        const now = Date.now();
+        const evicted = [];
+        for (const [id, meta] of this.map) {
+            if (now - meta.lastActive > maxIdleMs) {
+                this.map.delete(id);
+                evicted.push(id);
+            }
+        }
+        return evicted;
+    }
+}
+// ---------------------------------------------------------------- SessionStore-backed
+const KEY_PREFIX = "transport:";
+/**
+ * Wraps an existing SessionStore so the per-session metadata lives
+ * wherever the SessionStore decided — InMemorySessionStore (no
+ * cross-replica visibility, identical to InMemoryTransportSessionMap
+ * but useful for tests / when a future backend is plugged in) or
+ * RedisSessionStore (cross-replica safe).
+ *
+ * Each entry stored at `<KEY_PREFIX><sessionId>` as JSON.
+ */
+export class SessionStoreBackedTransportSessionMap {
+    backend;
+    store;
+    defaultTtlSeconds;
+    constructor(store, defaultTtlSeconds = 30 * 60) {
+        this.store = store;
+        this.backend = `session-store:${store.backend}`;
+        this.defaultTtlSeconds = defaultTtlSeconds;
+    }
+    async has(id) {
+        return (await this.store.get(KEY_PREFIX + id)) !== undefined;
+    }
+    async get(id) {
+        return (await this.store.get(KEY_PREFIX + id)) ?? undefined;
+    }
+    async set(id, meta, ttlSeconds) {
+        await this.store.setEx(KEY_PREFIX + id, ttlSeconds ?? this.defaultTtlSeconds, meta);
+    }
+    async touch(id, ttlSeconds) {
+        const cur = await this.get(id);
+        if (!cur)
+            return;
+        cur.lastActive = Date.now();
+        await this.set(id, cur, ttlSeconds);
+    }
+    async delete(id) {
+        await this.store.del(KEY_PREFIX + id);
+    }
+    async keys() {
+        const raw = await this.store.keys(KEY_PREFIX);
+        return raw.map((k) => k.slice(KEY_PREFIX.length));
+    }
+    async cleanup(maxIdleMs) {
+        const now = Date.now();
+        const ids = await this.keys();
+        const evicted = [];
+        for (const id of ids) {
+            const meta = await this.get(id);
+            if (!meta)
+                continue;
+            if (now - meta.lastActive > maxIdleMs) {
+                await this.delete(id);
+                evicted.push(id);
+            }
+        }
+        return evicted;
+    }
+}
+// ---------------------------------------------------------------- factory
+/**
+ * Pick the right implementation. When `sessionStore` is the
+ * in-memory default, return InMemoryTransportSessionMap so we
+ * avoid the (synchronous → async) layering tax. Otherwise wrap
+ * the supplied store.
+ */
+export function createTransportSessionMap(sessionStore) {
+    if (!sessionStore || sessionStore.backend === "memory") {
+        return new InMemoryTransportSessionMap();
+    }
+    return new SessionStoreBackedTransportSessionMap(sessionStore);
+}

package/dist/transport/transportSessionMap.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/transport/transportSessionMap.test.js

@@ -0,0 +1,111 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { InMemoryTransportSessionMap, SessionStoreBackedTransportSessionMap, createTransportSessionMap, } from "./transportSessionMap.js";
+import { InMemorySessionStore } from "./sessionStore.js";
+function meta(p = {}) {
+    return {
+        ownerReplica: p.ownerReplica ?? "replica-A",
+        product: p.product,
+        lastActive: p.lastActive ?? Date.now(),
+    };
+}
+test("InMemoryTransportSessionMap: get/set/has/delete round-trip", async () => {
+    const m = new InMemoryTransportSessionMap();
+    assert.equal(await m.has("s1"), false);
+    await m.set("s1", meta({ product: "checkout" }));
+    assert.equal(await m.has("s1"), true);
+    const got = await m.get("s1");
+    assert.equal(got?.ownerReplica, "replica-A");
+    assert.equal(got?.product, "checkout");
+    await m.delete("s1");
+    assert.equal(await m.has("s1"), false);
+});
+test("InMemoryTransportSessionMap: touch bumps lastActive", async () => {
+    const m = new InMemoryTransportSessionMap();
+    const before = Date.now() - 10_000;
+    await m.set("s1", meta({ lastActive: before }));
+    await new Promise((r) => setTimeout(r, 2));
+    await m.touch("s1");
+    const got = await m.get("s1");
+    assert.ok((got?.lastActive ?? 0) > before);
+});
+test("InMemoryTransportSessionMap: keys + cleanup", async () => {
+    const m = new InMemoryTransportSessionMap();
+    await m.set("fresh", meta({ lastActive: Date.now() }));
+    await m.set("stale", meta({ lastActive: Date.now() - 10_000 }));
+    const all = await m.keys();
+    assert.equal(all.length, 2);
+    const evicted = await m.cleanup(5_000);
+    assert.deepEqual(evicted, ["stale"]);
+    assert.equal(await m.has("stale"), false);
+    assert.equal(await m.has("fresh"), true);
+});
+test("SessionStoreBackedTransportSessionMap: round-trip via SessionStore", async () => {
+    const store = new InMemorySessionStore();
+    const m = new SessionStoreBackedTransportSessionMap(store);
+    await m.set("s1", meta({ product: "p" }));
+    assert.equal(await m.has("s1"), true);
+    const got = await m.get("s1");
+    assert.equal(got?.product, "p");
+    await m.delete("s1");
+    assert.equal(await m.has("s1"), false);
+});
+test("SessionStoreBackedTransportSessionMap: keys excludes the prefix in returned ids", async () => {
+    const store = new InMemorySessionStore();
+    const m = new SessionStoreBackedTransportSessionMap(store);
+    await m.set("alpha", meta());
+    await m.set("beta", meta());
+    const ids = (await m.keys()).sort();
+    assert.deepEqual(ids, ["alpha", "beta"]);
+    // Unrelated keys on the same SessionStore must not pollute the map.
+    await store.set("scim:user:1", { foo: "bar" });
+    const idsAfter = (await m.keys()).sort();
+    assert.deepEqual(idsAfter, ["alpha", "beta"]);
+});
+test("SessionStoreBackedTransportSessionMap: cleanup evicts stale entries", async () => {
+    const store = new InMemorySessionStore();
+    const m = new SessionStoreBackedTransportSessionMap(store);
+    await m.set("fresh", meta({ lastActive: Date.now() }));
+    await m.set("stale", meta({ lastActive: Date.now() - 60_000 }));
+    const evicted = await m.cleanup(30_000);
+    assert.deepEqual(evicted, ["stale"]);
+});
+test("SessionStoreBackedTransportSessionMap: touch is no-op on missing id", async () => {
+    const store = new InMemorySessionStore();
+    const m = new SessionStoreBackedTransportSessionMap(store);
+    await m.touch("ghost");
+    assert.equal(await m.has("ghost"), false);
+});
+test("SessionStoreBackedTransportSessionMap: backend tag exposes underlying store name", () => {
+    const store = new InMemorySessionStore();
+    const m = new SessionStoreBackedTransportSessionMap(store);
+    assert.equal(m.backend, "session-store:memory");
+});
+test("createTransportSessionMap: memory backend returns in-memory impl", () => {
+    const store = new InMemorySessionStore();
+    const m = createTransportSessionMap(store);
+    assert.equal(m.backend, "memory");
+});
+test("createTransportSessionMap: non-memory backend returns wrapper", () => {
+    // Fake a non-memory backend by stubbing the backend tag.
+    const fake = {
+        backend: "redis",
+        async get() { return undefined; },
+        async set() { },
+        async setEx() { },
+        async del() { },
+        async keys() { return []; },
+        async close() { },
+    };
+    const m = createTransportSessionMap(fake);
+    assert.equal(m.backend, "session-store:redis");
+});
+test("createTransportSessionMap: undefined sessionStore → memory impl (back-compat)", () => {
+    const m = createTransportSessionMap();
+    assert.equal(m.backend, "memory");
+});
+test("InMemoryTransportSessionMap.touch: ghost id is no-op", async () => {
+    const m = new InMemoryTransportSessionMap();
+    await m.touch("ghost");
+    assert.equal(await m.has("ghost"), false);
+});

package/dist/transport/websocket.d.ts

@@ -0,0 +1,35 @@
+import type { WebSocket } from "ws";
+import type { JSONRPCMessage, MessageExtraInfo, RequestId } from "@modelcontextprotocol/sdk/types.js";
+import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
+export declare const PING_INTERVAL_MS = 30000;
+export declare const PING_TIMEOUT_MS = 90000;
+export interface WebSocketTransportOptions {
+    /** Override the generated session id (useful for tests). */
+    sessionId?: string;
+    /** Override heartbeat ping interval; default 30s. */
+    pingIntervalMs?: number;
+    /** Override stale-connection timeout; default 90s. */
+    pingTimeoutMs?: number;
+}
+/**
+ * Per-WS-connection MCP transport. One instance per accepted socket.
+ */
+export declare class WebSocketServerTransport implements Transport {
+    sessionId?: string;
+    onclose?: () => void;
+    onerror?: (error: Error) => void;
+    onmessage?: <T extends JSONRPCMessage>(message: T, extra?: MessageExtraInfo) => void;
+    private ws;
+    private pingTimer?;
+    private lastPongAt;
+    private pingIntervalMs;
+    private pingTimeoutMs;
+    private closed;
+    constructor(ws: WebSocket, opts?: WebSocketTransportOptions);
+    start(): Promise<void>;
+    send(message: JSONRPCMessage, _options?: {
+        relatedRequestId?: RequestId;
+    }): Promise<void>;
+    close(): Promise<void>;
+    private handleClose;
+}