wontopos-mcp 1.0.4 → 1.0.6

package/README.md

@@ -52,8 +52,9 @@ Create a key in the [console](https://wontopos.com). Optional env:
   argument unless you opt in with `WONTOPOS_ALLOW_STORE_OVERRIDE=1` - a confused
   or prompt-injected model cannot read or write a sibling store. Want several
   stores? Register the server once per store (each entry stays pinned).
-- **Bounded results.** A tool result is capped at 128 KB before it reaches the
-  model, so an oversized memory cannot blow up the conversation context.
+- **Bounded results.** A tool result is capped at 128 KB (measured in UTF-8
+  bytes, so the bound holds for Korean/CJK too) before it reaches the model, so
+  an oversized memory cannot blow up the conversation context.
 - **Use a dedicated key.** Keys carry their workspace, so a key made just for
   MCP scopes what connected tools can ever touch. Rotate it in the console
   anytime without touching your app's keys.
@@ -106,11 +107,15 @@ automatic retries, redirect refusal, response caps, and key hygiene apply as-is.
 
 ## Changelog
 
-- **1.0.4** (unreleased) - the judgment + security release. Store pinning by
+- **1.0.5** - correctness on the caps: they are now measured in UTF-8 **bytes**,
+  not JS chars, so "128 KB" holds for Korean/CJK (a char cap let ~384 KB of
+  Korean through). Result 128 KB, error 2 KB, content 8 KB, query 8 KB — all
+  byte-bounded, and truncation never splits a multi-byte character.
+- **1.0.4** - the judgment + security release. Store pinning by
   default (`user_id` arguments only exist with `WONTOPOS_ALLOW_STORE_OVERRIDE=1`);
-  tool results capped at 128 KB with paging guidance and error messages capped
+  tool results capped with paging guidance and error messages capped
   too; blank / oversized / mis-shaped inputs refused before any request (empty
-  queries and memories, >8 KB content, >4 KB queries, non-uuid memory ids,
+  queries and memories, oversized content, non-uuid memory ids,
   unparseable event_date, speakers other than 'me'); stringified numbers coerced;
   a bounded request timeout (20s, `WONTOPOS_TIMEOUT_MS`) so a stalled API fails
   in-band instead of hanging the host. Tool descriptions now carry the

package/index.mjs

@@ -28,19 +28,38 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { z } from "zod";
 import { Client, WosError } from "wontopos";
 
-const VERSION = "1.0.4";
+const VERSION = "1.0.5";
 const flag = (v) => ["1", "true", "yes"].includes((v ?? "").trim().toLowerCase());
 const READ_ONLY = flag(process.env.WONTOPOS_READ_ONLY);
 // Store pinning (default ON): every call goes to WONTOPOS_USER_ID and the tools
 // do not even expose a user_id argument — a prompt-injected or confused model
 // cannot reach a sibling store. Opt out per install with ALLOW_STORE_OVERRIDE.
 const ALLOW_STORE_OVERRIDE = flag(process.env.WONTOPOS_ALLOW_STORE_OVERRIDE);
-const STORE = process.env.WONTOPOS_USER_ID || "default";
+// Whether the store was CHOSEN or fallen back to. Worth tracking, because the
+// fallback is silent in the worst way: if WONTOPOS_USER_ID never reaches this
+// process (a typo in the host config, an --env that did not take), everything goes
+// to `default` — and since every account is seeded with a `default` store, the boot
+// check below SUCCEEDS, so nothing looks wrong while the configured store sits
+// untouched. Say it out loud instead.
+const STORE_FROM_ENV = (process.env.WONTOPOS_USER_ID || "").trim();
+const STORE = STORE_FROM_ENV || "default";
 // Cap what a tool result may inject into the model's context. The SDK's 64MB cap
 // protects the process; this protects the conversation (a 2MB memory must not
-// become 2MB of context).
-const MAX_RESULT_CHARS = 131072;
-const MAX_QUERY_CHARS = 4096; // a query is a phrase, not a document
+// become 2MB of context). Measured in UTF-8 BYTES, not JS chars: `str.length`
+// counts UTF-16 units, so 131072 of them is ~384KB of Korean/CJK — the byte
+// count is what actually lands in the model, so bound that.
+const MAX_RESULT_BYTES = 131072; // 128 KB
+const MAX_QUERY_BYTES = 8192; // a query is a phrase, not a document (~4K CJK chars)
+const MAX_CONTENT_BYTES = 8192; // one memory is one fact, not a document
+const enc = new TextEncoder();
+const byteLen = (s) => enc.encode(s).length;
+/** Truncate a string to at most `maxBytes` UTF-8 bytes without splitting a
+ *  multi-byte character (TextEncoder.encodeInto stops on a char boundary). */
+function truncateToBytes(s, maxBytes) {
+  const buf = new Uint8Array(maxBytes);
+  const { read } = enc.encodeInto(s, buf); // `read` = whole chars that fit
+  return s.slice(0, read);
+}
 const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 
 // First env var with a NON-EMPTY value wins. `??` only skips null/undefined, so
@@ -84,14 +103,12 @@ function run(fn) {
     try {
       const result = await fn(args ?? {});
       let text = JSON.stringify(result, null, 1);
-      if (text.length > MAX_RESULT_CHARS) {
-        let cut = MAX_RESULT_CHARS;
-        // never cut between surrogate halves (would emit a lone surrogate)
-        const last = text.charCodeAt(cut - 1);
-        if (last >= 0xd800 && last <= 0xdbff) cut -= 1;
+      const bytes = byteLen(text);
+      if (bytes > MAX_RESULT_BYTES) {
+        // Leave room for the note itself so the whole reply stays under the cap.
         text =
-          text.slice(0, cut) +
-          `\n…[response truncated: ${text.length} chars exceeded the ${MAX_RESULT_CHARS}-char cap. ` +
+          truncateToBytes(text, MAX_RESULT_BYTES - 160) +
+          `\n…[response truncated: ${bytes} bytes exceeded the ${MAX_RESULT_BYTES}-byte cap. ` +
           "Narrow the query, lower limit, or page with cursor.]";
       }
       return { content: [{ type: "text", text }] };
@@ -100,7 +117,7 @@ function run(fn) {
       let msg = e instanceof WosError ? e.message : String(e?.message ?? e);
       // Errors are context too: a hostile or broken server must not bomb the
       // conversation through the error path either.
-      if (msg.length > 2000) msg = msg.slice(0, 2000) + "…[error truncated]";
+      if (byteLen(msg) > 2000) msg = truncateToBytes(msg, 2000) + "…[error truncated]";
       return { content: [{ type: "text", text: msg }], isError: true };
     }
   };
@@ -119,7 +136,7 @@ const uid = (u) => (ALLOW_STORE_OVERRIDE ? u ?? undefined : undefined);
 /** Reject blank or oversized queries before they reach the API. */
 function checkQuery(q, verb) {
   if (!q?.trim()) throw new Error(`query is blank — say what you want to ${verb}.`);
-  if (q.length > MAX_QUERY_CHARS) throw new Error(`query too long (max ${MAX_QUERY_CHARS} chars) — a query is a phrase, not a document.`);
+  if (byteLen(q) > MAX_QUERY_BYTES) throw new Error(`query too long (max ${MAX_QUERY_BYTES} bytes) — a query is a phrase, not a document.`);
 }
 
 server.registerTool(
@@ -173,8 +190,8 @@ server.registerTool(
   },
   run(({ content, speaker, event_date, user_id }) => {
     if (!content?.trim()) throw new Error("content is blank — a memory must carry an actual fact.");
-    if (content.length > 8192)
-      throw new Error("content too long (max 8192 chars) — a memory is one fact; backfill large text with the SDK's add_bulk.");
+    if (byteLen(content) > MAX_CONTENT_BYTES)
+      throw new Error("content too long (max 8192 bytes) — a memory is one fact; backfill large text with the SDK's add_bulk.");
     if (speaker && speaker !== "me")
       throw new Error("speaker must be 'me' (something the agent itself said) or omitted (the user's fact).");
     if (event_date && Number.isNaN(Date.parse(event_date)))
@@ -259,7 +276,7 @@ server.registerTool(
     if (!UUID_RE.test(old_memory_id?.trim() ?? ""))
       throw new Error("old_memory_id must be a memory id (uuid) from recall/search/list_memories results.");
     if (!new_content?.trim()) throw new Error("new_content is empty — an update must carry the corrected fact (to remove a memory, use forget).");
-    if (new_content.length > 8192) throw new Error("new_content too long (max 8192 chars) — a memory is one fact.");
+    if (byteLen(new_content) > MAX_CONTENT_BYTES) throw new Error("new_content too long (max 8192 bytes) — a memory is one fact.");
     return mem.update(old_memory_id.trim(), new_content, uid(user_id));
   })
 );
@@ -296,10 +313,24 @@ server.registerTool(
       "'deep_recall' searches then expands around the top match — thorough answer to one specific " +
       "question; 'timeline' returns memories ordered by when events happened — 'when did X', " +
       "histories; 'gather' expands around the top few matches — collect everything related to a " +
-      "topic. Heavier than search, so reach for it when recall/search came back thin or the user " +
-      "asks for a full picture.",
+      "topic; 'equilibrium' re-widens retrieval when a long session has narrowed it to whatever " +
+      "the current turn resembles — for replies that loop or flatten, not for a factual lookup; " +
+      "'tone_stabilizer' returns the assistant's OWN earlier words so it can come back to its " +
+      "usual register (needs turns stored with speaker \"me\"). " +
+      "Heavier than search, so reach for it when recall/search came back thin or the user asks " +
+      "for a full picture. Call the API's GET /api/v1/engram for the live catalogue.",
     inputSchema: {
-      name: z.enum(["deep_recall", "timeline", "gather"]),
+      // A plain string, NOT an enum: the enum was pinned to the original three, so
+      // every engram the service added afterwards was uncallable from here until
+      // this package was republished. The API validates the name and answers 400
+      // with the list it accepts, so an unknown name fails clearly and a new engram
+      // works the day it ships.
+      name: z
+        .string()
+        .min(1)
+        .describe(
+          "Engram name: deep_recall | timeline | gather | equilibrium | tone_stabilizer (the service is the authority; an unknown name returns the accepted list)."
+        ),
       query: z.string().describe("What to retrieve, phrased like the user's need."),
       ...storeArg,
     },
@@ -357,13 +388,26 @@ await server.connect(transport);
     return inner?.(msg, extra);
   };
 }
-console.error(`wontopos-mcp ${VERSION} ready (store: ${STORE}${READ_ONLY ? ", read-only" : ""})`);
+console.error(
+  `wontopos-mcp ${VERSION} ready (store: ${STORE}${STORE_FROM_ENV ? "" : " — FALLBACK: WONTOPOS_USER_ID is not set"}${READ_ONLY ? ", read-only" : ""})`
+);
 
 // Boot check (one metered stats call, after connect so host startup never waits):
 // "ready" above is a claim — verify it. A wrong key can do nothing → exit loudly.
 // A missing store is recoverable (the agent can create_store) → warn and serve.
 mem.stats().then(
-  (s) => console.error(`wontopos-mcp: store "${STORE}" verified (${s?.total_memories ?? "?"} memories).`),
+  (s) => {
+    console.error(`wontopos-mcp: store "${STORE}" verified (${s?.total_memories ?? "?"} memories).`);
+    // Verified, but on the fallback store — the case a misconfiguration hides in.
+    // The seeded `default` always exists, so this check passes and the operator has
+    // no other signal that the store they configured is not the one in use.
+    if (!STORE_FROM_ENV) {
+      console.error(
+        'wontopos-mcp: WONTOPOS_USER_ID is not set, so this server is using the seeded "default" store. ' +
+          "If you meant a different store, set WONTOPOS_USER_ID in the MCP server's env and restart."
+      );
+    }
+  },
   (e) => {
     const status = e instanceof WosError ? e.status : 0;
     if (status === 401) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wontopos-mcp",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "mcpName": "com.wontopos/mcp",
   "description": "(beta) Wontopos (WOS) long-term memory as an MCP server — one memory across Claude Code, Claude Desktop, Cursor, ChatGPT, and your own agents.",
   "keywords": [