dsh-interconnect 0.10.1 → 0.11.1

package/lib/interconnect/index.js

@@ -1,5 +1,6 @@
 // src/interconnect/index.ts
 import { Service } from "@deepseek-ai/cordis";
+import { createHash, randomUUID, timingSafeEqual as constantTimeEqual } from "node:crypto";
 import { credentialRef } from "@deepseek-ai/dsh-credentials";
 import { boundContextSummary, createUserMessage } from "@deepseek-ai/dsh-llm";
 
@@ -818,11 +819,6 @@ defineMethod("transform", [
 
 // src/interconnect/index.ts
 import WebSocket, { WebSocketServer } from "ws";
-
-// src/interconnect/types.ts
-var INTERCONNECT_TOKEN_REF = "DSH_INTERCONNECT_TOKEN";
-
-// src/interconnect/index.ts
 function isSessionOwnedBySubagent(ctx, session, agent) {
   if (session.header.origin === "subagent") return true;
   const parentId = session.header.parentSession;
@@ -830,59 +826,84 @@ function isSessionOwnedBySubagent(ctx, session, agent) {
   const parent = ctx.agents.get(parentId);
   return parent !== void 0 && ctx.agents.isOwnedBy(agent.id, parent);
 }
+function assertNever(value) {
+  throw new Error(`interconnect: unhandled variant ${JSON.stringify(value)}`);
+}
+var INTERCONNECT_TOKEN_REF = "DSH_INTERCONNECT_TOKEN";
 var PLUGIN_SOURCE = "dsh-interconnect";
+var MAX_LINK_FRAME_BYTES = 1024 * 1024;
+var LINK_HANDSHAKE_TIMEOUT_MS = 1e4;
 var LINK_CHANNEL = "/interconnect/link";
+var MAX_LISTED_SESSIONS = 100;
 var notificationSchema = Schema.union([
-  Schema.object({ kind: Schema.const("agent/created"), sessionId: Schema.string() }),
-  Schema.object({ kind: Schema.const("agent/disposed"), sessionId: Schema.string() }),
-  Schema.object({ kind: Schema.const("agent/status"), sessionId: Schema.string(), status: Schema.union([Schema.const("idle"), Schema.const("running")]) }),
-  Schema.object({ kind: Schema.const("session/created"), sessionId: Schema.string(), parentSessionId: Schema.string() }),
-  Schema.object({ kind: Schema.const("session/disposed"), sessionId: Schema.string() }),
-  Schema.object({ kind: Schema.const("subagent/end"), provider: Schema.string(), childSessionId: Schema.string(), stopReason: Schema.string() })
+  Schema.object({ kind: Schema.const("agent/created").required(), sessionId: Schema.string().required() }),
+  Schema.object({ kind: Schema.const("agent/disposed").required(), sessionId: Schema.string().required() }),
+  Schema.object({ kind: Schema.const("agent/status").required(), sessionId: Schema.string().required(), status: Schema.union([Schema.const("idle"), Schema.const("running")]).required() }),
+  Schema.object({ kind: Schema.const("session/created").required(), sessionId: Schema.string().required(), parentSessionId: Schema.string() }),
+  Schema.object({ kind: Schema.const("session/disposed").required(), sessionId: Schema.string().required() }),
+  Schema.object({ kind: Schema.const("subagent/end").required(), provider: Schema.string().required(), childSessionId: Schema.string().required(), stopReason: Schema.string().required() })
 ]);
 var senderSchema = Schema.object({ instanceId: Schema.string(), sessionId: Schema.string() });
-var messageSchema = Schema.union([
-  Schema.object({
-    kind: Schema.const("send"),
-    sessionId: Schema.string(),
-    text: Schema.string(),
-    sender: senderSchema,
-    delivery: Schema.union([Schema.const("followup"), Schema.const("steer"), Schema.const("inject")]),
-    resume: Schema.boolean()
-  }),
-  Schema.object({
-    kind: Schema.const("reply"),
-    sessionId: Schema.string(),
-    text: Schema.string(),
-    sender: senderSchema,
-    delivery: Schema.union([Schema.const("followup"), Schema.const("steer"), Schema.const("inject")]),
-    resume: Schema.boolean()
-  })
+var pingResultSchema = Schema.object({ pong: Schema.const(true).required(), instance: Schema.string().required() });
+var listResultSchema = Schema.object({
+  instance: Schema.string().required(),
+  sessions: Schema.array(Schema.object({
+    sessionId: Schema.string().required(),
+    title: Schema.string().required(false),
+    status: Schema.string().required(false)
+  })).required()
+});
+var acceptsQueryResult = (schema, result) => {
+  try {
+    const [parsed] = Schema.resolve(result, schema, {});
+    return parsed !== void 0 && parsed !== null;
+  } catch {
+    return false;
+  }
+};
+var queryResultSchema = Schema.union([
+  pingResultSchema,
+  listResultSchema,
+  Schema.object({ accepted: Schema.const(true).required() })
 ]);
+var messageSchema = Schema.object({
+  kind: Schema.const("send").required(),
+  sessionId: Schema.string().required(),
+  text: Schema.string().required(),
+  sender: senderSchema,
+  delivery: Schema.union([Schema.const("followup"), Schema.const("steer"), Schema.const("inject")]),
+  resume: Schema.boolean()
+});
 var querySchema = Schema.union([
-  Schema.object({ kind: Schema.const("ping") }),
-  Schema.object({ kind: Schema.const("list") }),
-  Schema.object({ kind: Schema.const("event"), notification: notificationSchema })
+  Schema.object({ kind: Schema.const("ping").required() }),
+  Schema.object({ kind: Schema.const("list").required() }),
+  Schema.object({ kind: Schema.const("event").required(), notification: notificationSchema.required() })
+]);
+var msgResultSchema = Schema.union([
+  Schema.object({ delivered: Schema.const(true).required(), instance: Schema.string().required(), delivery: Schema.union([Schema.const("followup"), Schema.const("steer"), Schema.const("inject")]) }),
+  Schema.object({ delivered: Schema.const(false).required(), instance: Schema.string().required(), reason: Schema.union([
+    Schema.const("session-not-live"),
+    Schema.const("unreachable"),
+    Schema.const("resume-refused"),
+    Schema.const("resume-failed"),
+    Schema.const("session-owned-by-subagent"),
+    Schema.const("no-sender-known")
+  ]).required() })
 ]);
 var linkFrameSchema = Schema.union([
-  Schema.object({ type: Schema.const("hello"), sender: Schema.string() }),
-  Schema.object({ type: Schema.const("event"), notification: notificationSchema }),
-  Schema.object({ type: Schema.const("msg"), reqId: Schema.string(), message: messageSchema }),
-  Schema.object({ type: Schema.const("msg-result"), reqId: Schema.string(), result: Schema.object({
-    delivered: Schema.boolean(),
-    instance: Schema.string(),
-    delivery: Schema.union([Schema.const("followup"), Schema.const("steer"), Schema.const("inject")]),
-    reason: Schema.string()
-  }) }),
-  Schema.object({ type: Schema.const("query"), reqId: Schema.string(), query: querySchema }),
-  Schema.object({ type: Schema.const("query-result"), reqId: Schema.string(), result: Schema.any() })
+  Schema.object({ type: Schema.const("hello").required(), sender: Schema.string().required() }),
+  Schema.object({ type: Schema.const("event").required(), notification: notificationSchema.required() }),
+  Schema.object({ type: Schema.const("msg").required(), reqId: Schema.string().required(), message: messageSchema.required() }),
+  Schema.object({ type: Schema.const("msg-result").required(), reqId: Schema.string().required(), result: msgResultSchema.required() }),
+  Schema.object({ type: Schema.const("query").required(), reqId: Schema.string().required(), query: querySchema.required() }),
+  Schema.object({ type: Schema.const("query-result").required(), reqId: Schema.string().required(), result: queryResultSchema.required() })
 ]);
 var InterconnectService = class extends Service {
-  static inject = ["webServer", "agents", "credentials"];
+  static inject = ["agents", "credentials"];
   static Config = Schema.object({
     instanceId: Schema.string().default("dsh"),
     requestTimeoutMs: Schema.natural().max(6e4).default(1e4),
-    peers: Schema.object({}).default({}),
+    peers: Schema.dict(Schema.string()).default({}),
     delivery: Schema.union([Schema.const("followup"), Schema.const("steer"), Schema.const("inject")]).default("followup"),
     allowResume: Schema.boolean().default(true)
   });
@@ -891,7 +912,7 @@ var InterconnectService = class extends Service {
   delivery;
   allowResume;
   subscriptions = [];
-  server = new WebSocketServer({ noServer: true });
+  server = new WebSocketServer({ noServer: true, maxPayload: MAX_LINK_FRAME_BYTES });
   sockets = /* @__PURE__ */ new Set();
   /** Outbound peer links keyed by the peer's `instanceId`. */
   linkStates = /* @__PURE__ */ new Map();
@@ -903,24 +924,38 @@ var InterconnectService = class extends Service {
   /** In-flight frames sent over a peer link, keyed by `reqId`, awaiting a correlated result. */
   pendingMessages = /* @__PURE__ */ new Map();
   reqIdCounter = 0;
+  /** Set when the service fiber unwinds; guards late inbound deliveries against driving disposed agents. */
+  disposed = false;
   constructor(ctx, config) {
     super(ctx, "interconnect");
     this.instanceId = config.instanceId;
     this.requestTimeoutMs = config.requestTimeoutMs;
     this.delivery = config.delivery ?? "followup";
     this.allowResume = config.allowResume ?? true;
+    for (const origin of Object.values(config.peers ?? {})) {
+      linkUrl(trimBase(origin));
+    }
     for (const [peerInstanceId, origin] of Object.entries(config.peers ?? {})) {
       this.link(peerInstanceId, origin);
     }
     const upgrade = {
       path: LINK_CHANNEL,
       handler: (req, socket, head) => {
-        void this.handleUpgrade(req, socket, head);
+        void this.handleUpgrade(req, socket, head).catch((error) => {
+          this.ctx.logger.warn(`interconnect: upgrade failed: ${error instanceof Error ? error.message : String(error)}`);
+          socket.destroy();
+        });
       }
     };
-    ctx.effect(() => ctx.webServer.registerUpgrade(upgrade), "interconnect: /interconnect/link websocket");
+    ctx.inject(["webServer"], (webCtx) => {
+      webCtx.effect(() => webCtx.webServer.registerUpgrade(upgrade), "interconnect: /interconnect/link websocket");
+    });
     this.heartbeatTimer = setInterval(() => {
       for (const socket of this.sockets) {
+        if (socket.readyState !== WebSocket.OPEN) {
+          this.sockets.delete(socket);
+          continue;
+        }
         if (socket.isAlive === false) {
           socket.terminate();
           this.sockets.delete(socket);
@@ -949,6 +984,7 @@ var InterconnectService = class extends Service {
       });
     }));
     this.subscriptions.push(ctx.on("session/disposed", (session) => {
+      this.senders.delete(String(session.id));
       this.fanout({ kind: "session/disposed", sessionId: String(session.id) });
     }));
     this.subscriptions.push(ctx.on("subagent/end", (info) => {
@@ -970,16 +1006,28 @@ var InterconnectService = class extends Service {
       for (const socket of this.sockets) socket.terminate();
       this.sockets.clear();
       this.server.close();
+      for (const pending of this.pendingMessages.values()) {
+        clearTimeout(pending.timer);
+        pending.resolve?.(void 0);
+      }
+      this.pendingMessages.clear();
+      this.disposed = true;
     }, "interconnect: websocket teardown");
   }
   /**
    * This instance's identity to attach to outbound messages. Always present:
    * it needs no address, only this instance's id and the calling session.
    * @param sessionId - the local session that is sending, used as the reply target.
+   * @returns this instance's address-free identity for the calling session.
    */
   selfSender(sessionId) {
     return { instanceId: this.instanceId, sessionId };
   }
+  /**
+   * Deliver one text message to a live session on a peer instance.
+   * @param request - the peer instance id, target session, text, and optional delivery/resume overrides.
+   * @returns the peer's answer, or an unreachable result when no link answers.
+   */
   async send(request) {
     const payload = {
       sessionId: request.sessionId,
@@ -988,14 +1036,20 @@ var InterconnectService = class extends Service {
       ...request.delivery === void 0 ? {} : { delivery: request.delivery },
       ...request.resume === void 0 ? {} : { resume: request.resume }
     };
-    const result = await this.msgRequest(request.instanceId, "send", payload);
-    return result ?? { delivered: false, instance: this.instanceId, reason: "unreachable" };
+    try {
+      const result = await this.msgRequest(request.instanceId, "send", payload);
+      return result ?? { delivered: false, instance: request.instanceId, reason: "unreachable" };
+    } catch {
+      return { delivered: false, instance: request.instanceId, reason: "unreachable" };
+    }
   }
   /**
    * Deliver one text message back to the peer that a local session last
    * received a send from. `sessionId` names the LOCAL replying session; the
    * outbound target is the `sender` that session recorded, addressed through
    * this instance's own link to the sender's instance.
+   * @param request - the LOCAL replying session id, the reply text, and optional delivery/resume overrides.
+   * @returns the recalled sender's answer, or an unreachable result when no link answers.
    */
   async reply(request) {
     const sender = this.senders.get(request.sessionId);
@@ -1011,13 +1065,19 @@ var InterconnectService = class extends Service {
       // back — chaining the conversation.
       sender: this.selfSender(request.sessionId)
     };
-    const result = await this.msgRequest(sender.instanceId, "send", payload);
-    return result ?? { delivered: false, instance: this.instanceId, reason: "unreachable" };
+    try {
+      const result = await this.msgRequest(sender.instanceId, "send", payload);
+      return result ?? { delivered: false, instance: sender.instanceId, reason: "unreachable" };
+    } catch {
+      return { delivered: false, instance: sender.instanceId, reason: "unreachable" };
+    }
   }
   /**
    * Probe a peer instance for liveness and identity over its persistent link.
    * Returns the peer identity when reachable, or undefined when the link is
    * not up or no answer arrives.
+   * @param instanceId - the peer's `instanceId` as configured under {@link Config.peers}.
+   * @returns the peer's identity, or undefined when the link is not up or no answer arrives.
    */
   async ping(instanceId) {
     return this.queryRequest(instanceId, { kind: "ping" });
@@ -1025,15 +1085,12 @@ var InterconnectService = class extends Service {
   /**
    * List a peer instance's live sessions over its persistent link. Undefined on
    * transport failure, matching `ping`.
+   * @param instanceId - the peer's `instanceId` as configured under {@link Config.peers}.
+   * @returns the peer's live session rows, or undefined on transport failure.
    */
   async list(instanceId) {
     return this.queryRequest(instanceId, { kind: "list" });
   }
-  /** The origin this instance dials to reach a configured peer, or undefined. */
-  originOf(instanceId) {
-    const state = this.linkStates.get(instanceId);
-    return state?.peer;
-  }
   /**
    * Send a `msg` frame over the live link to a peer and resolve with its
    * correlated `msg-result`. Undefined when the peer has no live link here
@@ -1043,7 +1100,7 @@ var InterconnectService = class extends Service {
   async msgRequest(instanceId, kind, payload) {
     const state = this.linkStates.get(instanceId);
     if (state === void 0 || !state.writable()) return void 0;
-    const reqId = `m${++this.reqIdCounter}-${crypto.randomUUID()}`;
+    const reqId = `m${++this.reqIdCounter}-${randomUUID()}`;
     const message = {
       kind,
       sessionId: payload.sessionId,
@@ -1052,7 +1109,7 @@ var InterconnectService = class extends Service {
       ...payload.delivery === void 0 ? {} : { delivery: payload.delivery },
       ...payload.resume === void 0 ? {} : { resume: payload.resume }
     };
-    return this.waitForResult(reqId, (failure) => {
+    return this.waitForResult(reqId, "msg", (failure) => {
       const wrote = state.sendFrame({ type: "msg", reqId, message });
       if (!wrote) failure(new Error(`interconnect: peer link to ${instanceId} closed while sending`));
     });
@@ -1061,32 +1118,34 @@ var InterconnectService = class extends Service {
   async queryRequest(instanceId, query) {
     const state = this.linkStates.get(instanceId);
     if (state === void 0 || !state.writable()) return void 0;
-    const reqId = `q${++this.reqIdCounter}-${crypto.randomUUID()}`;
-    return this.waitForResult(reqId, (failure) => {
-      const wrote = state.sendFrame({ type: "query", reqId, query });
-      if (!wrote) failure(new Error(`interconnect: peer link to ${instanceId} closed while querying`));
-    });
+    const reqId = `q${++this.reqIdCounter}-${randomUUID()}`;
+    const accept = query.kind === "ping" ? (result) => acceptsQueryResult(pingResultSchema, result) : (result) => acceptsQueryResult(listResultSchema, result);
+    try {
+      return await this.waitForResult(reqId, "query", (failure) => {
+        const wrote = state.sendFrame({ type: "query", reqId, query });
+        if (!wrote) failure(new Error(`interconnect: peer link to ${instanceId} closed while querying`));
+      }, accept);
+    } catch {
+      return void 0;
+    }
   }
   /** Settle a `reqId` frame against its `*-result`, timing out at `requestTimeoutMs`. */
-  waitForResult(reqId, send) {
+  waitForResult(reqId, kind, send, accept) {
     return new Promise((resolve2, reject) => {
       const timer = setTimeout(() => {
         this.pendingMessages.delete(reqId);
         reject(new Error(`interconnect: no result for ${reqId} within ${this.requestTimeoutMs}ms`));
       }, this.requestTimeoutMs);
-      this.pendingMessages.set(reqId, { timer });
-      const pending = this.pendingMessages.get(reqId);
-      if (pending === void 0) return;
-      pending.resolve = (result) => {
-        clearTimeout(timer);
-        this.pendingMessages.delete(reqId);
-        resolve2(result);
-      };
-      pending.reject = (error) => {
-        clearTimeout(timer);
-        this.pendingMessages.delete(reqId);
-        reject(error instanceof Error ? error : new Error(String(error)));
-      };
+      this.pendingMessages.set(reqId, {
+        timer,
+        kind,
+        ...accept === void 0 ? {} : { accept },
+        resolve: (result) => {
+          clearTimeout(timer);
+          this.pendingMessages.delete(reqId);
+          resolve2(result);
+        }
+      });
       send((error) => {
         clearTimeout(timer);
         this.pendingMessages.delete(reqId);
@@ -1102,12 +1161,20 @@ var InterconnectService = class extends Service {
    * @returns disposer removing the peer route.
    */
   subscribe(instanceId, origin) {
-    this.link(instanceId, origin);
+    const linked = this.link(instanceId, origin);
+    const dialedOrigin = trimBase(origin);
     return () => {
-      this.forgetLink(instanceId);
+      const state = this.linkStates.get(instanceId);
+      if (state === linked && state.peer === dialedOrigin) {
+        state.close();
+        this.linkStates.delete(instanceId);
+      }
     };
   }
-  /** Remove a peer route, closing its outbound link. */
+  /**
+   * Remove a peer route, closing its outbound link.
+   * @param instanceId - the peer route to remove.
+   */
   unsubscribe(instanceId) {
     const state = this.linkStates.get(instanceId);
     if (state !== void 0) state.close();
@@ -1124,19 +1191,23 @@ var InterconnectService = class extends Service {
    */
   link(instanceId, origin) {
     const existing = this.linkStates.get(instanceId);
-    if (existing !== void 0) {
+    if (existing !== void 0 && !existing.isClosed()) {
       existing.reroute(trimBase(origin));
       return existing;
     }
-    const state = new LinkState(this, instanceId, trimBase(origin));
+    const state = new LinkState(
+      (socket) => {
+        this.attachSocket(socket);
+      },
+      this.ctx.logger,
+      () => this.resolveTokenForDial(),
+      instanceId,
+      trimBase(origin)
+    );
     this.linkStates.set(instanceId, state);
     state.dial();
     return state;
   }
-  /** Remove a closed outbound link's state so a later `link` re-dials fresh. */
-  forgetLink(instanceId) {
-    this.linkStates.delete(instanceId);
-  }
   /** Push one serialized lifecycle fact out to every linked peer over WS. */
   fanout(notification) {
     this.broadcast(notification);
@@ -1146,11 +1217,15 @@ var InterconnectService = class extends Service {
     if (this.sockets.size === 0) return;
     const frame = { type: "event", notification };
     const encoded = JSON.stringify(frame);
+    const sent = /* @__PURE__ */ new Set();
     for (const socket of this.sockets) {
       if (socket.readyState !== WebSocket.OPEN) {
         this.sockets.delete(socket);
         continue;
       }
+      const peer = this.peerOf.get(socket);
+      if (peer !== void 0 && sent.has(peer)) continue;
+      if (peer !== void 0) sent.add(peer);
       socket.send(encoded);
     }
   }
@@ -1160,27 +1235,18 @@ var InterconnectService = class extends Service {
    * result so a throwing handler cannot escape the socket's message callback.
    */
   async handleMsgFrame(socket, reqId, message) {
-    let result;
-    if (message.kind === "reply") {
-      result = await this.replyForSession({
-        sessionId: message.sessionId,
-        text: message.text,
-        ...message.delivery === void 0 ? {} : { delivery: message.delivery },
-        ...message.resume === void 0 ? {} : { resume: message.resume }
-      });
-    } else {
-      result = await this.deliver({
-        sessionId: message.sessionId,
-        text: message.text,
-        ...message.sender === void 0 ? {} : { sender: message.sender },
-        ...message.delivery === void 0 ? {} : { delivery: message.delivery },
-        ...message.resume === void 0 ? {} : { resume: message.resume }
-      });
-    }
+    const result = await this.deliver({
+      sessionId: message.sessionId,
+      text: message.text,
+      /* v8 ignore next 1 -- schemastery resolves an absent optional `sender` to an empty object, never undefined. */
+      ...message.sender === void 0 ? {} : { sender: message.sender },
+      ...message.delivery === void 0 ? {} : { delivery: message.delivery },
+      ...message.resume === void 0 ? {} : { resume: message.resume }
+    });
     this.sendFrame(socket, { type: "msg-result", reqId, result });
   }
   /** Dispatch one inbound `query` frame (ping/list/event) and answer on the socket. */
-  async handleQueryFrame(socket, reqId, query) {
+  handleQueryFrame(socket, reqId, query) {
     let result;
     if (query.kind === "ping") {
       result = { pong: true, instance: this.instanceId };
@@ -1202,9 +1268,11 @@ var InterconnectService = class extends Service {
     this.ctx.emit("interconnect/event", eventPayload.notification, eventPayload.sender);
   }
   /**
-   * Summarize every live local session so a sender can discover valid targets
+   * Summarize the live local sessions so a sender can discover valid targets
    * instead of having to know a session id already. Only live agents are listed
-   * because `send` can reach exactly those.
+   * because `send` can reach exactly those, and the answer carries at most
+   * {@link MAX_LISTED_SESSIONS} rows so a large live set cannot push the
+   * `query-result` frame past the link's frame cap.
    *
    * Title and status are best-effort: the title projection is an optional
    * service, and a receiver without it still returns the ids. A projection that
@@ -1213,7 +1281,7 @@ var InterconnectService = class extends Service {
    */
   listSessions() {
     const reachable = this.ctx.agents.list().filter((agent) => !isSessionOwnedBySubagent(this.ctx, agent.session, agent));
-    const sessions = reachable.map((agent) => {
+    const sessions = reachable.slice(0, MAX_LISTED_SESSIONS).map((agent) => {
       let title;
       try {
         const snapshot = this.ctx.get("sessionProjections")?.snapshot(agent.session);
@@ -1253,7 +1321,9 @@ var InterconnectService = class extends Service {
       if (resolved === void 0 || resolved === null) return { reason: "session-not-live" };
       return { agent: resolved };
     } catch (error) {
-      this.ctx.logger.info(`interconnect: resume refused for ${payload.sessionId}: ${error instanceof Error ? error.message : String(error)}`);
+      this.ctx.logger.info(
+        `interconnect: resume refused for ${payload.sessionId}: ${error instanceof Error ? error.message : String(error)}`
+      );
       return { reason: "resume-failed" };
     }
   }
@@ -1262,9 +1332,11 @@ var InterconnectService = class extends Service {
    * when the sender asked and this receiver allows it.
    */
   async deliver(payload) {
+    if (this.disposed) return { delivered: false, instance: this.instanceId, reason: "unreachable" };
     let agent = this.ctx.agents.get(payload.sessionId);
     if (agent === void 0) {
       const woken = await this.wake(payload);
+      if (this.disposed) return { delivered: false, instance: this.instanceId, reason: "unreachable" };
       if ("reason" in woken) {
         return { delivered: false, instance: this.instanceId, reason: woken.reason };
       }
@@ -1275,11 +1347,11 @@ var InterconnectService = class extends Service {
     }
     const sender = (() => {
       const candidate = payload.sender;
-      return candidate === void 0 || typeof candidate.instanceId !== "string" ? void 0 : candidate;
+      if (typeof candidate !== "object" || candidate === null) return void 0;
+      const record = candidate;
+      if (typeof record.instanceId !== "string" || typeof record.sessionId !== "string") return void 0;
+      return { instanceId: record.instanceId, sessionId: record.sessionId };
     })();
-    if (sender !== void 0) {
-      this.senders.set(payload.sessionId, sender);
-    }
     const message = createUserMessage({
       source: {
         kind: "plugin",
@@ -1302,27 +1374,21 @@ var InterconnectService = class extends Service {
       case "followup":
         agent.followup(message);
         break;
+      /* v8 ignore next -- closed-union exhaustiveness guard */
+      default:
+        assertNever(mode);
+    }
+    if (sender !== void 0) {
+      this.senders.set(payload.sessionId, sender);
+    } else {
+      this.senders.delete(payload.sessionId);
     }
     return { delivered: true, instance: this.instanceId, delivery: mode };
   }
-  /**
-   * Inbound `reply` dispatch: forward a request to {link reply}, resolving the
-   * outbound sender for the named local session. Kept separate from {link
-   * deliver} so the two wire endpoints stay distinct in the request pipeline.
-   */
-  async replyForSession(payload) {
-    return this.reply({
-      sessionId: payload.sessionId,
-      text: payload.text,
-      ...payload.delivery === void 0 ? {} : { delivery: payload.delivery },
-      ...payload.resume === void 0 ? {} : { resume: payload.resume }
-    });
-  }
   async resolveToken() {
     const credential = await this.ctx.credentials.resolve(credentialRef(INTERCONNECT_TOKEN_REF));
     return credential === void 0 || credential.value.length === 0 ? void 0 : credential.value;
   }
-  /** Resolve the shared token for an outbound dial (same source as inbound). */
   resolveTokenForDial() {
     return this.resolveToken();
   }
@@ -1340,6 +1406,10 @@ var InterconnectService = class extends Service {
       socket.end("HTTP/1.1 403 Forbidden\r\nConnection: close\r\nContent-Length: 9\r\n\r\nforbidden");
       return;
     }
+    if (this.disposed) {
+      socket.end("HTTP/1.1 503 Service Unavailable\r\nConnection: close\r\nContent-Length: 11\r\n\r\nunavailable");
+      return;
+    }
     const expected = `Bearer ${token}`;
     const header = req.headers.authorization;
     if (header === void 0 || !timingSafeEqual(header, expected)) {
@@ -1353,7 +1423,10 @@ var InterconnectService = class extends Service {
   /**
    * Install frame + liveness handling on one socket and add it to the live
    * pool. Used by both the server half (accepted upgrade) and the client half
-   * (outbound dial), so a single socket carries events both directions.
+   * (outbound dial), so a single socket carries events both directions. Not a
+   * model-facing entry point; the outbound dial reaches it through a private
+   * closure.
+   * @param websocket - the accepted or dialed socket to install handlers on.
    */
   attachSocket(websocket) {
     this.sockets.add(websocket);
@@ -1362,7 +1435,8 @@ var InterconnectService = class extends Service {
       ;
       websocket.isAlive = true;
     });
-    websocket.on("message", (data) => {
+    websocket.on("message", (data, isBinary) => {
+      if (isBinary) return;
       this.handleFrame(websocket, data);
     });
     websocket.on("close", () => {
@@ -1376,31 +1450,43 @@ var InterconnectService = class extends Service {
   }
   /** Parse and route one inbound link frame, attributing events to the socket's announced peer. */
   handleFrame(socket, data) {
-    if (Array.isArray(data)) return;
-    const text = Buffer.isBuffer(data) ? data.toString("utf8") : Buffer.from(data).toString("utf8");
-    let frame;
+    const byteLength = typeof data === "string" ? Buffer.byteLength(data) : Array.isArray(data) ? data.reduce((total, part) => total + part.byteLength, 0) : data.byteLength;
+    if (byteLength > MAX_LINK_FRAME_BYTES) {
+      this.ctx.logger.warn("interconnect: dropping oversized link frame");
+      return;
+    }
+    const text = typeof data === "string" ? data : Array.isArray(data) ? Buffer.concat(data).toString("utf8") : Buffer.isBuffer(data) ? data.toString("utf8") : Buffer.from(data).toString("utf8");
+    let parsed;
     try {
-      frame = Schema.resolve(JSON.parse(text), linkFrameSchema, {})[0];
+      parsed = Schema.resolve(JSON.parse(text), linkFrameSchema, {})[0];
     } catch {
       this.ctx.logger.warn("interconnect: dropping malformed link frame");
       return;
     }
+    if (parsed === null || typeof parsed !== "object") {
+      this.ctx.logger.warn("interconnect: dropping malformed link frame");
+      return;
+    }
+    const frame = parsed;
     if (frame.type === "hello") {
       this.peerOf.set(socket, frame.sender);
       return;
     }
     if (frame.type === "event") {
       const sender = this.peerOf.get(socket) ?? "unknown-peer";
+      const kind = frame.notification.kind;
       try {
         this.receiveEvent({ sender, notification: frame.notification });
       } catch (error) {
-        this.ctx.logger.warn(`interconnect: listener for a ${frame.notification.kind} event from ${sender} threw: ${error instanceof Error ? error.message : String(error)}`);
+        this.ctx.logger.warn(
+          `interconnect: listener for a ${kind} event from ${sender} threw: ` + (error instanceof Error ? error.message : String(error))
+        );
       }
       return;
     }
     if (frame.type === "msg-result") {
       const pending = this.pendingMessages.get(frame.reqId);
-      if (pending !== void 0) {
+      if (pending !== void 0 && pending.kind === "msg") {
         ;
         pending.resolve?.(frame.result);
       }
@@ -1408,7 +1494,7 @@ var InterconnectService = class extends Service {
     }
     if (frame.type === "query-result") {
       const pending = this.pendingMessages.get(frame.reqId);
-      if (pending !== void 0) {
+      if (pending !== void 0 && pending.kind === "query" && (pending.accept === void 0 || pending.accept(frame.result))) {
         ;
         pending.resolve?.(frame.result);
       }
@@ -1427,8 +1513,8 @@ var InterconnectService = class extends Service {
       });
       return;
     }
-    void Promise.resolve().then(async () => {
-      await this.handleQueryFrame(socket, frame.reqId, frame.query);
+    void Promise.resolve().then(() => {
+      this.handleQueryFrame(socket, frame.reqId, frame.query);
     }).catch((error) => {
       this.ctx.logger.warn(`interconnect: query ${frame.reqId} handler threw: ${error instanceof Error ? error.message : String(error)}`);
     });
@@ -1441,15 +1527,21 @@ var InterconnectService = class extends Service {
   }
 };
 var LinkState = class {
-  constructor(owner, instanceId, origin) {
-    this.owner = owner;
+  constructor(attachSocket, logger, resolveToken, instanceId, origin) {
+    this.attachSocket = attachSocket;
+    this.logger = logger;
+    this.resolveToken = resolveToken;
     this.instanceId = instanceId;
     this.peer = origin;
   }
   socket;
+  dialEpoch = 0;
   closed = false;
   retry = 0;
   reconnectTimer;
+  warnedNoToken = false;
+  /** Dial-registered handlers, removed by reference on close/reroute so the pool-cleanup handlers attachSocket added stay alive. */
+  dialListeners;
   // `peer` is mutable so `reroute` can point the link at a new origin.
   peer;
   instanceId;
@@ -1457,9 +1549,16 @@ var LinkState = class {
   reroute(origin) {
     if (origin === this.peer) return;
     this.peer = origin;
+    this.dialEpoch += 1;
+    if (this.reconnectTimer !== void 0) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = void 0;
+    }
     const socket = this.socket;
     if (socket !== void 0) {
-      socket.removeAllListeners();
+      this.removeDialListeners(socket);
+      socket.on("error", () => {
+      });
       socket.terminate();
       this.socket = void 0;
     }
@@ -1468,29 +1567,59 @@ var LinkState = class {
   /** Open the socket; reconnect is scheduled by the close handler. */
   dial() {
     if (this.closed) return;
-    const url = new URL("/interconnect/link", this.peer);
-    url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
-    void this.owner.resolveTokenForDial().then((token) => {
-      if (token === void 0 || this.closed) return;
+    const epoch = this.dialEpoch;
+    let url;
+    try {
+      url = linkUrl(this.peer);
+    } catch {
+      this.logger.warn(`interconnect: invalid peer origin ${this.peer}; link to ${this.instanceId} stays down`);
+      return;
+    }
+    void this.resolveToken().then((token) => {
+      if (token === void 0) {
+        if (!this.warnedNoToken) {
+          this.warnedNoToken = true;
+          this.logger.warn(`interconnect: no shared token configured; peer ${this.instanceId} link stays down, retrying until one is set`);
+        }
+        if (this.closed || epoch !== this.dialEpoch) return;
+        this.scheduleReconnect();
+        return;
+      }
+      if (this.closed || epoch !== this.dialEpoch) return;
       const socket = new WebSocket(url, {
-        headers: { authorization: `Bearer ${token}` }
+        headers: { authorization: `Bearer ${token}` },
+        maxPayload: MAX_LINK_FRAME_BYTES,
+        // A peer that accepts TCP but never completes the upgrade would leave
+        // the socket in CONNECTING forever: no open (so no heartbeat) and no
+        // close (so no reconnect). ws aborts the connection past the handshake
+        // window, so its own error+close fire and the close handler schedules
+        // a reconnect — and ws owns the timer, so nothing leaks on teardown.
+        handshakeTimeout: LINK_HANDSHAKE_TIMEOUT_MS
       });
       this.socket = socket;
-      socket.once("open", () => {
+      const onOpen = () => {
         this.retry = 0;
-        this.owner.attachSocket(socket);
-      });
-      socket.once("close", () => {
+        this.attachSocket(socket);
+      };
+      const onClose = () => {
         if (this.closed) return;
         this.scheduleReconnect();
-      });
-      socket.on("error", () => {
-      });
+      };
+      const onError = () => {
+      };
+      this.dialListeners = { open: onOpen, close: onClose, error: onError };
+      socket.once("open", onOpen);
+      socket.once("close", onClose);
+      socket.on("error", onError);
     }).catch(() => {
-      if (this.closed) return;
+      if (this.closed || epoch !== this.dialEpoch) return;
       this.scheduleReconnect();
     });
   }
+  /** Whether this link has been closed; a closed state is never reused by `link()`. */
+  isClosed() {
+    return this.closed;
+  }
   /** Whether this link currently holds an open socket that can carry frames. */
   writable() {
     return this.socket !== void 0 && this.socket.readyState === WebSocket.OPEN;
@@ -1504,14 +1633,24 @@ var LinkState = class {
   }
   close() {
     this.closed = true;
-    this.owner.forgetLink(this.peer);
     if (this.reconnectTimer !== void 0) clearTimeout(this.reconnectTimer);
     const socket = this.socket;
     if (socket !== void 0) {
-      socket.removeAllListeners();
+      this.removeDialListeners(socket);
+      socket.on("error", () => {
+      });
       socket.terminate();
     }
   }
+  /** Detach the dial-registered handlers from a socket before terminating it. */
+  removeDialListeners(socket) {
+    const listeners = this.dialListeners;
+    if (listeners === void 0) return;
+    socket.removeListener("open", listeners.open);
+    socket.removeListener("close", listeners.close);
+    socket.removeListener("error", listeners.error);
+    this.dialListeners = void 0;
+  }
   scheduleReconnect() {
     const delay = Math.min(3e4, 1e3 * 2 ** this.retry);
     this.retry += 1;
@@ -1522,12 +1661,16 @@ var LinkState = class {
   }
 };
 function timingSafeEqual(a, b) {
-  if (a.length !== b.length) return false;
-  let diff = 0;
-  for (let i = 0; i < a.length; i += 1) {
-    diff |= a.charCodeAt(i) ^ b.charCodeAt(i);
-  }
-  return diff === 0;
+  return constantTimeEqual(createHash("sha256").update(a, "utf8").digest(), createHash("sha256").update(b, "utf8").digest());
+}
+function linkUrl(origin) {
+  const url = new URL("/interconnect/link", origin);
+  if (url.protocol === "http:") url.protocol = "ws:";
+  else if (url.protocol === "https:") url.protocol = "wss:";
+  if (url.protocol !== "ws:" && url.protocol !== "wss:") {
+    throw new TypeError(`interconnect: unsupported peer origin protocol ${url.protocol}`);
+  }
+  return url;
 }
 function trimBase(baseUrl) {
   return baseUrl.replace(/\/+$/, "");
@@ -1536,6 +1679,7 @@ var index_default = InterconnectService;
 export {
   INTERCONNECT_TOKEN_REF,
   InterconnectService,
-  index_default as default
+  index_default as default,
+  linkUrl
 };
 //# sourceMappingURL=index.js.map