@highway1/core 0.1.43 → 0.1.45

package/dist/index.js

@@ -257,8 +257,8 @@ async function createNode(config) {
         // Optimize for small networks: reduce replication factor and query timeout
         kBucketSize: 20,
         // Default K=20, keep for compatibility
-        querySelfInterval: 3e5,
-        // Self-query every 5 min (default 30s)
+        querySelfInterval: 3e4,
+        // Self-query every 30 seconds (libp2p default)
         // Allow queries to complete faster in small networks
         allowQueryWithZeroPeers: true
       });
@@ -1032,6 +1032,8 @@ function createSemanticSearch(dht) {
 
 // src/discovery/dht.ts
 var logger4 = createLogger("dht");
+var peerCache = /* @__PURE__ */ new Map();
+var CACHE_TTL = 5 * 60 * 1e3;
 function extractValue(event) {
   if (event.name === "VALUE" && event.value) return event.value;
   if (event.name === "PEER_RESPONSE" && event.value) return event.value;
@@ -1094,7 +1096,7 @@ function createDHTOperations(libp2p) {
         }
         const caps = (card.capabilities ?? []).flatMap((c) => {
           if (typeof c === "string") return [c];
-          return [c.name, c.id].filter(Boolean);
+          return [c.name, c.id].filter((v) => typeof v === "string" && v.length > 0);
         });
         caps.push("__all__");
         const importantCaps = ["__all__"];
@@ -1222,6 +1224,11 @@ function createDHTOperations(libp2p) {
     },
     resolveDID: async (did) => {
       try {
+        const cached = peerCache.get(did);
+        if (cached && Date.now() - cached.timestamp < CACHE_TTL) {
+          logger4.debug("Using cached peer info", { did });
+          return { peerId: cached.peerId, multiaddrs: cached.multiaddrs };
+        }
         const dht = libp2p.services?.dht;
         if (!dht) throw new DiscoveryError("DHT service not available");
         const key = fromString(`/clawiverse/agent/${did}`);
@@ -1231,7 +1238,13 @@ function createDHTOperations(libp2p) {
             const card = decodeFromCBOR(raw);
             if (card.peerId) {
               logger4.debug("Resolved DID to peer", { did, peerId: card.peerId });
-              return { peerId: card.peerId, multiaddrs: card.endpoints || [] };
+              const result = { peerId: card.peerId, multiaddrs: card.endpoints || [] };
+              peerCache.set(did, {
+                peerId: result.peerId,
+                multiaddrs: result.multiaddrs,
+                timestamp: Date.now()
+              });
+              return result;
             }
             logger4.warn("Agent Card found but has no peerId", { did });
             return null;
@@ -1323,6 +1336,18 @@ function decodeMessageJSON(json) {
   }
 }
 var logger5 = createLogger("router");
+function concatUint8Arrays(arrays) {
+  if (arrays.length === 0) return new Uint8Array(0);
+  if (arrays.length === 1) return arrays[0];
+  const totalLength = arrays.reduce((acc, arr) => acc + arr.length, 0);
+  const result = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const arr of arrays) {
+    result.set(arr, offset);
+    offset += arr.length;
+  }
+  return result;
+}
 function createMessageRouter(libp2p, verifyFn, dht, relayPeers) {
   const handlers = /* @__PURE__ */ new Map();
   let catchAllHandler;
@@ -1373,16 +1398,25 @@ function createMessageRouter(libp2p, verifyFn, dht, relayPeers) {
           multiaddrs: targetMultiaddrs
         });
         let stream;
+        const DIAL_TIMEOUT = 3e3;
         const relayMultiaddrs = targetMultiaddrs.filter((a) => a.includes("/p2p-circuit/"));
         const directMultiaddrs = targetMultiaddrs.filter((a) => !a.includes("/p2p-circuit/"));
-        for (const addr of directMultiaddrs) {
-          try {
-            const conn = await libp2p.dial(multiaddr(addr));
-            stream = await conn.newStream(PROTOCOL_PREFIX, { runOnLimitedConnection: true });
-            logger5.info("Direct dial succeeded", { addr });
-            break;
-          } catch {
-          }
+        if (directMultiaddrs.length > 0) {
+          const directDialPromises = directMultiaddrs.map(async (addr) => {
+            try {
+              const conn = await libp2p.dial(multiaddr(addr), {
+                signal: AbortSignal.timeout(DIAL_TIMEOUT)
+              });
+              const s = await conn.newStream(PROTOCOL_PREFIX, { runOnLimitedConnection: true });
+              logger5.info("Direct dial succeeded", { addr });
+              return s;
+            } catch {
+              return null;
+            }
+          });
+          stream = await Promise.race(
+            directDialPromises.map((p) => p.then((s) => s || Promise.reject()))
+          ).catch(() => void 0);
         }
         let lastError;
         if (!stream) {
@@ -1391,17 +1425,25 @@ function createMessageRouter(libp2p, verifyFn, dht, relayPeers) {
             ...(relayPeers ?? []).map((r) => buildCircuitRelayAddr(r, targetPeerIdStr))
           ];
           const uniqueRelayAddrs = [...new Set(allRelayAddrs)];
-          for (const addr of uniqueRelayAddrs) {
-            try {
-              const conn = await libp2p.dial(multiaddr(addr));
-              logger5.info("Relay connection established", { addr });
-              stream = await conn.newStream(PROTOCOL_PREFIX, { runOnLimitedConnection: true });
-              logger5.info("Relay stream opened", { addr });
-              break;
-            } catch (relayErr) {
-              logger5.warn("Relay dial failed", { addr, error: relayErr.message });
-              lastError = relayErr;
-            }
+          if (uniqueRelayAddrs.length > 0) {
+            const relayDialPromises = uniqueRelayAddrs.map(async (addr) => {
+              try {
+                const conn = await libp2p.dial(multiaddr(addr), {
+                  signal: AbortSignal.timeout(DIAL_TIMEOUT)
+                });
+                logger5.info("Relay connection established", { addr });
+                const s = await conn.newStream(PROTOCOL_PREFIX, { runOnLimitedConnection: true });
+                logger5.info("Relay stream opened", { addr });
+                return s;
+              } catch (relayErr) {
+                logger5.warn("Relay dial failed", { addr, error: relayErr.message });
+                lastError = relayErr;
+                return null;
+              }
+            });
+            stream = await Promise.race(
+              relayDialPromises.map((p) => p.then((s) => s || Promise.reject()))
+            ).catch(() => void 0);
           }
         }
         if (!stream && dht && "queryRelayPeers" in dht) {
@@ -1437,21 +1479,14 @@ function createMessageRouter(libp2p, verifyFn, dht, relayPeers) {
         if (envelope.type === "request") {
           logger5.debug("Waiting for response to request", { id: envelope.id });
           try {
-            const RESPONSE_TIMEOUT = 3e4;
+            const RESPONSE_TIMEOUT = 5e3;
             const responsePromise = (async () => {
               const responseChunks = [];
               for await (const chunk of stream.source) {
                 responseChunks.push(chunk.subarray());
               }
               if (responseChunks.length > 0) {
-                const responseData = new Uint8Array(
-                  responseChunks.reduce((acc, chunk) => acc + chunk.length, 0)
-                );
-                let offset = 0;
-                for (const chunk of responseChunks) {
-                  responseData.set(chunk, offset);
-                  offset += chunk.length;
-                }
+                const responseData = concatUint8Arrays(responseChunks);
                 const responseEnvelope = decodeMessage(responseData);
                 logger5.info("Received response", {
                   id: responseEnvelope.id,
@@ -1509,14 +1544,7 @@ async function handleIncomingStream(stream, handlers, catchAllHandler, verifyFn)
     for await (const chunk of stream.source) {
       chunks.push(chunk.subarray());
     }
-    const data = new Uint8Array(
-      chunks.reduce((acc, chunk) => acc + chunk.length, 0)
-    );
-    let offset = 0;
-    for (const chunk of chunks) {
-      data.set(chunk, offset);
-      offset += chunk.length;
-    }
+    const data = concatUint8Arrays(chunks);
     const envelope = decodeMessage(data);
     if (!validateEnvelope(envelope)) {
       logger5.warn("Received invalid message envelope");