@memnexus-ai/typescript-sdk 1.68.7 → 1.69.0

package/dist/index.cjs

@@ -55,6 +55,7 @@ __export(index_exports, {
   batchGetMemoriesRequest: () => batchGetMemoriesRequest,
   batchGetMemoriesResponse: () => batchGetMemoriesResponse,
   billingOverview: () => billingOverview,
+  branchFailure: () => branchFailure,
   buildContextActiveWork: () => buildContextActiveWork,
   buildContextActivity: () => buildContextActivity,
   buildContextFact: () => buildContextFact,
@@ -131,6 +132,7 @@ __export(index_exports, {
   precomputedMemoryFields: () => precomputedMemoryFields,
   recommendation: () => recommendation,
   relatedMemoryResult: () => relatedMemoryResult,
+  searchFailureResponse: () => searchFailureResponse,
   searchMeta: () => searchMeta,
   searchRequest: () => searchRequest,
   searchResponse: () => searchResponse,
@@ -5888,6 +5890,42 @@ var AdminService = class extends BaseService {
     }
     return this.client.call(request);
   }
+  /**
+   * Re-encrypt existing plaintext-at-rest Memory and Entity rows (dry-run by default)
+   * @param apply - When true, mutate rows. Default false = dry-run (count only, no writes). May also be supplied as `apply: true` in the request body; either the query param or the body field enables apply mode.
+   * @param body - Request body
+   */
+  async adminMigrateEncryptionBackfill(options) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "POST",
+      path: "/api/admin/migrate/encryption-backfill",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    if (options?.apply !== void 0) {
+      request.addQueryParam("apply", {
+        key: "apply",
+        value: options.apply,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: false,
+        isCursor: false
+      });
+    }
+    if (options?.body !== void 0) {
+      request.addBody(options?.body);
+    }
+    return this.client.call(request);
+  }
 };
 
 // src/services/admin-alerts-service.ts
@@ -6931,6 +6969,14 @@ var searchResult = import_zod.z.lazy(() => import_zod.z.object({
     contributingFactors: import_zod.z.array(import_zod.z.string()).optional()
   }).optional()
 }));
+var branchFailure = import_zod.z.object({
+  /** Search branch name (fulltext, semantic, topic, digest, …) */
+  name: import_zod.z.string(),
+  /** How the branch failed */
+  status: import_zod.z.enum(["timeout", "error"]),
+  /** Closed-vocabulary cause. Never free text — a raw message could leak internal hostnames, ports, or query text. */
+  reason: import_zod.z.enum(["timeout", "connection", "query_error", "provider_error", "unknown"])
+});
 var temporalMetadata = import_zod.z.object({
   /** Temporal query mode used */
   temporalMode: import_zod.z.string(),
@@ -6964,6 +7010,10 @@ var searchMeta = import_zod.z.lazy(() => import_zod.z.object({
   searchTime: import_zod.z.number(),
   /** Search method used for this query */
   searchMethod: import_zod.z.string(),
+  /** True when this result set is INCOMPLETE — at least one search branch timed out or errored, so absence of a memory does not mean it does not exist. ABSENT (not false) on the healthy path: a healthy response gains no new fields. */
+  degraded: import_zod.z.boolean().optional(),
+  /** The branches that did NOT complete, present only when degraded is true. Healthy branches are omitted, and the field is absent entirely on the healthy path. */
+  branchFailures: import_zod.z.array(branchFailure).optional(),
   /** Temporal query metadata (present when temporal filters are used) */
   temporalMetadata: temporalMetadata.optional()
 }));
@@ -7029,6 +7079,20 @@ var searchResponse = import_zod.z.lazy(() => import_zod.z.object({
   /** Clusters of related claims that may conflict. Only present when relevant groups exist. Claims within each group are sorted newest-first. */
   claim_groups: import_zod.z.array(claimGroup).optional()
 }));
+var searchFailureResponse = import_zod.z.lazy(() => import_zod.z.object({
+  /** Human-readable message. Worded so it never reads as 'no results exist'. */
+  error: import_zod.z.string(),
+  /** Top-level outcome the client switches on. all_branches_failed = every search branch failed, backend degraded (a retry may not help until it recovers); deadline_exceeded = the in-app request deadline was hit before a result could be produced (a retry may land inside budget); service_at_capacity = the request was shed by bounded admission/backpressure (retrying after retry_after_ms succeeds once load drops). */
+  reason: import_zod.z.enum(["all_branches_failed", "deadline_exceeded", "service_at_capacity"]).optional(),
+  /** Explicit signal that retrying is worthwhile. True for all typed honest-failure reasons. */
+  retryable: import_zod.z.boolean().optional(),
+  /** Advisory delay in milliseconds before retrying. Present only when reason is service_at_capacity. Carries server-side jitter (base ±25%) so clients shed together do not retry in lockstep and re-create the spike. */
+  retry_after_ms: import_zod.z.number().min(0).optional(),
+  /** True when the gather was incomplete — at least one search branch timed out or errored. */
+  degraded: import_zod.z.boolean().optional(),
+  /** The branches that did NOT complete. Healthy branches are omitted. */
+  branchFailures: import_zod.z.array(branchFailure).optional()
+}));
 var fact = import_zod.z.object({
   /** Unique identifier for the fact */
   id: import_zod.z.string(),
@@ -8074,6 +8138,7 @@ var index_default = Memnexus;
   batchGetMemoriesRequest,
   batchGetMemoriesResponse,
   billingOverview,
+  branchFailure,
   buildContextActiveWork,
   buildContextActivity,
   buildContextFact,
@@ -8149,6 +8214,7 @@ var index_default = Memnexus;
   precomputedMemoryFields,
   recommendation,
   relatedMemoryResult,
+  searchFailureResponse,
   searchMeta,
   searchRequest,
   searchResponse,