@memnexus-ai/typescript-sdk 1.42.17 → 1.44.0

package/dist/index.cjs

@@ -755,6 +755,8 @@ var TopicsService = class extends BaseService {
    * List all topics with pagination
    * @param limit - Maximum number of topics to return
    * @param offset - Number of topics to skip
+   * @param sortBy - Field to sort topics by
+   * @param order - Sort order
    */
   async listTopics(options) {
     const request = new Request({
@@ -794,6 +796,30 @@ var TopicsService = class extends BaseService {
         isCursor: false
       });
     }
+    if (options?.sortBy !== void 0) {
+      request.addQueryParam("sortBy", {
+        key: "sortBy",
+        value: options.sortBy,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: false,
+        isCursor: false
+      });
+    }
+    if (options?.order !== void 0) {
+      request.addQueryParam("order", {
+        key: "order",
+        value: options.order,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: false,
+        isCursor: false
+      });
+    }
     return this.client.call(request);
   }
   /**
@@ -1903,6 +1929,8 @@ var MemoriesService = class extends BaseService {
      * @param limit - Maximum number of memories to return
      * @param offset - Number of memories to skip
      * @param page - Page number (alternative to offset)
+     * @param sortBy - Field to sort results by
+     * @param order - Sort order
      */
   async listMemories(options) {
     const request = new Request({
@@ -1966,6 +1994,30 @@ var MemoriesService = class extends BaseService {
         isCursor: false
       });
     }
+    if (options?.sortBy !== void 0) {
+      request.addQueryParam("sortBy", {
+        key: "sortBy",
+        value: options.sortBy,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: false,
+        isCursor: false
+      });
+    }
+    if (options?.order !== void 0) {
+      request.addQueryParam("order", {
+        key: "order",
+        value: options.order,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: false,
+        isCursor: false
+      });
+    }
     return this.client.call(request);
   }
   /**
@@ -2047,6 +2099,15 @@ var MemoriesService = class extends BaseService {
      * @param ingestionTimeTo - Ingestion time range end (ISO 8601 datetime)
      * @param includeExpired - Include expired memories in results
      * @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({
@@ -2338,6 +2399,114 @@ var MemoriesService = class extends BaseService {
         isCursor: false
       });
     }
+    if (options?.sortBy !== void 0) {
+      request.addQueryParam("sortBy", {
+        key: "sortBy",
+        value: options.sortBy,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: false,
+        isCursor: false
+      });
+    }
+    if (options?.order !== void 0) {
+      request.addQueryParam("order", {
+        key: "order",
+        value: options.order,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: false,
+        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);
   }
   /**
@@ -3107,6 +3276,8 @@ var FactsService = class extends BaseService {
    * List all facts for the authenticated user
    * @param limit - Maximum number of facts to return
    * @param offset - Number of facts to skip
+   * @param sortBy - Field to sort facts by
+   * @param order - Sort order
    */
   async listFacts(options) {
     const request = new Request({
@@ -3146,6 +3317,30 @@ var FactsService = class extends BaseService {
         isCursor: false
       });
     }
+    if (options?.sortBy !== void 0) {
+      request.addQueryParam("sortBy", {
+        key: "sortBy",
+        value: options.sortBy,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: false,
+        isCursor: false
+      });
+    }
+    if (options?.order !== void 0) {
+      request.addQueryParam("order", {
+        key: "order",
+        value: options.order,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: false,
+        isCursor: false
+      });
+    }
     return this.client.call(request);
   }
   /**
@@ -3454,6 +3649,8 @@ var ConversationsService = class extends BaseService {
    * @param limit - Maximum number of conversations to return
    * @param offset - Number of conversations to skip
    * @param since - Return only conversations created after this timestamp (ISO 8601 format)
+   * @param sortBy - Field to sort conversations by
+   * @param order - Sort order
    */
   async listConversations(options) {
     const request = new Request({
@@ -3505,6 +3702,30 @@ var ConversationsService = class extends BaseService {
         isCursor: false
       });
     }
+    if (options?.sortBy !== void 0) {
+      request.addQueryParam("sortBy", {
+        key: "sortBy",
+        value: options.sortBy,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: false,
+        isCursor: false
+      });
+    }
+    if (options?.order !== void 0) {
+      request.addQueryParam("order", {
+        key: "order",
+        value: options.order,
+        explode: false,
+        encode: true,
+        style: "form",
+        isLimit: false,
+        isOffset: false,
+        isCursor: false
+      });
+    }
     return this.client.call(request);
   }
   /**
@@ -4894,7 +5115,25 @@ var searchRequest = import_zod.z.object({
   /** Include facts extracted from matched memories (defaults to false for performance) */
   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()
+  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) */
+  order: import_zod.z.enum(["asc", "desc"]).optional()
 });
 var entity = import_zod.z.object({
   /** Entity name */
@@ -4997,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 */