@memnexus-ai/typescript-sdk 1.30.0 → 1.31.1

package/dist/index.cjs

@@ -62,6 +62,11 @@ __export(index_exports, {
   createNarrativeRequest: () => createNarrativeRequest,
   createPortalSessionRequest: () => createPortalSessionRequest,
   default: () => index_default,
+  digestMetadata: () => digestMetadata,
+  digestRequest: () => digestRequest,
+  digestResponse: () => digestResponse,
+  digestSource: () => digestSource,
+  digestTimeRange: () => digestTimeRange,
   entity: () => entity,
   entityNode: () => entityNode,
   error: () => error,
@@ -2424,6 +2429,46 @@ var MemoriesService = class extends BaseService {
     }
     return this.client.call(request);
   }
+  /**
+     * Generate memory digest
+     * Synthesizes a comprehensive, structured briefing from all relevant memories
+  on a topic. Instead of multiple search rounds, one call returns a complete digest.
+  
+  **Formats:**
+  - `structured` (default): Sections with headers, bullet points, key decisions
+  - `narrative`: Chronological prose narrative
+  - `timeline`: Dated event list
+  - `status-report`: Done/In Progress/Blocked grouping
+  
+  **Pipeline:**
+  1. Gather: High-limit search + conversation expansion
+  2. Organize: Group by conversation, status, timeline
+  3. Synthesize: LLM generates formatted digest
+  
+  Requires an LLM provider to be configured (EXTRACTION_ENABLED=true).
+  Returns 503 if the LLM provider is unavailable and 3+ memories are found.
+  
+     * @param body - Request body
+     */
+  async generateMemoryDigest(body) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "POST",
+      path: "/api/memories/digest",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    if (body !== void 0) {
+      request.addBody(body);
+    }
+    return this.client.call(request);
+  }
   /**
      * Get version history for a named memory
      * Returns the full version chain for a named memory, ordered newest-first.
@@ -4180,6 +4225,56 @@ var UsersService = class extends BaseService {
     });
     return this.client.call(request);
   }
+  /**
+     * Initiate account deletion
+     * Schedule the current user's account for deletion after a 7-day grace period.
+  Requires email confirmation. Immediately revokes API keys and cancels
+  any active subscription. The account enters read-only mode.
+  
+     * @param body - Request body
+     */
+  async initiateAccountDeletion(body) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "POST",
+      path: "/api/users/me/deletion",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    if (body !== void 0) {
+      request.addBody(body);
+    }
+    return this.client.call(request);
+  }
+  /**
+     * Cancel account deletion
+     * Cancel a pending account deletion during the grace period.
+  Note: Previously revoked API keys are not restored — new keys must be created.
+  Stripe subscription may need manual reactivation via the billing portal.
+  
+     */
+  async cancelAccountDeletion() {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "DELETE",
+      path: "/api/users/me/deletion",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    return this.client.call(request);
+  }
   /**
    * Get user by ID
    * Get a user by their internal ID (admin only)
@@ -5104,6 +5199,8 @@ var user = import_zod.z.object({
   plan: import_zod.z.enum(["free", "pro", "enterprise"]),
   memoryLimit: import_zod.z.number(),
   retentionDays: import_zod.z.number().nullable(),
+  deletionStatus: import_zod.z.enum(["none", "pending_deletion", "deleting", "deleted"]),
+  deletionScheduledFor: import_zod.z.string().datetime().nullable(),
   createdAt: import_zod.z.string().datetime(),
   updatedAt: import_zod.z.string().datetime()
 });
@@ -5253,6 +5350,60 @@ var listPaymentMethodsResponse = import_zod.z.lazy(() => import_zod.z.object({
   /** List of payment methods */
   data: import_zod.z.array(paymentMethod)
 }));
+var digestRequest = import_zod.z.object({
+  /** The topic or subject to generate a digest for */
+  query: import_zod.z.string().min(1),
+  /** Time window filter (e.g., "7d", "24h", "2w", "30m"). Only considers memories within this window. */
+  recent: import_zod.z.string().optional(),
+  /** Filter to memories with these topics */
+  topics: import_zod.z.array(import_zod.z.string()).optional(),
+  /** Limit to specific conversation IDs */
+  conversationIds: import_zod.z.array(import_zod.z.string()).optional(),
+  /** Output format: "structured" (sections with headers), "narrative" (chronological prose), "timeline" (dated event list), "status-report" (done/in-progress/blocked) */
+  format: import_zod.z.enum(["structured", "narrative", "timeline", "status-report"]).optional(),
+  /** Maximum number of memories to consider (1-500, default 100) */
+  maxSources: import_zod.z.number().min(1).max(500).optional(),
+  /** Whether to include source memory IDs in the response */
+  includeMemoryIds: import_zod.z.boolean().optional()
+});
+var digestTimeRange = import_zod.z.object({
+  /** Earliest memory timestamp in the digest sources */
+  earliest: import_zod.z.string().datetime(),
+  /** Latest memory timestamp in the digest sources */
+  latest: import_zod.z.string().datetime()
+}).nullable();
+var digestMetadata = import_zod.z.lazy(() => import_zod.z.object({
+  /** The query used to generate the digest */
+  query: import_zod.z.string(),
+  /** Total number of memories gathered (search + expansion) before synthesis */
+  sourcesConsidered: import_zod.z.number().min(0),
+  /** Number of memories fed into the synthesis step */
+  sourcesUsed: import_zod.z.number().min(0),
+  /** Number of distinct conversations the sources come from */
+  conversationsSpanned: import_zod.z.number().min(0),
+  /** Time range of the source memories (null if no sources found) */
+  timeRange: digestTimeRange,
+  /** Output format used for this digest */
+  format: import_zod.z.enum(["structured", "narrative", "timeline", "status-report"]),
+  /** ISO 8601 timestamp when the digest was generated */
+  generatedAt: import_zod.z.string().datetime()
+}));
+var digestSource = import_zod.z.object({
+  /** Source memory ID */
+  memoryId: import_zod.z.string(),
+  /** Relevance score (0-1) for this source memory */
+  relevance: import_zod.z.number().min(0).max(1),
+  /** Conversation ID this memory belongs to */
+  conversation: import_zod.z.string().optional()
+});
+var digestResponse = import_zod.z.lazy(() => import_zod.z.object({
+  /** The generated digest content (markdown formatted) */
+  digest: import_zod.z.string(),
+  /** Generation metadata including source statistics */
+  metadata: digestMetadata,
+  /** Source memories used to generate the digest, for traceability */
+  sources: import_zod.z.array(digestSource)
+}));
 
 // src/index.ts
 var Memnexus = class {
@@ -5435,6 +5586,11 @@ var index_default = Memnexus;
   createMemoryResponseMeta,
   createNarrativeRequest,
   createPortalSessionRequest,
+  digestMetadata,
+  digestRequest,
+  digestResponse,
+  digestSource,
+  digestTimeRange,
   entity,
   entityNode,
   error,