dsh-interconnect 0.11.11 → 0.11.13

package/lib/tool-interconnect/index.js

@@ -5,6 +5,7 @@ import { defineTool } from "@deepseek-ai/dsh-tools";
 import { Service } from "@deepseek-ai/cordis";
 import { createHash, randomUUID, timingSafeEqual as constantTimeEqual } from "node:crypto";
 import { credentialRef } from "@deepseek-ai/dsh-credentials";
+import { remoteErrorOf } from "@deepseek-ai/dsh-typert-protocol";
 import { boundContextSummary, createUserMessage } from "@deepseek-ai/dsh-llm";
 
 // ../.dsh/source/staging-20260807T143236Z/vendor/cosmokit/src/misc.ts
@@ -948,6 +949,8 @@ var InterconnectService = class extends Service {
   heartbeatTimer;
   /** Peer identity each live socket announced via its `hello` frame, if any. */
   peerOf = /* @__PURE__ */ new WeakMap();
+  /** Configured peer an outbound dial owns a socket for; absent on inbound sockets. */
+  dialedPeerOf = /* @__PURE__ */ new WeakMap();
   /** Sender each local session last received a send from, keyed by local session id. */
   senders = /* @__PURE__ */ new Map();
   /** In-flight frames sent over a peer link, keyed by `reqId`, awaiting a correlated result. */
@@ -1179,50 +1182,16 @@ var InterconnectService = class extends Service {
     });
   }
   /**
-   * Add a peer route at runtime. Returns a disposer that removes it. Re-adding
-   * an existing instanceId re-routes it to the new origin.
-   * @param instanceId - the peer's `instanceId`.
-   * @param origin - origin this instance dials to reach that peer.
-   * @returns disposer removing the peer route.
-   */
-  subscribe(instanceId, origin) {
-    const linked = this.link(instanceId, origin);
-    const dialedOrigin = trimBase(origin);
-    return () => {
-      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.
-   * @param instanceId - the peer route to remove.
-   */
-  unsubscribe(instanceId) {
-    const state = this.linkStates.get(instanceId);
-    if (state !== void 0) state.close();
-    this.linkStates.delete(instanceId);
-  }
-  /**
-   * Open (and, on drop, re-open) a persistent WebSocket link to a peer. Local
-   * events stream over the link in real time, and events the peer pushes are
-   * surfaced as `interconnect/event`. Repeating for the same instanceId
-   * re-routes the link to the new origin.
+   * Dial one configured peer route. Activation calls this once per
+   * `Config.peers` entry; the resulting state owns reconnection for the life of
+   * the service fiber.
    * @param instanceId - the peer's `instanceId`.
    * @param origin - receiver origin this instance dials, e.g. `http://127.0.0.1:13080`.
-   * @returns a handle closing the link and cancelling reconnection.
    */
   link(instanceId, origin) {
-    const existing = this.linkStates.get(instanceId);
-    if (existing !== void 0 && !existing.isClosed()) {
-      existing.reroute(trimBase(origin));
-      return existing;
-    }
     const state = new LinkState(
       (socket) => {
-        this.attachSocket(socket);
+        this.attachDialedSocket(socket, instanceId);
       },
       this.ctx.logger,
       () => this.resolveToken(),
@@ -1231,26 +1200,41 @@ var InterconnectService = class extends Service {
     );
     this.linkStates.set(instanceId, state);
     state.dial();
-    return state;
   }
   /** Push one serialized lifecycle fact out to every linked peer over WS. */
   fanout(notification) {
     this.broadcast(notification);
   }
-  /** Push one fact over every live WebSocket link, dropping closed sockets. */
+  /**
+   * Push one fact over every live WebSocket link, dropping closed sockets.
+   *
+   * A bidirectional pair owns two sockets to the same peer (this instance's
+   * dialed link plus the peer's inbound one), so one event must leave over one
+   * of them. Which one is decided by local ownership, not by the peer: a dialed
+   * socket is a configured peer's link and always sends. An inbound socket is
+   * skipped only when a dialed link to the id that socket itself announced is
+   * open, so an announcement can suppress nothing but a duplicate the
+   * controlled link already carries — an impostor cannot drop an event for a
+   * peer, and without a dialed link every inbound socket receives it.
+   */
   broadcast(notification) {
     if (this.sockets.size === 0) return;
     const frame = { type: "event", notification };
     const encoded = JSON.stringify(frame);
-    const sent = /* @__PURE__ */ new Set();
+    const covered = /* @__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);
+      const dialedPeer = this.dialedPeerOf.get(socket);
+      if (dialedPeer !== void 0) covered.add(dialedPeer);
+    }
+    for (const socket of this.sockets) {
+      if (this.dialedPeerOf.get(socket) === void 0) {
+        const announced = this.peerOf.get(socket);
+        if (announced !== void 0 && covered.has(announced)) continue;
+      }
       socket.send(encoded);
     }
   }
@@ -1381,6 +1365,9 @@ var InterconnectService = class extends Service {
       this.ctx.logger.info(
         `interconnect: resume refused for ${payload.sessionId}: ${error instanceof Error ? error.message : String(error)}`
       );
+      if (remoteErrorOf(error)?.code === "session/agent-busy") {
+        return { reason: "session-owned-by-subagent" };
+      }
       return { reason: "resume-failed" };
     }
   }
@@ -1487,6 +1474,17 @@ var InterconnectService = class extends Service {
       this.attachSocket(websocket);
     });
   }
+  /**
+   * Install frame + liveness handling on one outbound socket the dial owns for
+   * a configured peer, recording that local ownership before anything else can
+   * observe the socket.
+   * @param websocket - the dialed socket.
+   * @param peerInstanceId - the configured peer this instance dials.
+   */
+  attachDialedSocket(websocket, peerInstanceId) {
+    this.dialedPeerOf.set(websocket, peerInstanceId);
+    this.attachSocket(websocket);
+  }
   /**
    * 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
@@ -1593,40 +1591,17 @@ var LinkState = class {
     this.instanceId = instanceId;
     this.peer = origin;
   }
-  socket;
-  dialEpoch = 0;
+  dialed;
   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.
+  /** Receiver origin this link dials. */
   peer;
   instanceId;
-  /** Point this link at a different origin; re-dials immediately. */
-  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) {
-      this.removeDialListeners(socket);
-      socket.on("error", () => {
-      });
-      socket.terminate();
-      this.socket = void 0;
-    }
-    this.dial();
-  }
   /** Open the socket; reconnect is scheduled by the close handler. */
   dial() {
     if (this.closed) return;
-    const epoch = this.dialEpoch;
     let url;
     try {
       url = linkUrl(this.peer);
@@ -1640,11 +1615,11 @@ var LinkState = class {
           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;
+        if (this.closed) return;
         this.scheduleReconnect();
         return;
       }
-      if (this.closed || epoch !== this.dialEpoch) return;
+      if (this.closed) return;
       const socket = new WebSocket(url, {
         headers: { authorization: `Bearer ${token}` },
         maxPayload: MAX_LINK_FRAME_BYTES,
@@ -1655,7 +1630,6 @@ var LinkState = class {
         // a reconnect — and ws owns the timer, so nothing leaks on teardown.
         handshakeTimeout: LINK_HANDSHAKE_TIMEOUT_MS
       });
-      this.socket = socket;
       const onOpen = () => {
         this.retry = 0;
         this.attachSocket(socket);
@@ -1666,49 +1640,38 @@ var LinkState = class {
       };
       const onError = () => {
       };
-      this.dialListeners = { open: onOpen, close: onClose, error: onError };
+      this.dialed = { socket, open: onOpen, close: onClose, error: onError };
       socket.once("open", onOpen);
       socket.once("close", onClose);
       socket.on("error", onError);
     }).catch(() => {
-      if (this.closed || epoch !== this.dialEpoch) return;
+      if (this.closed) 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;
+    const dialed = this.dialed;
+    return dialed !== void 0 && dialed.socket.readyState === WebSocket.OPEN;
   }
   /** Write one frame over this link's outbound socket; false when not open. */
   sendFrame(frame) {
-    const socket = this.socket;
-    if (socket === void 0 || socket.readyState !== WebSocket.OPEN) return false;
-    socket.send(JSON.stringify(frame));
+    const dialed = this.dialed;
+    if (dialed === void 0 || dialed.socket.readyState !== WebSocket.OPEN) return false;
+    dialed.socket.send(JSON.stringify(frame));
     return true;
   }
   close() {
     this.closed = true;
     if (this.reconnectTimer !== void 0) clearTimeout(this.reconnectTimer);
-    const socket = this.socket;
-    if (socket !== void 0) {
-      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;
+    const dialed = this.dialed;
+    if (dialed === void 0) return;
+    dialed.socket.removeListener("open", dialed.open);
+    dialed.socket.removeListener("close", dialed.close);
+    dialed.socket.removeListener("error", dialed.error);
+    dialed.socket.on("error", () => {
+    });
+    dialed.socket.terminate();
   }
   scheduleReconnect() {
     const delay = Math.min(3e4, 1e3 * 2 ** this.retry);
@@ -1945,7 +1908,7 @@ function apply(ctx) {
   }));
   ctx.tools.register(defineTool({
     name: "interconnect_reply",
-    description: `Deliver one text message back to the peer that this session last received an interconnect message from. Only the reply text is needed: the replying session is this agent's own, and the outbound target (the sending instance id and session id) is recalled from the message this session received, so you do not ask for an address twice. A session that never received a message through interconnect \u2014 or received one without a sender identity \u2014 reports reason "no-sender-known".`,
+    description: `Deliver one text message back to the peer that this session last received an interconnect message from. Only the reply text is needed: the replying session is this agent's own, and the outbound target (the sending instance id and session id) is recalled from the message this session received, so you do not ask for an address twice. The recalled target is the most recent sender only: a later message from another peer replaces it, and restarting this instance forgets it until a new message arrives, so name the intended recipient in the reply text when more than one peer may message this session. A session that never received a message through interconnect \u2014 or received one without a sender identity \u2014 reports reason "no-sender-known".`,
     parameters: {
       text: {
         type: "string",