@kybernesis/dispatch 0.3.0 → 0.3.2

package/dist/governed-peers.d.ts

@@ -35,5 +35,20 @@ export interface GovernedPeersOptions {
     cacheMs?: number;
     /** How long to wait for a peer's answer before giving up. */
     timeoutMs?: number;
+    /**
+     * Peers that already have a declared `remotePeer()` file, so they are not
+     * offered twice.
+     *
+     * Some peers earn their file: `remotePeer` forwards the human's principal,
+     * which is the only correct way to reach an agent holding personal data.
+     * Discovery would list those peers too, and an agent shown two routes to the
+     * same colleague will sometimes pick the one that answers as itself — the
+     * quieter of the two failures, because it succeeds and returns less.
+     *
+     * Naming a peer here is not the thing this module exists to remove. It does
+     * not make the peer reachable; the file already did that. It says "handled
+     * elsewhere", and removing the line costs a duplicate, not a capability.
+     */
+    declared?: string[];
 }
 export declare function governedPeers(options?: GovernedPeersOptions): import("eve").DynamicSentinel<Record<string, unknown> | null>;

package/dist/governed-peers.js

@@ -70,44 +70,83 @@ async function ask(options, peer, message) {
     const { sessionId } = (await started.json());
     if (!sessionId)
         throw new Error(`${peer.name} did not open a session.`);
-    // Read its stream to the end of the turn. The peer may think for a while, so
-    // this waits on CONTENT rather than on a fixed deadline per poll.
-    const began = Date.now();
-    let index = 0;
+    /**
+     * Read the turn off the peer's NDJSON stream, incrementally.
+     *
+     * The stream FOLLOWS the live session: it stays open after the turn so the
+     * next one arrives on the same connection. Buffering it whole — `await
+     * res.text()` — therefore waits for a connection that never closes, and the
+     * call dies on its own timeout having already received the answer.
+     *
+     * That failure is host-shaped, which is what made it confusing: a callee on
+     * serverless ends its response when the function returns, so a buffered read
+     * resolves and everything looks correct. Against a callee on a long-lived
+     * host, the identical code hangs every time.
+     *
+     * So: parse line by line as bytes arrive, and stop at the turn boundary.
+     */
+    const controller = new AbortController();
+    const deadline = setTimeout(() => controller.abort(), timeout);
     let reply = "";
-    while (Date.now() - began < timeout) {
-        const res = await fetch(`${base}/eve/v1/session/${encodeURIComponent(sessionId)}/stream?startIndex=${index}`, { headers: { authorization: `Bearer ${token}` }, signal: AbortSignal.timeout(60_000) });
-        if (!res.ok)
-            break;
-        const text = await res.text();
-        for (const line of text.split("\n")) {
-            if (!line.trim())
-                continue;
-            index += 1;
-            try {
-                const event = JSON.parse(line);
+    try {
+        const res = await fetch(`${base}/eve/v1/session/${encodeURIComponent(sessionId)}/stream?startIndex=0`, { headers: { authorization: `Bearer ${token}` }, signal: controller.signal });
+        if (!res.ok || !res.body)
+            throw new Error(`${peer.name} would not stream its answer (HTTP ${res.status}).`);
+        const reader = res.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            // Keep the trailing fragment: a chunk boundary lands mid-line often
+            // enough that dropping it loses whole events under load.
+            const lines = buffer.split("\n");
+            buffer = lines.pop() ?? "";
+            for (const line of lines) {
+                if (!line.trim())
+                    continue;
+                let event;
+                try {
+                    event = JSON.parse(line);
+                }
+                catch {
+                    continue;
+                }
                 // Only a terminal message is the answer: eve emits narration as its own
                 // completed message with finishReason "tool-calls", and treating those
                 // as the reply returns the peer's intentions instead of its answer.
                 if (event.type === "message.completed" && event.data?.finishReason === "stop") {
                     reply = String(event.data.message ?? "");
                 }
+                if (event.type === "turn.failed" || event.type === "session.failed") {
+                    const detail = event.data?.message;
+                    throw new Error(`${peer.name} failed to answer${detail ? `: ${detail}` : "."}`);
+                }
                 if (event.type === "session.waiting" || event.type === "turn.completed") {
+                    await reader.cancel().catch(() => { });
                     if (reply)
                         return reply;
+                    throw new Error(`${peer.name} finished its turn without a reply.`);
                 }
             }
-            catch {
-                /* a partial line; the next poll re-reads from this index */
-            }
         }
         if (reply)
             return reply;
-        await new Promise((r) => setTimeout(r, 1_500));
+        throw new Error(`${peer.name} closed the stream without answering.`);
+    }
+    catch (error) {
+        if (reply)
+            return reply;
+        if (error?.name === "AbortError") {
+            throw new Error(`${peer.name} did not answer within ${Math.round(timeout / 1000)}s.`);
+        }
+        throw error;
+    }
+    finally {
+        clearTimeout(deadline);
     }
-    if (reply)
-        return reply;
-    throw new Error(`${peer.name} did not answer within ${Math.round(timeout / 1000)}s.`);
 }
 /** A tool name an agent can actually call: letters, digits, underscore. */
 function toolName(peer) {
@@ -117,7 +156,9 @@ export function governedPeers(options = {}) {
     return defineDynamic({
         events: {
             "turn.started": async () => {
-                const peers = await discover(options);
+                const all = await discover(options);
+                const skip = new Set((options.declared ?? []).map((n) => n.toLowerCase()));
+                const peers = all.filter((p) => !skip.has(p.name.toLowerCase()));
                 if (peers.length === 0)
                     return null;
                 const tools = {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kybernesis/dispatch",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "Agent-to-agent dispatch for eve agents: declared remote-peer edges with principal forwarding on by default, and a receiver channel that makes trusting the wrong caller hard to express.",
   "license": "Apache-2.0",
   "type": "module",
@@ -27,7 +27,8 @@
   "scripts": {
     "build": "tsc -p tsconfig.build.json",
     "prepare": "tsc -p tsconfig.build.json",
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "node ../../scripts/prepublish.mjs"
   },
   "devDependencies": {
     "@types/node": "24.x",