@anuma/sdk 3.8.4 → 3.8.5

package/dist/expo/index.cjs

@@ -15088,9 +15088,11 @@ function createAutoExtractor(options) {
             }
           }
         );
-        const advancedTo = window2[window2.length - 1].id;
-        stateFor(conversationId).watermark = advancedTo;
-        persistCursor(conversationId, messages, advancedTo, contiguous);
+        if (outcome !== "empty-after-retry") {
+          const advancedTo = window2[window2.length - 1].id;
+          stateFor(conversationId).watermark = advancedTo;
+          persistCursor(conversationId, messages, advancedTo, contiguous);
+        }
         for (let i = 0; i < results.length; i++) {
           if (results[i].action === "suppressed") continue;
           options.onMemoryExtracted?.({

package/dist/expo/index.d.mts

@@ -6232,6 +6232,12 @@ declare class WalletPoller {
  * during a busy window are still examined instead of scrolling out of a last-N
  * window.
  *
+ * The watermark advances only when the extractor genuinely EXAMINED the window.
+ * A pipeline throw and an `empty-after-retry` outcome (the extraction LLM
+ * returned empty/malformed after exhausting its retries) both leave it in place,
+ * so the next turn's window re-covers those messages instead of stranding them.
+ * A quiet turn that legitimately yielded no facts *does* advance it.
+ *
  * Durability: the in-memory watermark alone does NOT survive process death, so
  * a session killed after messages accumulate but before extraction would, on
  * the next launch, fall back to a trailing-window guess and could skip the

package/dist/expo/index.d.ts

@@ -6232,6 +6232,12 @@ declare class WalletPoller {
  * during a busy window are still examined instead of scrolling out of a last-N
  * window.
  *
+ * The watermark advances only when the extractor genuinely EXAMINED the window.
+ * A pipeline throw and an `empty-after-retry` outcome (the extraction LLM
+ * returned empty/malformed after exhausting its retries) both leave it in place,
+ * so the next turn's window re-covers those messages instead of stranding them.
+ * A quiet turn that legitimately yielded no facts *does* advance it.
+ *
  * Durability: the in-memory watermark alone does NOT survive process death, so
  * a session killed after messages accumulate but before extraction would, on
  * the next launch, fall back to a trailing-window guess and could skip the

package/dist/expo/index.mjs

@@ -7240,9 +7240,11 @@ function createAutoExtractor(options) {
             }
           }
         );
-        const advancedTo = window[window.length - 1].id;
-        stateFor(conversationId).watermark = advancedTo;
-        persistCursor(conversationId, messages, advancedTo, contiguous);
+        if (outcome !== "empty-after-retry") {
+          const advancedTo = window[window.length - 1].id;
+          stateFor(conversationId).watermark = advancedTo;
+          persistCursor(conversationId, messages, advancedTo, contiguous);
+        }
         for (let i = 0; i < results.length; i++) {
           if (results[i].action === "suppressed") continue;
           options.onMemoryExtracted?.({

package/dist/react/index.cjs

@@ -16378,9 +16378,11 @@ function createAutoExtractor(options) {
             }
           }
         );
-        const advancedTo = window2[window2.length - 1].id;
-        stateFor(conversationId).watermark = advancedTo;
-        persistCursor(conversationId, messages, advancedTo, contiguous);
+        if (outcome !== "empty-after-retry") {
+          const advancedTo = window2[window2.length - 1].id;
+          stateFor(conversationId).watermark = advancedTo;
+          persistCursor(conversationId, messages, advancedTo, contiguous);
+        }
         for (let i = 0; i < results.length; i++) {
           if (results[i].action === "suppressed") continue;
           options.onMemoryExtracted?.({

package/dist/react/index.d.mts

@@ -7388,6 +7388,12 @@ declare function updateVaultMemoryEmbeddingOp(ctx: VaultMemoryOperationsContext,
  * during a busy window are still examined instead of scrolling out of a last-N
  * window.
  *
+ * The watermark advances only when the extractor genuinely EXAMINED the window.
+ * A pipeline throw and an `empty-after-retry` outcome (the extraction LLM
+ * returned empty/malformed after exhausting its retries) both leave it in place,
+ * so the next turn's window re-covers those messages instead of stranding them.
+ * A quiet turn that legitimately yielded no facts *does* advance it.
+ *
  * Durability: the in-memory watermark alone does NOT survive process death, so
  * a session killed after messages accumulate but before extraction would, on
  * the next launch, fall back to a trailing-window guess and could skip the

package/dist/react/index.d.ts

@@ -7388,6 +7388,12 @@ declare function updateVaultMemoryEmbeddingOp(ctx: VaultMemoryOperationsContext,
  * during a busy window are still examined instead of scrolling out of a last-N
  * window.
  *
+ * The watermark advances only when the extractor genuinely EXAMINED the window.
+ * A pipeline throw and an `empty-after-retry` outcome (the extraction LLM
+ * returned empty/malformed after exhausting its retries) both leave it in place,
+ * so the next turn's window re-covers those messages instead of stranding them.
+ * A quiet turn that legitimately yielded no facts *does* advance it.
+ *
  * Durability: the in-memory watermark alone does NOT survive process death, so
  * a session killed after messages accumulate but before extraction would, on
  * the next launch, fall back to a trailing-window guess and could skip the

package/dist/react/index.mjs

@@ -8053,9 +8053,11 @@ function createAutoExtractor(options) {
             }
           }
         );
-        const advancedTo = window2[window2.length - 1].id;
-        stateFor(conversationId).watermark = advancedTo;
-        persistCursor(conversationId, messages, advancedTo, contiguous);
+        if (outcome !== "empty-after-retry") {
+          const advancedTo = window2[window2.length - 1].id;
+          stateFor(conversationId).watermark = advancedTo;
+          persistCursor(conversationId, messages, advancedTo, contiguous);
+        }
         for (let i = 0; i < results.length; i++) {
           if (results[i].action === "suppressed") continue;
           options.onMemoryExtracted?.({

package/dist/server/index.cjs

@@ -28244,9 +28244,11 @@ function createAutoExtractor(options) {
             }
           }
         );
-        const advancedTo = window2[window2.length - 1].id;
-        stateFor(conversationId).watermark = advancedTo;
-        persistCursor(conversationId, messages, advancedTo, contiguous);
+        if (outcome !== "empty-after-retry") {
+          const advancedTo = window2[window2.length - 1].id;
+          stateFor(conversationId).watermark = advancedTo;
+          persistCursor(conversationId, messages, advancedTo, contiguous);
+        }
         for (let i = 0; i < results.length; i++) {
           if (results[i].action === "suppressed") continue;
           options.onMemoryExtracted?.({

package/dist/server/index.d.mts

@@ -6943,6 +6943,12 @@ declare function createMemoryVaultTool(vaultCtx: VaultMemoryOperationsContext, o
  * during a busy window are still examined instead of scrolling out of a last-N
  * window.
  *
+ * The watermark advances only when the extractor genuinely EXAMINED the window.
+ * A pipeline throw and an `empty-after-retry` outcome (the extraction LLM
+ * returned empty/malformed after exhausting its retries) both leave it in place,
+ * so the next turn's window re-covers those messages instead of stranding them.
+ * A quiet turn that legitimately yielded no facts *does* advance it.
+ *
  * Durability: the in-memory watermark alone does NOT survive process death, so
  * a session killed after messages accumulate but before extraction would, on
  * the next launch, fall back to a trailing-window guess and could skip the

package/dist/server/index.d.ts

@@ -6943,6 +6943,12 @@ declare function createMemoryVaultTool(vaultCtx: VaultMemoryOperationsContext, o
  * during a busy window are still examined instead of scrolling out of a last-N
  * window.
  *
+ * The watermark advances only when the extractor genuinely EXAMINED the window.
+ * A pipeline throw and an `empty-after-retry` outcome (the extraction LLM
+ * returned empty/malformed after exhausting its retries) both leave it in place,
+ * so the next turn's window re-covers those messages instead of stranding them.
+ * A quiet turn that legitimately yielded no facts *does* advance it.
+ *
  * Durability: the in-memory watermark alone does NOT survive process death, so
  * a session killed after messages accumulate but before extraction would, on
  * the next launch, fall back to a trailing-window guess and could skip the

package/dist/server/index.mjs

@@ -6141,9 +6141,11 @@ function createAutoExtractor(options) {
             }
           }
         );
-        const advancedTo = window2[window2.length - 1].id;
-        stateFor(conversationId).watermark = advancedTo;
-        persistCursor(conversationId, messages, advancedTo, contiguous);
+        if (outcome !== "empty-after-retry") {
+          const advancedTo = window2[window2.length - 1].id;
+          stateFor(conversationId).watermark = advancedTo;
+          persistCursor(conversationId, messages, advancedTo, contiguous);
+        }
         for (let i = 0; i < results.length; i++) {
           if (results[i].action === "suppressed") continue;
           options.onMemoryExtracted?.({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anuma/sdk",
-  "version": "3.8.4",
+  "version": "3.8.5",
   "description": "",
   "main": "./dist/index.cjs",
   "module": "./dist/index.mjs",