wontopos-mcp 1.0.19 → 1.0.20

package/README.md

@@ -224,6 +224,15 @@ advertise different limits.
 
 ## Changelog
 
+- **1.0.20** - a trimmed reply no longer misreports its own size. When a result is
+  larger than the 128KB cap the server cuts the arrays inside it, and the sibling
+  `count` field kept the number from before the cut: a model was handed 100 memories
+  beside `"count": 200` and reasonably read that as JSON truncated mid-structure. The
+  count now says what is actually there. The advice that follows it - "ask for this
+  page again with limit=N" - took N from the longest array anywhere in the reply, so
+  it could name a nested list that had nothing to do with the page; it reads the page's
+  own list now. Underneath, the `wontopos` SDK pin moves to **2.2.38**.
+
 - **1.0.19** - out of beta, and the release that made `recall` keep the other half of
   its promise. It opens by offering "recent turns", and nothing in this server could
   ever write one: turns go through their own API route, every tool here wrote

package/index.mjs

@@ -214,22 +214,33 @@ const RECALL_TURNS = 20;
 
 function droppableLists(root) {
   const out = [];
-  const stack = [["", root]];
+  const stack = [["", root, null]];
   let budget = 20000;
   while (stack.length && budget-- > 0) {
-    const [name, node] = stack.pop();
+    const [name, node, owner] = stack.pop();
     if (Array.isArray(node)) {
-      if (node.length > 1 && node.some((e) => e && typeof e === "object")) out.push([name || "items", node]);
-      for (const v of node) if (v && typeof v === "object") stack.push([name, v]);
+      // `owner` is the object holding this array, so a sibling `count` can be corrected
+      // when the array is cut. Without it the trimmer handed a model 100 memories beside
+      // "count": 200 — and the schemas call that field authoritative, so the model reads
+      // the JSON as truncated mid-structure and either retries or reports the store wrong.
+      if (node.length > 1 && node.some((e) => e && typeof e === "object")) out.push([name || "items", node, owner]);
+      for (const v of node) if (v && typeof v === "object") stack.push([name, v, null]);
       continue;
     }
     for (const [k, v] of Object.entries(node)) {
-      if (v && typeof v === "object") stack.push([Array.isArray(v) ? k : name, v]);
+      if (v && typeof v === "object") stack.push([Array.isArray(v) ? k : name, v, Array.isArray(v) ? node : null]);
     }
   }
   return out;
 }
 
+/** After an array is cut, make its sibling `count` say what is actually there. Only the
+ *  field literally named `count`, and only when it already matched the old length —
+ *  `total_found` and friends mean something else and are left alone. */
+function syncCount(owner, arr, before) {
+  if (owner && typeof owner.count === "number" && owner.count === before) owner.count = arr.length;
+}
+
 function truncationKey(obj) {
   let k = "_truncated";
   while (Object.prototype.hasOwnProperty.call(obj, k)) k = `_${k}`;
@@ -285,12 +296,14 @@ function fitToCap(result) {
       let guard = 64;
       while (byteLen(text) > MAX_RESULT_BYTES && guard-- > 0) {
         let cutAny = false;
-        for (const [name, arr] of lists) {
+        for (const [name, arr, owner] of lists) {
           if (arr.length <= 1) continue;
+          const before = arr.length;
           const keep = Math.max(1, Math.floor(arr.length / 2));
           dropped[name || "items"] = (dropped[name || "items"] ?? 0) + (arr.length - keep);
           if (KEEP_TAIL.has(name)) arr.splice(0, arr.length - keep);
           else arr.length = keep;
+          syncCount(owner, arr, before);
           cutAny = true;
         }
         if (!cutAny) break;
@@ -300,7 +313,11 @@ function fitToCap(result) {
         const paged = ["next_cursor", "next_before", "next_skip_ids"].some(
           (k) => !Array.isArray(clone) && clone[k] != null
         );
-        const kept = lists.reduce((n, [, arr]) => Math.max(n, arr.length), 0);
+        // The page's own list, not the longest array anywhere in the reply: `kept` used
+        // to be a Math.max over every list, so the advice could name the length of a
+        // nested array and send the model back for a page that overflows again.
+        const pageList = lists.find(([name]) => !KEEP_TAIL.has(name) && dropped[name || "items"]);
+        const kept = pageList ? pageList[1].length : 0;
         const note =
           `dropped ${Object.entries(dropped).map(([k, n]) => `${n} ${k}`).join(", ")} to fit the ` +
           (paged

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wontopos-mcp",
-  "version": "1.0.19",
+  "version": "1.0.20",
   "mcpName": "com.wontopos/mcp",
   "description": "Wontopos (WOS) long-term memory as an MCP server — one memory across Claude Code, Claude Desktop, Cursor, ChatGPT, and your own agents.",
   "keywords": [
@@ -34,7 +34,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.30.0",
-    "wontopos": "2.2.37",
+    "wontopos": "2.2.38",
     "zod": "^3.23.0"
   },
   "overrides": {