dsh-interconnect 0.11.9 → 0.11.11

package/lib/tool-interconnect/index.js

@@ -1287,10 +1287,22 @@ var InterconnectService = class extends Service {
     }
     this.sendFrame(socket, { type: "query-result", reqId, result });
   }
-  /** Surface one remote notification to local listeners and the log. */
+  /**
+   * Surface one remote notification to local listeners and the log.
+   *
+   * `ctx.parallel` is used instead of `ctx.emit`: `emit` maps listeners without
+   * awaiting them, so a listener that returns a rejected promise would surface
+   * as an unhandled rejection, while `parallel` settles every listener and
+   * aggregates their failures.
+   */
   receiveEvent(eventPayload) {
-    this.ctx.logger.info(`interconnect: remote event ${eventPayload.notification.kind} from ${eventPayload.sender}`);
-    this.ctx.emit("interconnect/event", eventPayload.notification, eventPayload.sender);
+    const { notification, sender } = eventPayload;
+    this.ctx.logger.info(`interconnect: remote event ${notification.kind} from ${sender}`);
+    void this.ctx.parallel("interconnect/event", notification, sender).catch((error) => {
+      const reasons = error instanceof AggregateError ? error.errors : [error];
+      const detail = reasons.map((reason) => reason instanceof Error ? reason.message : String(reason)).join("; ");
+      this.ctx.logger.warn(`interconnect: listener for a ${notification.kind} event from ${sender} threw: ${detail}`);
+    });
   }
   /**
    * Summarize the live local sessions so a sender can discover valid targets
@@ -1528,15 +1540,7 @@ var InterconnectService = class extends Service {
       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 ${kind} event from ${sender} threw: ` + (error instanceof Error ? error.message : String(error))
-        );
-      }
+      this.receiveEvent({ sender: this.peerOf.get(socket) ?? "unknown-peer", notification: frame.notification });
       return;
     }
     if (frame.type === "msg-result") {
@@ -1775,7 +1779,7 @@ function apply(ctx) {
   const interconnect = ctx.interconnect;
   ctx.tools.register(defineTool({
     name: "interconnect_send",
-    description: 'Deliver one text message to a live session on another DSH instance (same machine, another machine, or another session). Returns whether the peer instance received it and which instance answered. Only a session with a running agent receives directly; a persisted one can be woken by setting resume, and when delivery fails the result reports the reason (for example "session-not-live") and interconnect_list shows which sessions are live there. The sending instance and session ids are attached automatically, so the receiver can reply with interconnect_reply; do not pass a sender parameter.',
+    description: 'Deliver one text message to a live session on another DSH instance (same machine, another machine, or another session). Returns whether the peer instance received it and which instance answered. Only a live session receives directly; a persisted one can be woken by setting resume, and when delivery fails the result reports the reason (for example "session-not-live") and interconnect_list shows which sessions are live there. The sending instance and session ids are attached automatically, so the receiver can reply with interconnect_reply; do not pass a sender parameter.',
     parameters: {
       instanceId: {
         type: "string",
@@ -1799,7 +1803,7 @@ function apply(ctx) {
       },
       resume: {
         type: "boolean",
-        description: `Wake the target session if it is persisted but has no running agent. Off by default because delivery to a woken session starts a real agent turn \u2014 a billed model call with that session's full toolset \u2014 in a conversation nobody is watching. Prefer interconnect_list and an already-live target; set this only when that specific session must be reached. The receiver may refuse, answering reason "resume-refused".`
+        description: `Wake the target session if it is persisted but not live. Off by default because delivery to a woken session starts a real agent turn \u2014 a billed model call with that session's full toolset \u2014 in a conversation nobody is watching. Prefer interconnect_list and an already-live target; set this only when that specific session must be reached. The receiver may refuse, answering reason "resume-refused".`
       }
     },
     output: {
@@ -1814,7 +1818,7 @@ function apply(ctx) {
         const text = (() => {
           switch (value.reason) {
             case "unreachable":
-              return `not delivered: ${value.instance} did not answer (unreachable or unauthorized)`;
+              return `not delivered: ${value.instance} did not answer (unreachable); retrying may succeed`;
             case "resume-refused":
               return `not delivered: ${value.instance} does not allow waking persisted sessions`;
             case "resume-failed":
@@ -1866,7 +1870,7 @@ function apply(ctx) {
       },
       render: (_args, value) => [{
         type: "text",
-        text: value.reachable ? `reachable: ${value.instance ?? "(unknown instance)"}` : "unreachable or unauthorized"
+        text: value.reachable ? `reachable: ${value.instance ?? "(unknown instance)"}` : "unreachable"
       }]
     },
     async execute(args, exec) {
@@ -1877,7 +1881,7 @@ function apply(ctx) {
   }));
   ctx.tools.register(defineTool({
     name: "interconnect_list",
-    description: "List the live sessions on a peer DSH instance, so a message can be addressed without knowing a session id in advance. Every returned sessionId is a valid interconnect_send target at the time of the call. Only sessions with a running agent appear, and a long listing stops at a size bound, so a live session missing from it may simply not fit; reaching a persisted session requires interconnect_send with resume set.",
+    description: "List the live sessions on a peer DSH instance, so a message can be addressed without knowing a session id in advance. Every returned sessionId is a valid interconnect_send target at the time of the call. Only live sessions appear, and a long listing stops at a size bound, so a live session missing from it may simply not fit; reaching a persisted session requires interconnect_send with resume set.",
     parameters: {
       instanceId: {
         type: "string",
@@ -1907,7 +1911,7 @@ function apply(ctx) {
         }
       },
       render: (_args, value) => {
-        if (!value.reachable) return [{ type: "text", text: "unreachable or unauthorized" }];
+        if (!value.reachable) return [{ type: "text", text: "unreachable" }];
         const sessions = value.sessions ?? [];
         if (sessions.length === 0) {
           return [{ type: "text", text: `no live sessions on ${value.instance ?? "(unknown instance)"}` }];
@@ -1955,7 +1959,7 @@ function apply(ctx) {
       },
       resume: {
         type: "boolean",
-        description: "Wake the target session if it is persisted but has no running agent, as in interconnect_send. Off by default; the receiver may refuse."
+        description: "Wake the target session if it is persisted but not live, as in interconnect_send. Off by default; the receiver may refuse."
       }
     },
     output: {
@@ -1975,7 +1979,7 @@ function apply(ctx) {
             return "not delivered: the recorded sender's session belongs to a subagent and its parent agent owns delivery";
           }
           if (value.reason === "unreachable") {
-            return "not delivered: the recorded sender did not answer (unreachable or unauthorized)";
+            return "not delivered: the recorded sender did not answer (unreachable); retrying may succeed";
           }
           if (value.reason === "resume-refused") {
             return "not delivered: the recorded sender does not allow waking persisted sessions";