@memnexus-ai/typescript-sdk 1.43.0 → 1.45.0

package/dist/index.cjs

@@ -1818,11 +1818,18 @@ var MonitoringService = class extends BaseService {
 // src/services/memories-service.ts
 var MemoriesService = class extends BaseService {
   /**
-   * Get memory by ID
-   * Retrieve a specific memory by its ID
-   * @param id - The memory ID
-   */
-  async getMemoryById(id) {
+     * Get memory by ID
+     * Retrieve a specific memory by its ID with configurable detail level.
+  
+  **Detail levels:**
+  - `minimal` — raw memory only, no extra queries
+  - `standard` (default) — adds userTopics, extractedTopics, entities, facts, relationships
+  - `full` — adds conversationContext (title, memoryCount, position) and relationship target previews
+  
+     * @param id - The memory ID
+     * @param detail - Detail level: minimal (raw memory), standard (default, + topics/entities/facts/relationships), full (+ conversation context and relationship previews)
+     */
+  async getMemoryById(id, options) {
     const request = new Request({
       baseUrl: this.config.baseUrl || "http://localhost:3000",
       method: "GET",
@@ -1846,6 +1853,18 @@ var MemoriesService = class extends BaseService {
       isOffset: false,
       isCursor: false
     });
+    if (options?.detail !== void 0) {
+      request.addQueryParam("detail", {
+        key: "detail",
+        value: options.detail,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: false,
+        isCursor: false
+      });
+    }
     return this.client.call(request);
   }
   /**
@@ -2101,6 +2120,13 @@ var MemoriesService = class extends BaseService {
      * @param temporalMode - Temporal query mode
      * @param sortBy - Field to sort results by
      * @param order - Sort order
+     * @param expandEntities - Enable entity graph traversal branch in hybrid search
+     * @param expandTopics - Enable topic graph traversal branch in hybrid search
+     * @param expandFacts - Enable fact graph traversal branch in hybrid search
+     * @param includeSuperseded - Include superseded and contradicted memories in results
+     * @param entityWeight - Weight for entity graph branch in hybrid search
+     * @param topicWeight - Weight for topic graph branch in hybrid search
+     * @param factWeight - Weight for fact graph branch in hybrid search
      */
   async searchMemoriesGet(options) {
     const request = new Request({
@@ -2416,6 +2442,90 @@ var MemoriesService = class extends BaseService {
         isCursor: false
       });
     }
+    if (options?.expandEntities !== void 0) {
+      request.addQueryParam("expandEntities", {
+        key: "expandEntities",
+        value: options.expandEntities,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: false,
+        isCursor: false
+      });
+    }
+    if (options?.expandTopics !== void 0) {
+      request.addQueryParam("expandTopics", {
+        key: "expandTopics",
+        value: options.expandTopics,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: false,
+        isCursor: false
+      });
+    }
+    if (options?.expandFacts !== void 0) {
+      request.addQueryParam("expandFacts", {
+        key: "expandFacts",
+        value: options.expandFacts,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: false,
+        isCursor: false
+      });
+    }
+    if (options?.includeSuperseded !== void 0) {
+      request.addQueryParam("includeSuperseded", {
+        key: "includeSuperseded",
+        value: options.includeSuperseded,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: false,
+        isCursor: false
+      });
+    }
+    if (options?.entityWeight !== void 0) {
+      request.addQueryParam("entityWeight", {
+        key: "entityWeight",
+        value: options.entityWeight,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: false,
+        isCursor: false
+      });
+    }
+    if (options?.topicWeight !== void 0) {
+      request.addQueryParam("topicWeight", {
+        key: "topicWeight",
+        value: options.topicWeight,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: false,
+        isCursor: false
+      });
+    }
+    if (options?.factWeight !== void 0) {
+      request.addQueryParam("factWeight", {
+        key: "factWeight",
+        value: options.factWeight,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: false,
+        isCursor: false
+      });
+    }
     return this.client.call(request);
   }
   /**
@@ -2554,11 +2664,12 @@ var MemoriesService = class extends BaseService {
   /**
      * Get a memory by name
      * Retrieve the current HEAD version of a named memory by its user-assigned name.
-  Returns the memory with topic breakdown and entities, same as GET /api/memories/{id}.
+  Supports the same detail levels as GET /api/memories/{id}.
   
      * @param name - Memory name (kebab-case, 2-64 chars)
+     * @param detail - Detail level: minimal (raw memory), standard (default, + topics/entities/facts/relationships), full (+ conversation context and relationship previews)
      */
-  async getMemoryByName(name) {
+  async getMemoryByName(name, options) {
     const request = new Request({
       baseUrl: this.config.baseUrl || "http://localhost:3000",
       method: "GET",
@@ -2582,6 +2693,18 @@ var MemoriesService = class extends BaseService {
       isOffset: false,
       isCursor: false
     });
+    if (options?.detail !== void 0) {
+      request.addQueryParam("detail", {
+        key: "detail",
+        value: options.detail,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: false,
+        isCursor: false
+      });
+    }
     return this.client.call(request);
   }
   /**
@@ -4857,7 +4980,9 @@ var namedMemoryHistoryResponse = import_zod.z.object({
 });
 var batchGetMemoriesRequest = import_zod.z.object({
   /** Array of memory IDs to retrieve */
-  ids: import_zod.z.array(import_zod.z.string().uuid()).min(1).max(100)
+  ids: import_zod.z.array(import_zod.z.string().uuid()).min(1).max(100),
+  /** Detail level for each memory. 'minimal' returns raw memory only (default, backward compatible). 'standard' adds topics, entities, facts, and relationships. */
+  detail: import_zod.z.enum(["minimal", "standard"]).optional()
 });
 var batchGetMemoriesMeta = import_zod.z.object({
   /** Number of IDs requested */
@@ -5025,6 +5150,20 @@ var searchRequest = import_zod.z.object({
   includeFacts: import_zod.z.boolean().optional(),
   /** Filter entities by type (e.g., PERSON, TECHNOLOGY, PROJECT) */
   entityTypes: import_zod.z.array(import_zod.z.string().max(50)).max(20).optional(),
+  /** Enable entity graph traversal branch in hybrid search (default false) */
+  expandEntities: import_zod.z.boolean().optional(),
+  /** Enable topic graph traversal branch in hybrid search (default false) */
+  expandTopics: import_zod.z.boolean().optional(),
+  /** Enable fact graph traversal branch in hybrid search (default false) */
+  expandFacts: import_zod.z.boolean().optional(),
+  /** Include superseded and contradicted memories in results (default false) */
+  includeSuperseded: import_zod.z.boolean().optional(),
+  /** Weight for entity graph branch in hybrid search (0-1, default 0.7) */
+  entityWeight: import_zod.z.number().min(0).max(1).optional(),
+  /** Weight for topic graph branch in hybrid search (0-1, default 0.5) */
+  topicWeight: import_zod.z.number().min(0).max(1).optional(),
+  /** Weight for fact graph branch in hybrid search (0-1, default 0.6) */
+  factWeight: import_zod.z.number().min(0).max(1).optional(),
   /** Field to sort results by (defaults to 'relevance' for search, 'createdAt' for list) */
   sortBy: import_zod.z.enum(["relevance", "createdAt", "updatedAt", "eventTime"]).optional(),
   /** Sort order: 'asc' or 'desc' (defaults to 'desc' for timestamps, 'desc' for relevance) */
@@ -5131,6 +5270,10 @@ var searchResult = import_zod.z.lazy(() => import_zod.z.object({
   fulltextScore: import_zod.z.number().optional(),
   /** Rank in fulltext search results */
   fulltextRank: import_zod.z.number().nullable().optional(),
+  /** Search branches that contributed to this result (e.g. ['semantic', 'entity']) */
+  matchedVia: import_zod.z.array(import_zod.z.string()).optional(),
+  /** Per-branch RRF scores for this result */
+  branchScores: import_zod.z.object({}).catchall(import_zod.z.number()).optional(),
   /** Detailed explanation of the match (only when explain=true) */
   explanation: import_zod.z.object({
     /** Human-readable explanation of why this result matched */