agent-comm-hub 0.1.6

package/lib/index.js

@@ -0,0 +1,798 @@
+// src/index.ts
+import { createServer } from "node:http";
+
+// src/hub.ts
+import { randomUUID } from "node:crypto";
+
+// src/protocol.ts
+var KINDS = ["chat", "task", "notice", "ack"];
+var PEER_ID_PATTERN = /^[A-Za-z0-9._:-]{1,64}$/;
+var BROADCAST = "all";
+function encodeContent(payload) {
+  return JSON.stringify(payload);
+}
+function decodeContent(kind, content) {
+  if (kind !== "task" && kind !== "ack") return content;
+  try {
+    const parsed = JSON.parse(content);
+    if (parsed !== null && typeof parsed === "object") return parsed;
+  } catch {
+  }
+  return content;
+}
+
+// src/hub.ts
+var AgentHub = class {
+  constructor(options) {
+    this.options = options;
+    const idle = options.peerIdleTimeoutMs ?? 6e5;
+    if (idle > 0) {
+      const interval = Math.min(6e4, Math.max(1e3, idle / 2));
+      this.gcTimer = setInterval(() => this.gcTick(idle), interval);
+      this.gcTimer.unref?.();
+    }
+  }
+  queues = /* @__PURE__ */ new Map();
+  waiters = /* @__PURE__ */ new Map();
+  historyRing = [];
+  lastSeen = /* @__PURE__ */ new Map();
+  gcTimer;
+  /** Stop the idle GC (call when the hub shuts down). */
+  dispose() {
+    if (this.gcTimer !== void 0) clearInterval(this.gcTimer);
+  }
+  gcTick(idleTimeoutMs) {
+    const now = Date.now();
+    for (const peerId of this.peers()) {
+      if (now - (this.lastSeen.get(peerId) ?? 0) > idleTimeoutMs) {
+        if (this.options.isPeerLive?.(peerId) === true) continue;
+        this.options.onPeerGc?.(peerId);
+        this.unregister(peerId);
+      }
+    }
+  }
+  /** All registered peer ids, insertion order. */
+  peers() {
+    return [...this.lastSeen.keys()];
+  }
+  /** Register a peer; throws if the id is already taken. */
+  register(peerId) {
+    if (this.lastSeen.has(peerId)) throw new Error(`peer already registered: ${peerId}`);
+    this.lastSeen.set(peerId, Date.now());
+    this.options.onPeersChanged?.(this.peers());
+  }
+  /** Remove a peer and its queued messages; pending waiters resolve as timeouts. */
+  unregister(peerId) {
+    this.queues.delete(peerId);
+    for (const waiter of this.waiters.get(peerId) ?? []) {
+      clearTimeout(waiter.timer);
+      waiter.onAbort();
+    }
+    this.waiters.delete(peerId);
+    this.lastSeen.delete(peerId);
+    this.options.onPeersChanged?.(this.peers());
+  }
+  /** Mark activity for `peer` (called on every tool call from that peer). */
+  touch(peerId) {
+    if (this.lastSeen.has(peerId)) this.lastSeen.set(peerId, Date.now());
+  }
+  /** Is the peer currently registered? */
+  has(peerId) {
+    return this.lastSeen.has(peerId);
+  }
+  /** Is the peer "active" (tool/activity within the connected window)? */
+  isActive(peerId) {
+    const last = this.lastSeen.get(peerId);
+    return last !== void 0 && Date.now() - last < (this.options.connectedWindowMs ?? 3e4);
+  }
+  /** Send a chat/notice text message to `to` (or {@link BROADCAST}). */
+  send(from, to, kind, content) {
+    return this.route(from, to, kind, content);
+  }
+  /** Send a structured task message to `to` (or {@link BROADCAST}). */
+  sendTask(from, to, task) {
+    return this.route(from, to, "task", JSON.stringify(task));
+  }
+  /** Send an acknowledgement back to the sender of `ref`. */
+  sendAck(from, ref, ack) {
+    const original = this.historyRing.findLast((message) => message.id === ref);
+    if (!original) throw new Error(`cannot ack unknown message: ${ref}`);
+    return this.route(from, original.from, "ack", JSON.stringify(ack), ref);
+  }
+  /** Recent messages involving `peer` (inbound and outbound), newest first. */
+  history(peerId, limit) {
+    const filtered = this.historyRing.filter((message) => message.from === peerId || message.to === peerId || message.to === BROADCAST);
+    return filtered.slice(-Math.max(0, limit)).reverse();
+  }
+  /**
+   * Live summary for the status tool. `livePeers` (sessions with a live SSE
+   * stream) count as connected even without recent tool activity.
+   */
+  status(livePeers) {
+    const now = Date.now();
+    return {
+      server: "agent-comm-hub",
+      peers: this.peers().map((peer) => ({
+        id: peer,
+        connected: this.isActive(peer) || livePeers?.has(peer) === true,
+        lastSeenMs: this.lastSeen.get(peer) ?? 0,
+        queued: (this.queues.get(peer) ?? []).length,
+        waiting: (this.waiters.get(peer) ?? []).length
+      })),
+      historyLimit: this.options.historyLimit,
+      maxQueue: this.options.maxQueue
+    };
+  }
+  /** Non-blocking drain of everything queued for `peer` (optionally from one sender). */
+  poll(peerId, from) {
+    const queue = this.queues.get(peerId) ?? [];
+    const drained = from === void 0 ? queue.splice(0, queue.length) : drainFrom(queue, from);
+    for (const message of drained) this.remember(message);
+    return drained;
+  }
+  /**
+   * Long-poll for the next message addressed to `peer`: resolves immediately
+   * when a matching one is queued, otherwise waits up to `timeoutMs` (capped
+   * by `waitTimeoutMs`) or until `signal` aborts. `from` narrows to one sender.
+   */
+  wait(peerId, timeoutMs, from, signal) {
+    const startedAt = Date.now();
+    const queued = this.poll(peerId, from)[0];
+    if (queued) return Promise.resolve({ type: "message", message: queued });
+    const budget = Math.max(1, Math.min(Math.floor(timeoutMs), this.options.waitTimeoutMs));
+    return new Promise((resolve) => {
+      let settled = false;
+      const settle = (result) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        signal?.removeEventListener("abort", onAbort);
+        resolve(result);
+      };
+      const onAbort = () => {
+        removeFromRegistry();
+        settle({ type: "timeout", waitedMs: Date.now() - startedAt });
+      };
+      const removeFromRegistry = () => {
+        const list2 = this.waiters.get(peerId);
+        if (list2) this.waiters.set(peerId, list2.filter((waiter) => waiter.resolve !== settle));
+      };
+      const timer = setTimeout(() => {
+        removeFromRegistry();
+        settle({ type: "timeout", waitedMs: Date.now() - startedAt });
+      }, budget);
+      if (signal?.aborted) {
+        onAbort();
+        return;
+      }
+      signal?.addEventListener("abort", onAbort, { once: true });
+      const list = this.waiters.get(peerId) ?? [];
+      list.push({ resolve: settle, timer, onAbort, ...from !== void 0 ? { from } : {} });
+      this.waiters.set(peerId, list);
+    });
+  }
+  /** Create a message from `from` addressed to `to` and deliver it. */
+  route(from, to, kind, content, ref) {
+    if (!this.lastSeen.has(from)) throw new Error(`sender not registered: ${from}`);
+    if (to !== BROADCAST && !this.lastSeen.has(to)) throw new Error(`unknown recipient: ${to} (registered peers: ${this.peers().join(", ") || "none"})`);
+    const message = {
+      id: randomUUID(),
+      from,
+      to,
+      kind,
+      content,
+      ...ref !== void 0 ? { ref } : {},
+      ts: Date.now()
+    };
+    this.lastSeen.set(from, message.ts);
+    if (to === BROADCAST) {
+      for (const peer of this.peers()) {
+        if (peer !== from) this.deliver(peer, message);
+      }
+    } else {
+      this.deliver(to, message);
+    }
+    return message;
+  }
+  /** Queue or hand off a message; wake the first matching waiter for its target. */
+  deliver(target, message) {
+    const list = this.waiters.get(target) ?? [];
+    const index = list.findIndex((waiter) => waiter.from === void 0 || waiter.from === message.from);
+    if (index >= 0) {
+      const [waiter] = list.splice(index, 1);
+      this.waiters.set(target, list);
+      clearTimeout(waiter.timer);
+      this.remember(message);
+      waiter.resolve({ type: "message", message });
+      return;
+    }
+    const queue = this.queues.get(target) ?? [];
+    if (queue.length >= this.options.maxQueue) queue.shift();
+    queue.push(message);
+    this.queues.set(target, queue);
+    this.options.onQueued?.(message);
+  }
+  /** Append a delivered message to the history ring. */
+  remember(message) {
+    this.historyRing.push(message);
+    if (this.historyRing.length > this.options.historyLimit) this.historyRing.splice(0, this.historyRing.length - this.options.historyLimit);
+  }
+};
+function drainFrom(queue, from) {
+  const kept = [];
+  const drained = [];
+  for (const message of queue) {
+    if (message.from === from) drained.push(message);
+    else kept.push(message);
+  }
+  queue.splice(0, queue.length, ...kept);
+  return drained;
+}
+
+// src/hub-tools.ts
+var DEFAULT_WAIT_MS = 3e4;
+function present(message) {
+  const { ref, ...rest } = message;
+  return {
+    ...rest,
+    ...ref !== void 0 ? { ref } : {},
+    content: decodeContent(message.kind, message.content)
+  };
+}
+function sanitizePeerId(name) {
+  const cleaned = name.toLowerCase().replace(/[^a-z0-9._:-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 64);
+  return cleaned === "" ? "agent" : cleaned;
+}
+function autoRegisterPeer(hub, registry, sessionId, clientName) {
+  if (sessionId === void 0) return void 0;
+  const bound = registry.peerFor(sessionId);
+  if (bound !== void 0) return bound;
+  if (registry.isSuppressed(sessionId)) return void 0;
+  const peerId = sanitizePeerId(clientName ?? "agent");
+  if (!hub.has(peerId)) hub.register(peerId);
+  registry.bindPeer(sessionId, peerId);
+  hub.touch(peerId);
+  return peerId;
+}
+function livePeersFor(registry) {
+  const live = /* @__PURE__ */ new Set();
+  const streams = registry.liveSessions();
+  for (const [sessionId, peerId] of registry.peerBindings) {
+    if (streams.has(sessionId)) live.add(peerId);
+  }
+  return live;
+}
+function hubTools(hub, registry, options) {
+  const schema = (properties, required = []) => ({
+    type: "object",
+    properties,
+    required,
+    additionalProperties: false
+  });
+  const str = (description) => ({ type: "string", description });
+  const int = (description) => ({ type: "integer", description });
+  const optStr = str;
+  const requirePeer = (sessionId) => {
+    const bound = registry.peerFor(sessionId);
+    if (bound !== void 0) {
+      hub.touch(bound);
+      return bound;
+    }
+    const auto = autoRegisterPeer(hub, registry, sessionId, registry.clientName(sessionId));
+    if (auto !== void 0) {
+      hub.touch(auto);
+      return auto;
+    }
+    throw new Error("not registered \u2014 call bridge_register(peerId) first");
+  };
+  const receipt = (message) => ({
+    ok: true,
+    id: message.id,
+    from: message.from,
+    to: message.to,
+    kind: message.kind,
+    ts: message.ts
+  });
+  const presentWait = (result) => result.type === "timeout" ? result : { type: "message", message: present(result.message) };
+  const wrap = (peerAware, handler) => async (args, sessionId) => {
+    const peer = peerAware ? requirePeer(sessionId) : "";
+    return handler(args, peer, sessionId);
+  };
+  return [
+    {
+      name: "bridge_register",
+      description: 'Claim or rename your identity on the hub. Sessions auto-share a peer id derived from the client name; call this to switch to a readable unique peerId such as "mavis" or "opencode:myproject". Rejects when the id is claimed by another connection. Returns the current peer list.',
+      inputSchema: schema({ peerId: str("Unique peer id: letters/digits/._:- , 1-64 chars.") }, ["peerId"]),
+      handler: async (args, sessionId) => {
+        const peerId = String(args.peerId);
+        if (!/^[A-Za-z0-9._:-]{1,64}$/.test(peerId)) {
+          throw new Error(`invalid peerId: ${peerId} (expected [A-Za-z0-9._:-]{1,64})`);
+        }
+        if (hub.has(peerId) && registry.peerFor(sessionId) !== peerId) {
+          throw new Error(`peer already registered by another connection: ${peerId}`);
+        }
+        const current = registry.peerFor(sessionId);
+        if (current !== void 0 && current !== peerId) {
+          registry.unbindPeer(sessionId);
+          if (registry.attachedCount(current) === 0) hub.unregister(current);
+        }
+        registry.bindPeer(sessionId, peerId);
+        if (!hub.has(peerId)) hub.register(peerId);
+        registry.clearSuppress(sessionId);
+        hub.touch(peerId);
+        return { ok: true, peerId, peers: hub.peers() };
+      }
+    },
+    {
+      name: "bridge_unregister",
+      description: "Leave the hub: detaches your session (and drops the peer when no other session shares it); auto-registration stays off until an explicit bridge_register. Idempotent.",
+      inputSchema: schema({}),
+      handler: async (_args, sessionId) => {
+        const peer = registry.peerFor(sessionId);
+        if (peer !== void 0) {
+          registry.unbindPeer(sessionId);
+          if (registry.attachedCount(peer) === 0) hub.unregister(peer);
+        }
+        registry.suppressAuto(sessionId);
+        return { ok: true, peerId: peer ?? null };
+      }
+    },
+    {
+      name: "bridge_chat",
+      description: 'Send a chat message to another agent on the hub. Use bridge_wait (long-poll) or bridge_poll to receive replies. `to` is the target peerId, or "all" to broadcast.',
+      inputSchema: schema(
+        { to: str('Target peerId, or "all" to broadcast.'), message: str("The message text.") },
+        ["to", "message"]
+      ),
+      handler: wrap(true, async (args, peer) => receipt(hub.send(peer, String(args.to), "chat", String(args.message))))
+    },
+    {
+      name: "bridge_task",
+      description: "Delegate a structured task to another agent. The receiving agent decides whether to accept; expect an ack (accepted/rejected/done/failed) via bridge_wait / bridge_poll.",
+      inputSchema: schema(
+        {
+          to: str('Target peerId, or "all" to broadcast.'),
+          prompt: str("What the receiving agent should do."),
+          context: optStr("Optional background information for the task."),
+          deliverable: optStr("Optional expected deliverable description.")
+        },
+        ["to", "prompt"]
+      ),
+      handler: wrap(true, async (args, peer) => receipt(hub.sendTask(peer, String(args.to), {
+        prompt: String(args.prompt),
+        ...args.context !== void 0 ? { context: String(args.context) } : {},
+        ...args.deliverable !== void 0 ? { deliverable: String(args.deliverable) } : {}
+      })))
+    },
+    {
+      name: "bridge_ack",
+      description: "Acknowledge a message received from another agent (usually a delegated task): accepted | rejected | done | failed. The ack is routed back to the original sender of `ref`.",
+      inputSchema: schema(
+        {
+          ref: str("The id of the message being acknowledged."),
+          status: { type: "string", enum: ["accepted", "rejected", "done", "failed"], description: "acknowledgement status." },
+          note: optStr("Optional explanation for the acknowledgement.")
+        },
+        ["ref", "status"]
+      ),
+      handler: wrap(true, async (args, peer) => {
+        const status = String(args.status);
+        const valid = ["accepted", "rejected", "done", "failed"];
+        if (!valid.includes(status)) {
+          throw new Error(`invalid ack status: ${status} (expected ${valid.join(" | ")})`);
+        }
+        return receipt(hub.sendAck(peer, String(args.ref), { status, ...args.note !== void 0 ? { note: String(args.note) } : {} }));
+      })
+    },
+    {
+      name: "bridge_wait",
+      description: "Wait (long-poll) for the next message addressed to you. Resolves immediately when one is queued; otherwise blocks until one arrives or the timeout fires. `from` narrows to one sender. Loop this tool to hold a real-time conversation.",
+      inputSchema: schema({
+        from: optStr("Only wait for messages from this peerId."),
+        timeoutMs: int(`Max wait in milliseconds (default ${DEFAULT_WAIT_MS}, ceiling is server waitTimeoutMs).`)
+      }),
+      handler: wrap(true, async (args, peer) => presentWait(await hub.wait(peer, args.timeoutMs === void 0 ? options.defaultWaitMs ?? DEFAULT_WAIT_MS : Number(args.timeoutMs), args.from === void 0 ? void 0 : String(args.from))))
+    },
+    {
+      name: "bridge_poll",
+      description: "Non-blocking: drain every message currently queued for you. Empty list when nothing is waiting. `from` narrows to one sender.",
+      inputSchema: schema({ from: optStr("Only drain messages from this peerId.") }),
+      handler: wrap(true, async (args, peer) => ({ messages: hub.poll(peer, args.from === void 0 ? void 0 : String(args.from)).map(present) }))
+    },
+    {
+      name: "bridge_status",
+      description: "Hub health: server info, every registered peer with connected/queued/waiting state. A peer is connected when it was active recently or its SSE channel is alive.",
+      inputSchema: schema({}),
+      handler: wrap(true, async () => hub.status(livePeersFor(registry)))
+    },
+    {
+      name: "bridge_peers",
+      description: "List registered peers and whether each is connected (recent activity or a live SSE channel).",
+      inputSchema: schema({}),
+      handler: wrap(true, async () => {
+        const status = hub.status(livePeersFor(registry));
+        return { peers: hub.peers().map((id) => ({ id, connected: status.peers.find((peer) => peer.id === id)?.connected ?? false })) };
+      })
+    },
+    {
+      name: "bridge_history",
+      description: "Recent messages involving you (newest first); pass `peer` to inspect another peer's conversation. Use to refresh context after a reconnect.",
+      inputSchema: schema({ peer: optStr("PeerId whose conversation to inspect; default: yourself."), limit: int("How many messages to return (default 20).") }),
+      handler: wrap(true, async (args, peer) => ({ messages: hub.history(args.peer === void 0 ? peer : String(args.peer), Math.min(args.limit === void 0 ? 20 : Number(args.limit), 100)).map(present) }))
+    }
+  ];
+}
+
+// src/mcp-server.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+var SUPPORTED_VERSIONS = ["2025-06-18", "2025-03-26", "2024-11-05"];
+var LATEST_VERSION = SUPPORTED_VERSIONS[0];
+var MAX_BODY_BYTES = 1048576;
+var SessionRegistry = class {
+  sessions = /* @__PURE__ */ new Set();
+  /** sessionId → peerId claimed via `bridge_register`. */
+  peerBindings = /* @__PURE__ */ new Map();
+  /** Session id from the request header, if any. */
+  sessionIdFor(req) {
+    return req.headers["mcp-session-id"];
+  }
+  /** Track `sessionId`, generating a fresh one when absent. */
+  ensureSession(sessionId) {
+    const id = sessionId ?? randomUUID2();
+    this.sessions.add(id);
+    return id;
+  }
+  /** Peer bound to a session, if any. */
+  peerFor(sessionId) {
+    if (sessionId === void 0) return void 0;
+    return this.peerBindings.get(sessionId);
+  }
+  /** Bind `peerId` to `sessionId`; rejects when the session already claimed
+   * a different peer or the session id is absent. */
+  bindPeer(sessionId, peerId) {
+    if (sessionId === void 0) throw new Error("no MCP session \u2014 re-initialize the connection");
+    const existing = this.peerBindings.get(sessionId);
+    if (existing !== void 0 && existing !== peerId) {
+      throw new Error(`this connection is already registered as '${existing}'`);
+    }
+    this.peerBindings.set(sessionId, peerId);
+    this.sessions.add(sessionId);
+    return sessionId;
+  }
+  /** Drop the binding of a session (used by bridge_unregister). */
+  unbindPeer(sessionId) {
+    if (sessionId !== void 0) this.peerBindings.delete(sessionId);
+  }
+  /** Client-reported name per session (from the initialize clientInfo). */
+  clientNames = /* @__PURE__ */ new Map();
+  /** Remember the client name reported by a session (on initialize). */
+  noteClient(sessionId, name) {
+    this.clientNames.set(sessionId, name);
+  }
+  /** Client-reported name for a session, if any. */
+  clientName(sessionId) {
+    if (sessionId === void 0) return void 0;
+    return this.clientNames.get(sessionId);
+  }
+  /** Sessions whose owner explicitly unregistered; auto-registration is
+   * suppressed for them until an explicit `bridge_register`. */
+  suppressedAuto = /* @__PURE__ */ new Set();
+  /** Suppress auto-registration for this session (on bridge_unregister). */
+  suppressAuto(sessionId) {
+    if (sessionId !== void 0) this.suppressedAuto.add(sessionId);
+  }
+  /** Allow auto-registration again (on explicit bridge_register). */
+  clearSuppress(sessionId) {
+    if (sessionId !== void 0) this.suppressedAuto.delete(sessionId);
+  }
+  /** Whether this session may not auto-register. */
+  isSuppressed(sessionId) {
+    return sessionId !== void 0 && this.suppressedAuto.has(sessionId);
+  }
+  /** Sessions with a live SSE stream (server→client channel). */
+  liveStreams = /* @__PURE__ */ new Set();
+  /** Mark a session's SSE stream open (server→client channel alive). */
+  markSseOpen(sessionId) {
+    this.liveStreams.add(sessionId);
+  }
+  /** Mark a session's SSE stream closed. */
+  markSseClosed(sessionId) {
+    this.liveStreams.delete(sessionId);
+  }
+  /** Session ids with a live SSE stream. */
+  liveSessions() {
+    return this.liveStreams;
+  }
+  /** Drop every binding that points at `peerId` (used by the idle GC). */
+  unbindPeerId(peerId) {
+    for (const [sessionId, bound] of this.peerBindings) {
+      if (bound === peerId) this.peerBindings.delete(sessionId);
+    }
+  }
+  /** How many sessions are currently attached to `peerId`. */
+  attachedCount(peerId) {
+    let count = 0;
+    for (const bound of this.peerBindings.values()) {
+      if (bound === peerId) count++;
+    }
+    return count;
+  }
+};
+var McpStreamableHttpServer = class {
+  constructor(tools, info, registry, log = () => {
+  }, onInitialize = () => {
+  }) {
+    this.tools = tools;
+    this.info = info;
+    this.registry = registry;
+    this.log = log;
+    this.onInitialize = onInitialize;
+  }
+  sseStreams = /* @__PURE__ */ new Map();
+  /** Attach request handling for `path` (e.g. `/mcp`) to an http server. */
+  attach(server, path) {
+    server.on("request", (req, res) => {
+      const url = new URL(req.url ?? "/", "http://localhost");
+      if (url.pathname !== path) {
+        res.writeHead(404, { "Content-Type": "application/json" }).end(JSON.stringify({ error: "not found" }));
+        return;
+      }
+      if (req.method === "GET") {
+        this.handleGet(req, res);
+        return;
+      }
+      if (req.method === "POST") {
+        void this.handlePost(req, res);
+        return;
+      }
+      if (req.method === "OPTIONS") {
+        res.writeHead(204, corsHeaders()).end();
+        return;
+      }
+      res.writeHead(405, corsHeaders()).end();
+    });
+  }
+  /** Close all open SSE streams (called on server shutdown). */
+  close() {
+    for (const stream of this.sseStreams.values()) stream.end();
+    this.sseStreams.clear();
+  }
+  handleGet(req, res) {
+    const sessionId = this.registry.ensureSession(this.registry.sessionIdFor(req));
+    res.writeHead(200, {
+      ...corsHeaders(),
+      "Content-Type": "text/event-stream; charset=utf-8",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive",
+      ...req.headers["mcp-session-id"] ? {} : { "Mcp-Session-Id": sessionId }
+    });
+    res.write(": connected\n\n");
+    this.sseStreams.set(sessionId, res);
+    this.registry.markSseOpen(sessionId);
+    req.on("close", () => {
+      this.sseStreams.delete(sessionId);
+      this.registry.markSseClosed(sessionId);
+    });
+  }
+  async handlePost(req, res) {
+    let body;
+    try {
+      body = await readBody(req);
+    } catch (error) {
+      this.jsonRpcError(res, null, -32700, `parse error: ${error.message}`);
+      return;
+    }
+    let message;
+    try {
+      message = JSON.parse(body.toString("utf8"));
+    } catch {
+      this.jsonRpcError(res, null, -32700, "parse error: invalid JSON");
+      return;
+    }
+    if (typeof message !== "object" || message === null || message.method === void 0) {
+      this.jsonRpcError(res, message?.id ?? null, -32600, "invalid request");
+      return;
+    }
+    const id = message.id ?? null;
+    const sessionId = this.registry.sessionIdFor(req);
+    if (id === null) {
+      res.writeHead(202, { ...corsHeaders(), "Content-Length": "0" }).end();
+      return;
+    }
+    try {
+      const { result, extraHeaders } = await this.dispatch(message, sessionId);
+      res.writeHead(200, {
+        ...corsHeaders(),
+        "Content-Type": "application/json; charset=utf-8",
+        "Mcp-Protocol-Version": messageProtocolVersion(req),
+        ...extraHeaders
+      });
+      res.end(JSON.stringify({ jsonrpc: "2.0", id, result }));
+    } catch (error) {
+      const code = error.code ?? -32603;
+      this.jsonRpcError(res, id, code, error.message, void 0, messageProtocolVersion(req));
+    }
+  }
+  async dispatch(message, sessionId) {
+    const method = message.method ?? "";
+    switch (method) {
+      case "initialize": {
+        const newSessionId = this.registry.ensureSession(sessionId);
+        const clientInfo = message.params?.clientInfo;
+        const clientName = typeof clientInfo?.name === "string" && clientInfo.name !== "" ? clientInfo.name : void 0;
+        if (clientName !== void 0) {
+          this.registry.noteClient(newSessionId, clientName);
+        }
+        this.onInitialize(newSessionId, clientName);
+        const requested = message.params?.protocolVersion;
+        const protocolVersion = typeof requested === "string" && SUPPORTED_VERSIONS.includes(requested) ? requested : LATEST_VERSION;
+        return {
+          extraHeaders: { "Mcp-Session-Id": newSessionId },
+          result: {
+            protocolVersion,
+            capabilities: { tools: { listChanged: false } },
+            serverInfo: { name: this.info.name, version: this.info.version },
+            instructions: "You are already registered with the hub (auto-registered at connect). Use bridge_chat / bridge_task / bridge_wait / bridge_poll / bridge_status / bridge_peers / bridge_history / bridge_ack to talk to other agents; bridge_register(peerId) renames your identity."
+          }
+        };
+      }
+      case "tools/list":
+        return { result: { tools: this.tools.map((tool) => ({
+          name: tool.name,
+          description: tool.description,
+          inputSchema: tool.inputSchema
+        })) } };
+      case "tools/call": {
+        const params = message.params ?? {};
+        if (typeof params.name !== "string") throw rpcError(-32602, "tools/call requires a string name");
+        const tool = this.tools.find((candidate) => candidate.name === params.name);
+        if (!tool) throw rpcError(-32602, `unknown tool: ${params.name}`);
+        const args = params.arguments ?? {};
+        if (typeof args !== "object" || args === null || Array.isArray(args)) {
+          throw rpcError(-32602, "tools/call arguments must be an object");
+        }
+        try {
+          const value = await tool.handler(args, sessionId);
+          return { result: { content: [{ type: "text", text: JSON.stringify(value) }], isError: false } };
+        } catch (error) {
+          return {
+            result: {
+              content: [{ type: "text", text: JSON.stringify({ error: error.message }) }],
+              isError: true
+            }
+          };
+        }
+      }
+      case "ping":
+        return { result: {} };
+      default:
+        throw rpcError(-32601, `method not found: ${method}`);
+    }
+  }
+  jsonRpcError(res, id, code, message, data, protocolVersion) {
+    res.writeHead(code === -32700 || code === -32600 ? 400 : 200, {
+      ...corsHeaders(),
+      "Content-Type": "application/json; charset=utf-8",
+      ...protocolVersion ? { "Mcp-Protocol-Version": protocolVersion } : {}
+    });
+    res.end(JSON.stringify({ jsonrpc: "2.0", id, error: { code, message, ...data !== void 0 ? { data } : {} } }));
+  }
+};
+function rpcError(code, message) {
+  const error = new Error(message);
+  error.code = code;
+  return error;
+}
+function messageProtocolVersion(req) {
+  return req.headers["mcp-protocol-version"] ?? LATEST_VERSION;
+}
+function corsHeaders() {
+  return {
+    "Access-Control-Allow-Origin": "*",
+    "Access-Control-Allow-Headers": "*",
+    "Access-Control-Allow-Methods": "GET, POST, OPTIONS"
+  };
+}
+function readBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    let size = 0;
+    req.on("data", (chunk) => {
+      size += chunk.length;
+      if (size > MAX_BODY_BYTES) {
+        reject(new Error("request body too large"));
+        req.destroy();
+        return;
+      }
+      chunks.push(chunk);
+    });
+    req.on("end", () => resolve(Buffer.concat(chunks)));
+    req.on("error", reject);
+  });
+}
+
+// src/index.ts
+var SERVER_NAME = "agent-comm-hub";
+var SERVER_VERSION = "0.1.6";
+var DEFAULT_HOST = "127.0.0.1";
+var DEFAULT_PORT = 18764;
+var DEFAULT_PATH = "/mcp";
+var DEFAULT_CONFIG = {
+  host: DEFAULT_HOST,
+  port: DEFAULT_PORT,
+  path: DEFAULT_PATH,
+  maxQueue: 200,
+  historyLimit: 100,
+  waitTimeoutMs: 6e4,
+  defaultWaitMs: 3e4,
+  connectedWindowMs: 3e4,
+  peerIdleTimeoutMs: 6e5
+};
+function startHub(config = {}, log = console) {
+  const overrides = Object.fromEntries(Object.entries(config).filter(([, value]) => value !== void 0));
+  const resolved = { ...DEFAULT_CONFIG, ...overrides };
+  const hub = new AgentHub({
+    maxQueue: resolved.maxQueue,
+    historyLimit: resolved.historyLimit,
+    waitTimeoutMs: resolved.waitTimeoutMs,
+    connectedWindowMs: resolved.connectedWindowMs,
+    peerIdleTimeoutMs: resolved.peerIdleTimeoutMs,
+    onPeerGc: (peerId) => registry.unbindPeerId(peerId),
+    // The idle GC must never evict a peer whose session has a live SSE channel.
+    isPeerLive: (peerId) => livePeersFor(registry).has(peerId)
+  });
+  const registry = new SessionRegistry();
+  const mcp = new McpStreamableHttpServer(
+    hubTools(hub, registry, { defaultWaitMs: resolved.defaultWaitMs, waitTimeoutMs: resolved.waitTimeoutMs }),
+    { name: SERVER_NAME, version: SERVER_VERSION },
+    registry,
+    (message) => log.warn(message),
+    (sessionId, clientName) => {
+      try {
+        const peer = autoRegisterPeer(hub, registry, sessionId, clientName);
+        if (peer !== void 0) log.info(`peer joined: ${peer}`);
+      } catch (error) {
+        log.warn(`auto-register failed: ${error.message}`);
+      }
+    }
+  );
+  const server = createServer();
+  mcp.attach(server, resolved.path);
+  server.on("error", (error) => log.warn(`hub http server error: ${error.message}`));
+  server.listen(resolved.port, resolved.host, () => {
+    log.info(`agent-comm-hub listening on http://${resolved.host}:${resolved.port}${resolved.path}`);
+  });
+  return {
+    hub,
+    registry,
+    server,
+    mcp,
+    close: () => {
+      hub.dispose();
+      mcp.close();
+      server.closeAllConnections?.();
+      server.close();
+    }
+  };
+}
+export {
+  AgentHub,
+  BROADCAST,
+  DEFAULT_CONFIG,
+  DEFAULT_HOST,
+  DEFAULT_PATH,
+  DEFAULT_PORT,
+  KINDS,
+  McpStreamableHttpServer,
+  PEER_ID_PATTERN,
+  SERVER_NAME,
+  SERVER_VERSION,
+  SessionRegistry,
+  autoRegisterPeer,
+  decodeContent,
+  encodeContent,
+  hubTools,
+  present,
+  sanitizePeerId,
+  startHub
+};