@memnexus-ai/typescript-sdk 1.26.2 → 1.28.0

package/dist/index.cjs

@@ -80,6 +80,7 @@ __export(index_exports, {
   memoryRelationship: () => memoryRelationship,
   memoryRelationshipsResponse: () => memoryRelationshipsResponse,
   mergeCommunitiesRequest: () => mergeCommunitiesRequest,
+  namedMemoryHistoryResponse: () => namedMemoryHistoryResponse,
   narrativeMemory: () => narrativeMemory,
   narrativeThread: () => narrativeThread,
   narrativeTimelineResponse: () => narrativeTimelineResponse,
@@ -99,6 +100,7 @@ __export(index_exports, {
   updateArtifactRequest: () => updateArtifactRequest,
   updateFactRequest: () => updateFactRequest,
   updateMemoryRequest: () => updateMemoryRequest,
+  updateNamedMemoryRequest: () => updateNamedMemoryRequest,
   updateNarrativeRequest: () => updateNarrativeRequest,
   user: () => user,
   userUsage: () => userUsage
@@ -2421,6 +2423,110 @@ var MemoriesService = class extends BaseService {
     }
     return this.client.call(request);
   }
+  /**
+     * Get version history for a named memory
+     * Returns the full version chain for a named memory, ordered newest-first.
+  Walks the SUPERSEDES chain from HEAD backwards.
+  
+     * @param name - Memory name (kebab-case, 2-64 chars)
+     */
+  async getNamedMemoryHistory(name) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "GET",
+      path: "/api/memories/named/{name}/history",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    request.addPathParam("name", {
+      key: "name",
+      value: name,
+      explode: false,
+      encode: true,
+      style: "simple",
+      isLimit: false,
+      isOffset: false,
+      isCursor: false
+    });
+    return this.client.call(request);
+  }
+  /**
+     * 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}.
+  
+     * @param name - Memory name (kebab-case, 2-64 chars)
+     */
+  async getMemoryByName(name) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "GET",
+      path: "/api/memories/named/{name}",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    request.addPathParam("name", {
+      key: "name",
+      value: name,
+      explode: false,
+      encode: true,
+      style: "simple",
+      isLimit: false,
+      isOffset: false,
+      isCursor: false
+    });
+    return this.client.call(request);
+  }
+  /**
+     * Update a named memory (create new version)
+     * Creates a new version of a named memory. The name pointer moves to the new version,
+  and a SUPERSEDES relationship links the new version to the old one.
+  The old version's effectiveState becomes 'superseded'.
+  
+     * @param name - Memory name (kebab-case, 2-64 chars)
+     * @param body - Request body
+     */
+  async updateNamedMemory(name, body) {
+    const request = new Request({
+      baseUrl: this.config.baseUrl || "http://localhost:3000",
+      method: "PUT",
+      path: "/api/memories/named/{name}",
+      config: this.config,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+        maxDelayMs: 5e3,
+        jitterMs: 50,
+        backoffFactor: 2
+      }
+    });
+    request.addPathParam("name", {
+      key: "name",
+      value: name,
+      explode: false,
+      encode: true,
+      style: "simple",
+      isLimit: false,
+      isOffset: false,
+      isCursor: false
+    });
+    if (body !== void 0) {
+      request.addBody(body);
+    }
+    return this.client.call(request);
+  }
   /**
      * Find similar memories
      * Find memories that are semantically similar to the given memory.
@@ -4130,6 +4236,10 @@ var pagination = import_zod.z.object({
 var memory = import_zod.z.object({
   /** Unique memory identifier */
   id: import_zod.z.string(),
+  /** Optional human-readable name for deterministic retrieval. Only the HEAD version carries the name. */
+  name: import_zod.z.string().regex(/^[a-z0-9][a-z0-9-]{0,62}[a-z0-9]$/).optional(),
+  /** Version number for named memories (1 for first version, increments on update) */
+  version: import_zod.z.number().min(1).optional(),
   /** Memory content */
   content: import_zod.z.string(),
   /** Type of memory */
@@ -4183,6 +4293,8 @@ var memory = import_zod.z.object({
 var createMemoryRequest = import_zod.z.object({
   /** Conversation ID - use "NEW" to create a new conversation or provide existing conversation ID */
   conversationId: import_zod.z.string().min(1),
+  /** Optional human-readable name for deterministic retrieval. Must be unique per user. */
+  name: import_zod.z.string().regex(/^[a-z0-9][a-z0-9-]{0,62}[a-z0-9]$/).optional(),
   /** Memory content */
   content: import_zod.z.string().min(1),
   /** Type of memory */
@@ -4203,6 +4315,8 @@ var createMemoryRequest = import_zod.z.object({
 var updateMemoryRequest = import_zod.z.object({
   /** Updated memory content */
   content: import_zod.z.string().min(1).optional(),
+  /** Assign or remove a name. Set to a valid name to assign, empty string to remove. */
+  name: import_zod.z.union([import_zod.z.string().regex(/^[a-z0-9][a-z0-9-]{0,62}[a-z0-9]$/), import_zod.z.enum([""])]).optional(),
   /** Updated memory type */
   memoryType: import_zod.z.enum(["episodic", "semantic", "procedural"]).optional(),
   /** Updated context or domain */
@@ -4228,6 +4342,10 @@ var relatedMemoryResult = import_zod.z.object({
   memory: import_zod.z.object({
     /** Unique memory identifier */
     id: import_zod.z.string(),
+    /** Optional human-readable name for deterministic retrieval. Only the HEAD version carries the name. */
+    name: import_zod.z.string().regex(/^[a-z0-9][a-z0-9-]{0,62}[a-z0-9]$/).optional(),
+    /** Version number for named memories (1 for first version, increments on update) */
+    version: import_zod.z.number().min(1).optional(),
     /** Memory content */
     content: import_zod.z.string(),
     /** Type of memory */
@@ -4288,6 +4406,32 @@ var relatedMemoryResult = import_zod.z.object({
 var getMemoryResponse = import_zod.z.lazy(() => import_zod.z.object({
   data: memory
 }));
+var updateNamedMemoryRequest = import_zod.z.object({
+  /** New content for the named memory version */
+  content: import_zod.z.string().min(1),
+  /** Type of memory (defaults to previous version's type) */
+  memoryType: import_zod.z.enum(["episodic", "semantic", "procedural"]).optional(),
+  /** Context or domain */
+  context: import_zod.z.string().optional(),
+  /** Associated topics */
+  topics: import_zod.z.array(import_zod.z.string()).optional()
+});
+var namedMemoryHistoryResponse = import_zod.z.object({
+  /** Human-readable name for deterministic retrieval (kebab-case, 2-64 chars) */
+  name: import_zod.z.string().regex(/^[a-z0-9][a-z0-9-]{0,62}[a-z0-9]$/),
+  versions: import_zod.z.array(import_zod.z.object({
+    /** Version number */
+    version: import_zod.z.number().min(1),
+    /** Memory ID for this version */
+    id: import_zod.z.string(),
+    /** Memory content at this version */
+    content: import_zod.z.string(),
+    /** Effective state — HEAD version is 'current', older versions are 'superseded' */
+    effectiveState: import_zod.z.enum(["current", "superseded", "contradicted"]).optional(),
+    /** When this version was created */
+    createdAt: import_zod.z.string().datetime()
+  }))
+});
 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)
@@ -4477,6 +4621,10 @@ var searchResult = import_zod.z.lazy(() => import_zod.z.object({
   memory: import_zod.z.object({
     /** Unique memory identifier */
     id: import_zod.z.string(),
+    /** Optional human-readable name for deterministic retrieval. Only the HEAD version carries the name. */
+    name: import_zod.z.string().regex(/^[a-z0-9][a-z0-9-]{0,62}[a-z0-9]$/).optional(),
+    /** Version number for named memories (1 for first version, increments on update) */
+    version: import_zod.z.number().min(1).optional(),
     /** Memory content */
     content: import_zod.z.string(),
     /** Type of memory */
@@ -4843,6 +4991,10 @@ var narrativeMemory = import_zod.z.object({
   memory: import_zod.z.object({
     /** Unique memory identifier */
     id: import_zod.z.string(),
+    /** Optional human-readable name for deterministic retrieval. Only the HEAD version carries the name. */
+    name: import_zod.z.string().regex(/^[a-z0-9][a-z0-9-]{0,62}[a-z0-9]$/).optional(),
+    /** Version number for named memories (1 for first version, increments on update) */
+    version: import_zod.z.number().min(1).optional(),
     /** Memory content */
     content: import_zod.z.string(),
     /** Type of memory */
@@ -5276,6 +5428,7 @@ var index_default = Memnexus;
   memoryRelationship,
   memoryRelationshipsResponse,
   mergeCommunitiesRequest,
+  namedMemoryHistoryResponse,
   narrativeMemory,
   narrativeThread,
   narrativeTimelineResponse,
@@ -5295,6 +5448,7 @@ var index_default = Memnexus;
   updateArtifactRequest,
   updateFactRequest,
   updateMemoryRequest,
+  updateNamedMemoryRequest,
   updateNarrativeRequest,
   user,
   userUsage