@voidly/agent-sdk 3.3.0 → 3.3.2

package/dist/index.d.ts

@@ -364,7 +364,11 @@ declare class VoidlyAgent {
         messageType?: string;
         unreadOnly?: boolean;
     }): Promise<DecryptedMessage[]>;
-    /** Decrypt raw message objects (shared by receive(), SSE, WebSocket transports) */
+    /** Decrypt raw message objects (shared by receive(), SSE, WebSocket transports)
+     * Returns decrypted messages AND IDs of messages that failed to decrypt.
+     * Failed messages should be marked as read on the relay — they are permanently
+     * undecryptable and will poison the queue if left unread (Signal-style handling).
+     */
     private _decryptMessages;
     /**
      * Delete a message by ID (must be sender or recipient).

package/dist/index.js

@@ -4220,6 +4220,7 @@ var VoidlyAgent = class _VoidlyAgent {
       } catch {
       }
     }
+    const effectiveConfig = !mlkemSk && config?.postQuantum !== false ? { ...config, postQuantum: false } : config;
     const agent = new _VoidlyAgent({
       did: creds.did,
       apiKey: creds.apiKey,
@@ -4230,7 +4231,7 @@ var VoidlyAgent = class _VoidlyAgent {
       },
       mlkemPublicKey: mlkemPk,
       mlkemSecretKey: mlkemSk
-    }, config);
+    }, effectiveConfig);
     if (creds.ratchetStates) {
       for (const [pairId, rs] of Object.entries(creds.ratchetStates)) {
         try {
@@ -4784,16 +4785,37 @@ var VoidlyAgent = class _VoidlyAgent {
       throw new Error(`Receive failed: ${err.error?.message || err.error || res.statusText}`);
     }
     const data = await res.json();
-    return this._decryptMessages(data.messages);
+    const { decrypted, failedIds } = await this._decryptMessages(data.messages);
+    if (failedIds.length > 0) {
+      try {
+        await this.markReadBatch(failedIds);
+      } catch {
+        for (const id of failedIds) {
+          try {
+            await this.markRead(id);
+          } catch {
+          }
+        }
+      }
+    }
+    return decrypted;
   }
-  /** Decrypt raw message objects (shared by receive(), SSE, WebSocket transports) */
+  /** Decrypt raw message objects (shared by receive(), SSE, WebSocket transports)
+   * Returns decrypted messages AND IDs of messages that failed to decrypt.
+   * Failed messages should be marked as read on the relay — they are permanently
+   * undecryptable and will poison the queue if left unread (Signal-style handling).
+   */
   async _decryptMessages(rawMessages) {
     const decrypted = [];
+    const failedIds = [];
     const resetPeers = /* @__PURE__ */ new Set();
     for (const msg of rawMessages) {
       try {
         if (this._seenMessageIds.has(msg.id)) continue;
-        if (resetPeers.has(msg.from)) continue;
+        if (resetPeers.has(msg.from)) {
+          failedIds.push(msg.id);
+          continue;
+        }
         let senderEncPub;
         let senderSignPubBytes = null;
         if (msg.sender_encryption_key) {
@@ -4929,6 +4951,7 @@ var VoidlyAgent = class _VoidlyAgent {
             const skip = targetStep - state.recvStep;
             if (skip > MAX_SKIP) {
               this._decryptFailCount++;
+              failedIds.push(msg.id);
               const peerForSkip = msg.from || "unknown";
               const prevSkipFails = this._peerDecryptFails.get(peerForSkip) || 0;
               this._peerDecryptFails.set(peerForSkip, prevSkipFails + 1);
@@ -4956,6 +4979,55 @@ var VoidlyAgent = class _VoidlyAgent {
               rawPlaintext = import_tweetnacl.default.secretbox.open(ciphertext, nonce, messageKey);
             }
           }
+          if (!rawPlaintext && envelopeDhRatchetKey && this.doubleRatchet && state) {
+            try {
+              const x25519Shared2 = import_tweetnacl.default.box.before(senderEncPub, this.encryptionKeyPair.secretKey);
+              let initialKey2;
+              if (envelopePqCiphertext && this.mlkemSecretKey) {
+                try {
+                  const pqCt2 = (0, import_tweetnacl_util.decodeBase64)(envelopePqCiphertext);
+                  const kem2 = new MlKem768();
+                  const pqShared2 = await kem2.decap(pqCt2, this.mlkemSecretKey);
+                  const combined2 = new Uint8Array(x25519Shared2.length + pqShared2.length);
+                  combined2.set(x25519Shared2, 0);
+                  combined2.set(pqShared2, x25519Shared2.length);
+                  initialKey2 = new Uint8Array(await globalThis.crypto.subtle.digest("SHA-256", combined2));
+                } catch {
+                  initialKey2 = x25519Shared2;
+                }
+              } else {
+                initialKey2 = x25519Shared2;
+              }
+              const senderDhPub2 = (0, import_tweetnacl_util.decodeBase64)(envelopeDhRatchetKey);
+              const dhOutput2 = import_tweetnacl.default.box.before(senderDhPub2, this.encryptionKeyPair.secretKey);
+              const { newRootKey: rk2, newChainKey: ck2 } = await kdfRK(initialKey2, dhOutput2);
+              let freshCk = ck2;
+              for (let fi = 1; fi < envelopeRatchetStep; fi++) {
+                const { nextChainKey: nck } = await ratchetStep(freshCk);
+                freshCk = nck;
+              }
+              const { nextChainKey: finalCk, messageKey: freshMk } = await ratchetStep(freshCk);
+              const freshPlain = import_tweetnacl.default.secretbox.open(ciphertext, nonce, freshMk);
+              if (freshPlain) {
+                rawPlaintext = freshPlain;
+                state.recvChainKey = finalCk;
+                state.recvStep = envelopeRatchetStep;
+                state.rootKey = rk2;
+                state.dhRecvPubKey = senderDhPub2;
+                state.prevSendStep = state.sendStep;
+                state.dhSendKeyPair = import_tweetnacl.default.box.keyPair();
+                state.sendStep = 0;
+                state.sendChainKey = initialKey2;
+                const dhOut3 = import_tweetnacl.default.box.before(senderDhPub2, state.dhSendKeyPair.secretKey);
+                const kdf3 = await kdfRK(state.rootKey, dhOut3);
+                state.rootKey = kdf3.newRootKey;
+                state.sendChainKey = kdf3.newChainKey;
+                if (state.dhSkippedKeys) state.dhSkippedKeys.clear();
+                if (state.skippedKeys) state.skippedKeys.clear();
+              }
+            } catch {
+            }
+          }
           if (!rawPlaintext) {
             rawPlaintext = import_tweetnacl.default.box.open(ciphertext, nonce, senderEncPub, this.encryptionKeyPair.secretKey);
           }
@@ -4964,6 +5036,7 @@ var VoidlyAgent = class _VoidlyAgent {
         }
         if (!rawPlaintext) {
           this._decryptFailCount++;
+          failedIds.push(msg.id);
           const senderForFail = msg.from || "unknown";
           const prevFails = this._peerDecryptFails.get(senderForFail) || 0;
           this._peerDecryptFails.set(senderForFail, prevFails + 1);
@@ -5044,6 +5117,7 @@ var VoidlyAgent = class _VoidlyAgent {
         }
         if (this.requireSignatures && !signatureValid) {
           this._decryptFailCount++;
+          failedIds.push(msg.id);
           const peerForSig = msg.from || "unknown";
           const prevSigFails = this._peerDecryptFails.get(peerForSig) || 0;
           this._peerDecryptFails.set(peerForSig, prevSigFails + 1);
@@ -5073,6 +5147,7 @@ var VoidlyAgent = class _VoidlyAgent {
         });
       } catch {
         this._decryptFailCount++;
+        failedIds.push(msg.id);
         const peerForCatch = msg.from || "unknown";
         const prevCatchFails = this._peerDecryptFails.get(peerForCatch) || 0;
         this._peerDecryptFails.set(peerForCatch, prevCatchFails + 1);
@@ -5087,7 +5162,7 @@ var VoidlyAgent = class _VoidlyAgent {
       this._persistRatchetState().catch(() => {
       });
     }
-    return decrypted;
+    return { decrypted, failedIds };
   }
   // ─── Message Management ─────────────────────────────────────────────────────
   /**
@@ -6443,7 +6518,13 @@ var VoidlyAgent = class _VoidlyAgent {
                 if (eventType === "message" && dataStr) {
                   try {
                     const rawMsg = JSON.parse(dataStr);
-                    const decrypted = await this._decryptMessages([rawMsg]);
+                    const { decrypted, failedIds } = await this._decryptMessages([rawMsg]);
+                    for (const id of failedIds) {
+                      try {
+                        await this.markRead(id);
+                      } catch {
+                      }
+                    }
                     if (decrypted.length > 0) {
                       consecutiveEmpty = 0;
                       sseFailures = 0;

package/dist/index.mjs

@@ -4210,6 +4210,7 @@ var VoidlyAgent = class _VoidlyAgent {
       } catch {
       }
     }
+    const effectiveConfig = !mlkemSk && config?.postQuantum !== false ? { ...config, postQuantum: false } : config;
     const agent = new _VoidlyAgent({
       did: creds.did,
       apiKey: creds.apiKey,
@@ -4220,7 +4221,7 @@ var VoidlyAgent = class _VoidlyAgent {
       },
       mlkemPublicKey: mlkemPk,
       mlkemSecretKey: mlkemSk
-    }, config);
+    }, effectiveConfig);
     if (creds.ratchetStates) {
       for (const [pairId, rs] of Object.entries(creds.ratchetStates)) {
         try {
@@ -4774,16 +4775,37 @@ var VoidlyAgent = class _VoidlyAgent {
       throw new Error(`Receive failed: ${err.error?.message || err.error || res.statusText}`);
     }
     const data = await res.json();
-    return this._decryptMessages(data.messages);
+    const { decrypted, failedIds } = await this._decryptMessages(data.messages);
+    if (failedIds.length > 0) {
+      try {
+        await this.markReadBatch(failedIds);
+      } catch {
+        for (const id of failedIds) {
+          try {
+            await this.markRead(id);
+          } catch {
+          }
+        }
+      }
+    }
+    return decrypted;
   }
-  /** Decrypt raw message objects (shared by receive(), SSE, WebSocket transports) */
+  /** Decrypt raw message objects (shared by receive(), SSE, WebSocket transports)
+   * Returns decrypted messages AND IDs of messages that failed to decrypt.
+   * Failed messages should be marked as read on the relay — they are permanently
+   * undecryptable and will poison the queue if left unread (Signal-style handling).
+   */
   async _decryptMessages(rawMessages) {
     const decrypted = [];
+    const failedIds = [];
     const resetPeers = /* @__PURE__ */ new Set();
     for (const msg of rawMessages) {
       try {
         if (this._seenMessageIds.has(msg.id)) continue;
-        if (resetPeers.has(msg.from)) continue;
+        if (resetPeers.has(msg.from)) {
+          failedIds.push(msg.id);
+          continue;
+        }
         let senderEncPub;
         let senderSignPubBytes = null;
         if (msg.sender_encryption_key) {
@@ -4919,6 +4941,7 @@ var VoidlyAgent = class _VoidlyAgent {
             const skip = targetStep - state.recvStep;
             if (skip > MAX_SKIP) {
               this._decryptFailCount++;
+              failedIds.push(msg.id);
               const peerForSkip = msg.from || "unknown";
               const prevSkipFails = this._peerDecryptFails.get(peerForSkip) || 0;
               this._peerDecryptFails.set(peerForSkip, prevSkipFails + 1);
@@ -4946,6 +4969,55 @@ var VoidlyAgent = class _VoidlyAgent {
               rawPlaintext = import_tweetnacl.default.secretbox.open(ciphertext, nonce, messageKey);
             }
           }
+          if (!rawPlaintext && envelopeDhRatchetKey && this.doubleRatchet && state) {
+            try {
+              const x25519Shared2 = import_tweetnacl.default.box.before(senderEncPub, this.encryptionKeyPair.secretKey);
+              let initialKey2;
+              if (envelopePqCiphertext && this.mlkemSecretKey) {
+                try {
+                  const pqCt2 = (0, import_tweetnacl_util.decodeBase64)(envelopePqCiphertext);
+                  const kem2 = new MlKem768();
+                  const pqShared2 = await kem2.decap(pqCt2, this.mlkemSecretKey);
+                  const combined2 = new Uint8Array(x25519Shared2.length + pqShared2.length);
+                  combined2.set(x25519Shared2, 0);
+                  combined2.set(pqShared2, x25519Shared2.length);
+                  initialKey2 = new Uint8Array(await globalThis.crypto.subtle.digest("SHA-256", combined2));
+                } catch {
+                  initialKey2 = x25519Shared2;
+                }
+              } else {
+                initialKey2 = x25519Shared2;
+              }
+              const senderDhPub2 = (0, import_tweetnacl_util.decodeBase64)(envelopeDhRatchetKey);
+              const dhOutput2 = import_tweetnacl.default.box.before(senderDhPub2, this.encryptionKeyPair.secretKey);
+              const { newRootKey: rk2, newChainKey: ck2 } = await kdfRK(initialKey2, dhOutput2);
+              let freshCk = ck2;
+              for (let fi = 1; fi < envelopeRatchetStep; fi++) {
+                const { nextChainKey: nck } = await ratchetStep(freshCk);
+                freshCk = nck;
+              }
+              const { nextChainKey: finalCk, messageKey: freshMk } = await ratchetStep(freshCk);
+              const freshPlain = import_tweetnacl.default.secretbox.open(ciphertext, nonce, freshMk);
+              if (freshPlain) {
+                rawPlaintext = freshPlain;
+                state.recvChainKey = finalCk;
+                state.recvStep = envelopeRatchetStep;
+                state.rootKey = rk2;
+                state.dhRecvPubKey = senderDhPub2;
+                state.prevSendStep = state.sendStep;
+                state.dhSendKeyPair = import_tweetnacl.default.box.keyPair();
+                state.sendStep = 0;
+                state.sendChainKey = initialKey2;
+                const dhOut3 = import_tweetnacl.default.box.before(senderDhPub2, state.dhSendKeyPair.secretKey);
+                const kdf3 = await kdfRK(state.rootKey, dhOut3);
+                state.rootKey = kdf3.newRootKey;
+                state.sendChainKey = kdf3.newChainKey;
+                if (state.dhSkippedKeys) state.dhSkippedKeys.clear();
+                if (state.skippedKeys) state.skippedKeys.clear();
+              }
+            } catch {
+            }
+          }
           if (!rawPlaintext) {
             rawPlaintext = import_tweetnacl.default.box.open(ciphertext, nonce, senderEncPub, this.encryptionKeyPair.secretKey);
           }
@@ -4954,6 +5026,7 @@ var VoidlyAgent = class _VoidlyAgent {
         }
         if (!rawPlaintext) {
           this._decryptFailCount++;
+          failedIds.push(msg.id);
           const senderForFail = msg.from || "unknown";
           const prevFails = this._peerDecryptFails.get(senderForFail) || 0;
           this._peerDecryptFails.set(senderForFail, prevFails + 1);
@@ -5034,6 +5107,7 @@ var VoidlyAgent = class _VoidlyAgent {
         }
         if (this.requireSignatures && !signatureValid) {
           this._decryptFailCount++;
+          failedIds.push(msg.id);
           const peerForSig = msg.from || "unknown";
           const prevSigFails = this._peerDecryptFails.get(peerForSig) || 0;
           this._peerDecryptFails.set(peerForSig, prevSigFails + 1);
@@ -5063,6 +5137,7 @@ var VoidlyAgent = class _VoidlyAgent {
         });
       } catch {
         this._decryptFailCount++;
+        failedIds.push(msg.id);
         const peerForCatch = msg.from || "unknown";
         const prevCatchFails = this._peerDecryptFails.get(peerForCatch) || 0;
         this._peerDecryptFails.set(peerForCatch, prevCatchFails + 1);
@@ -5077,7 +5152,7 @@ var VoidlyAgent = class _VoidlyAgent {
       this._persistRatchetState().catch(() => {
       });
     }
-    return decrypted;
+    return { decrypted, failedIds };
   }
   // ─── Message Management ─────────────────────────────────────────────────────
   /**
@@ -6433,7 +6508,13 @@ var VoidlyAgent = class _VoidlyAgent {
                 if (eventType === "message" && dataStr) {
                   try {
                     const rawMsg = JSON.parse(dataStr);
-                    const decrypted = await this._decryptMessages([rawMsg]);
+                    const { decrypted, failedIds } = await this._decryptMessages([rawMsg]);
+                    for (const id of failedIds) {
+                      try {
+                        await this.markRead(id);
+                      } catch {
+                      }
+                    }
                     if (decrypted.length > 0) {
                       consecutiveEmpty = 0;
                       sseFailures = 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voidly/agent-sdk",
-  "version": "3.3.0",
+  "version": "3.3.2",
   "description": "E2E encrypted agent-to-agent communication SDK — Double Ratchet, X3DH, deniable auth, ML-KEM-768 post-quantum, SSE streaming, ratchet persistence, multi-relay federation",
   "main": "dist/index.js",
   "module": "dist/index.mjs",