@memnexus-ai/typescript-sdk 1.43.0 → 1.44.0

package/dist/index.cjs

@@ -2101,6 +2101,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 +2423,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);
   }
   /**
@@ -5025,6 +5116,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 +5236,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 */