wontopos 2.2.21 → 2.2.23

package/dist/wontopos.d.ts

@@ -76,8 +76,6 @@ export declare class RateLimitError extends WosError {
 /** 5xx — the service failed. Safe to retry. */
 export declare class ServerError extends WosError {
 }
-/** Build the most specific WosError subclass for an HTTP status. */
-export declare function errorFor(status: number, message: string, requestId?: string): WosError;
 export interface Usage {
     input_tokens?: number;
     output_tokens?: number;
@@ -242,6 +240,12 @@ export interface ClientOptions {
      * 502/503 and connection errors only when a retry can never double-process a
      * write. 0 disables retries (default 2). */
     maxRetries?: number;
+    /** Alias of `maxRetries`. The Python SDK calls this option `retries`, and these
+     *  SDKs are published in lockstep as "the same surface" — so code ported between
+     *  them silently lost its retry setting instead of failing loudly (an unknown
+     *  key on an options object is not an error in TS at runtime). Both names work;
+     *  `maxRetries` wins if somehow both are given. */
+    retries?: number;
 }
 /** Wontopos memory client. Store and recall memories, isolated per `userId`. */
 export declare class Client {

package/dist/wontopos.js

@@ -37,7 +37,7 @@
  * runtime's (never disabled by this SDK; Node 18+ floors TLS at 1.2). Prefer
  * `Client.fromEnv()` over keys in source code.
  */
-const VERSION = "2.2.21";
+const VERSION = "2.2.23";
 /** Runtime info helps support debug a report ("node 18 on Windows...") —
  * platform only, never anything identifying. Browsers have no `process` (and
  * silently drop the UA header anyway). */
@@ -138,6 +138,26 @@ const asObj = (x) => (x != null && typeof x === "object" && !Array.isArray(x) ?
 const asRecords = (x) => asList(x).filter((m) => m != null && typeof m === "object" && !Array.isArray(m));
 // Attach a delivery-form override (memoir/archive) + tz to a body, the way search
 // passes them; on Scroll 1.2+ this renders each returned memory's time in that form.
+/** Every memory a search returned — main lane and self lane together.
+ *
+ * On a self-lane model the service splits the result: the assistant's OWN words
+ * come back in `self_memories` and are REMOVED from `memories`, so the two never
+ * double-count. `search()` read only `memories`, so on Scroll 1.2 an assistant
+ * turn stored with `addTurn` was silently missing from search while the same
+ * query on tablet-1 returned it — upgrading the model made search return LESS,
+ * and the dropped memories were already on the wire and already paid for.
+ *
+ * Both lanes, de-duplicated by id, each memory keeping its `speaker` so the
+ * caller can still tell who said what. Callers who want the lanes kept apart use
+ * `searchSelf()`, which exists for exactly that. */
+function mergeLanes(r) {
+    const main = asRecords(r?.memories);
+    const mine = asRecords(r?.self_memories);
+    if (mine.length === 0)
+        return main;
+    const seen = new Set(main.map((m) => m.id).filter((id) => typeof id === "string"));
+    return main.concat(mine.filter((m) => !(typeof m.id === "string" && seen.has(m.id))));
+}
 function withForm(body, form, tz) {
     if (form !== undefined)
         body.form = form;
@@ -195,7 +215,8 @@ const STATUS_ERRORS = {
     429: RateLimitError,
 };
 /** Build the most specific WosError subclass for an HTTP status. */
-export function errorFor(status, message, requestId) {
+// Internal factory — the typed error CLASSES are the public surface.
+function errorFor(status, message, requestId) {
     const Cls = status === 0
         ? APIConnectionError
         : STATUS_ERRORS[status] ?? (status >= 500 && status < 600 ? ServerError : WosError);
@@ -242,7 +263,7 @@ export class Client {
         // Coerce a non-finite maxRetries (NaN/Infinity) back to the default — otherwise
         // NaN makes `attempts = NaN + 1` and the loop runs zero requests then throws
         // "retries exhausted"; Infinity would retry forever.
-        const mr = opts.maxRetries;
+        const mr = opts.maxRetries ?? opts.retries;
         this.maxRetries = typeof mr === "number" && Number.isFinite(mr) ? Math.max(0, Math.floor(mr)) : 2;
         this.headers = {
             "X-API-Key": this.apiKey,
@@ -350,7 +371,7 @@ export class Client {
         // Reserved fields win over ...opts: an app that forwards untrusted input as
         // opts must not be able to override the store (user_id), query, or limit.
         const r = await this.post("/api/v1/memory/search", { ...opts, user_id: this.uid(userId), query, max_results: limit });
-        return asRecords(r.memories);
+        return mergeLanes(r);
     }
     /** Search a self-memory model (Scroll 1.2+): both lanes from ONE call. Returns
      * `{ memories, self_memories }` — `memories` is the main lane (what others said /

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wontopos",
-  "version": "2.2.21",
+  "version": "2.2.23",
   "description": "Wontopos — long-term memory for AI agents. Pure semantic retrieval, identical recall in every language, ~100× lower LLM bill.",
   "keywords": [
     "memory",