memorysync-sdk 1.7.2 → 1.8.0

package/dist/index.d.mts

@@ -807,6 +807,17 @@ interface AddRequest {
     sessionId?: string;
     metadata?: Record<string, unknown>;
     endUserId?: string;
+    /**
+     * Your own identifier for this record, at most 128 characters.
+     *
+     * Send it and re-sending the record is recognised rather than stored a second
+     * time: the call resolves to an {@link AddSkippedResponse} with reason
+     * `already_ingested` and the ids the first write produced. That makes an
+     * interrupted write safe to retry without first checking whether it landed.
+     * Near-duplicate detection is always on but compares *meaning*, so it is a
+     * filter and not a guarantee.
+     */
+    clientRef?: string;
 }
 interface MemoryRecord {
     id: number;
@@ -832,6 +843,16 @@ interface AddSkippedResponse {
 type AddResponse = MemoryRecord | AddSkippedResponse;
 interface BulkAddItem {
     text: string;
+    /**
+     * Your own identifier for this record, at most 128 characters.
+     *
+     * Send it and re-submitting the record is recognised rather than stored a
+     * second time: the item comes back `skipped` with reason `already_ingested`
+     * and the ids the first submission produced. This is what makes a large import
+     * safe to re-run. Near-duplicate detection is always on but compares
+     * *meaning*, so it is a filter and not a guarantee.
+     */
+    clientRef?: string;
     source?: string;
     eventType?: string;
     tags?: string[];
@@ -851,6 +872,15 @@ interface BulkAddResponse {
     skipped: number;
     rejected: number;
     results: BulkAddItemResult[];
+    /**
+     * Items the server accepted without returning a per-item result.
+     *
+     * Normally `0`. It is the whole batch when the organization is over its plan
+     * limit: the route answers a bare success envelope and stores nothing, so
+     * there is no per-item detail to report. Counted separately from `created` on
+     * purpose — reporting these as created would be a guess, and a wrong one.
+     */
+    unreported: number;
 }
 interface QueryFilters {
     memoryType?: string;

package/dist/index.d.ts

@@ -807,6 +807,17 @@ interface AddRequest {
     sessionId?: string;
     metadata?: Record<string, unknown>;
     endUserId?: string;
+    /**
+     * Your own identifier for this record, at most 128 characters.
+     *
+     * Send it and re-sending the record is recognised rather than stored a second
+     * time: the call resolves to an {@link AddSkippedResponse} with reason
+     * `already_ingested` and the ids the first write produced. That makes an
+     * interrupted write safe to retry without first checking whether it landed.
+     * Near-duplicate detection is always on but compares *meaning*, so it is a
+     * filter and not a guarantee.
+     */
+    clientRef?: string;
 }
 interface MemoryRecord {
     id: number;
@@ -832,6 +843,16 @@ interface AddSkippedResponse {
 type AddResponse = MemoryRecord | AddSkippedResponse;
 interface BulkAddItem {
     text: string;
+    /**
+     * Your own identifier for this record, at most 128 characters.
+     *
+     * Send it and re-submitting the record is recognised rather than stored a
+     * second time: the item comes back `skipped` with reason `already_ingested`
+     * and the ids the first submission produced. This is what makes a large import
+     * safe to re-run. Near-duplicate detection is always on but compares
+     * *meaning*, so it is a filter and not a guarantee.
+     */
+    clientRef?: string;
     source?: string;
     eventType?: string;
     tags?: string[];
@@ -851,6 +872,15 @@ interface BulkAddResponse {
     skipped: number;
     rejected: number;
     results: BulkAddItemResult[];
+    /**
+     * Items the server accepted without returning a per-item result.
+     *
+     * Normally `0`. It is the whole batch when the organization is over its plan
+     * limit: the route answers a bare success envelope and stores nothing, so
+     * there is no per-item detail to report. Counted separately from `created` on
+     * purpose — reporting these as created would be a guess, and a wrong one.
+     */
+    unreported: number;
 }
 interface QueryFilters {
     memoryType?: string;

package/dist/index.js

@@ -576,7 +576,7 @@ var IntegrationsNamespace = class extends Namespace {
 };
 
 // src/control-plane.ts
-var SDK_VERSION = "1.7.2";
+var SDK_VERSION = "1.8.0";
 function safeJson(text) {
   try {
     return JSON.parse(text);
@@ -1132,7 +1132,23 @@ var ControlPlaneClient = class {
 };
 
 // src/index.ts
-var SDK_VERSION2 = "1.7.2";
+function asSkipped(raw, defaultReason) {
+  if (!raw || typeof raw !== "object") return null;
+  if (raw.status === "skipped") {
+    return {
+      status: "skipped",
+      reason: raw.reason ?? defaultReason,
+      memoryIds: raw.memory_ids ?? [],
+      candidatesExtracted: raw.candidates_extracted ?? 0,
+      candidatesStored: raw.candidates_stored ?? 0
+    };
+  }
+  if (raw.status === "ok" && raw.id === void 0) {
+    return { status: "skipped", reason: "quota_exhausted", memoryIds: [], candidatesExtracted: 0, candidatesStored: 0 };
+  }
+  return null;
+}
+var SDK_VERSION2 = "1.8.0";
 function camelToSnakeKey(key) {
   return key.replace(/([A-Z])/g, "_$1").toLowerCase();
 }
@@ -1299,19 +1315,13 @@ var MemorySyncClient = class {
     if (req.sessionId !== void 0) body.session_id = req.sessionId;
     if (req.metadata !== void 0) body.metadata = req.metadata;
     if (req.endUserId !== void 0) body.end_user_id = req.endUserId;
+    if (req.clientRef !== void 0) body.client_ref = req.clientRef;
     const raw = await this.request("POST", "/memory/add", {
       body,
       endUserOverride: req.endUserId
     });
-    if (raw && raw.status === "skipped") {
-      return {
-        status: "skipped",
-        reason: raw.reason ?? "no_high_value_content",
-        memoryIds: raw.memory_ids ?? [],
-        candidatesExtracted: raw.candidates_extracted ?? 0,
-        candidatesStored: raw.candidates_stored ?? 0
-      };
-    }
+    const notStored = asSkipped(raw, "no_high_value_content");
+    if (notStored) return notStored;
     return snakeToCamelMemory(raw);
   }
   async bulkAdd(items, opts = {}) {
@@ -1326,17 +1336,29 @@ var MemorySyncClient = class {
         if (i.metadata !== void 0) o.metadata = i.metadata;
         if (i.importance !== void 0) o.importance = i.importance;
         if (i.endUserId !== void 0) o.end_user_id = i.endUserId;
+        if (i.clientRef !== void 0) o.client_ref = i.clientRef;
         return o;
       }),
       deduplicate: opts.deduplicate ?? true
     };
     const raw = await this.request("POST", "/memory/bulk-add", { body });
+    if (!Array.isArray(raw.results)) {
+      return {
+        total: items.length,
+        created: 0,
+        skipped: 0,
+        rejected: 0,
+        results: [],
+        unreported: items.length
+      };
+    }
     return {
       total: raw.total,
       created: raw.created,
       skipped: raw.skipped,
       rejected: raw.rejected,
-      results: (raw.results ?? []).map((r) => ({
+      unreported: 0,
+      results: raw.results.map((r) => ({
         index: r.index,
         status: r.status,
         memoryIds: r.memory_ids ?? [],
@@ -1533,15 +1555,8 @@ var MemorySyncClient = class {
       form,
       endUserOverride: req.endUserId
     });
-    if (raw && raw.status === "skipped") {
-      return {
-        status: "skipped",
-        reason: raw.reason ?? "no_extractable_text",
-        memoryIds: raw.memory_ids ?? [],
-        candidatesExtracted: raw.candidates_extracted ?? 0,
-        candidatesStored: raw.candidates_stored ?? 0
-      };
-    }
+    const notStored = asSkipped(raw, "no_extractable_text");
+    if (notStored) return notStored;
     return snakeToCamelMemory(raw);
   }
   // ── Bulk edit ──────────────────────────────────────────────────────