@batonfx/memory 0.3.4 → 0.3.5

package/.turbo/turbo-build.log

@@ -1,5 +1,5 @@
 $ bun build ./src/index.ts --outdir dist --target bun --format esm
-Bundled 176 modules in 523ms
+Bundled 176 modules in 390ms
 
   index.js  1.1 MB  (entry point)
 

package/dist/index.js

@@ -32865,7 +32865,11 @@ var make37 = exports_Ref.make(exports_HashMap.empty()).pipe(exports_Effect.map((
     }
     return matches.toSorted((left, right) => right.score - left.score).slice(0, input.limit);
   }),
-  delete: (input) => exports_Ref.update(documents, (current) => exports_HashMap.filter(current, (document) => !sameKey(document.key, input.key)))
+  delete: (input) => exports_Ref.update(documents, (current) => exports_HashMap.filter(current, (document) => {
+    if (!sameKey(document.key, input.key))
+      return true;
+    return input.id === undefined ? false : document.id !== input.id;
+  }))
 })));
 var memoryLayer2 = exports_Layer.effect(VectorStore, make37.pipe(exports_Effect.map(VectorStore.of)));
 var testLayer2 = (implementation) => exports_Layer.succeed(VectorStore, VectorStore.of(implementation));
@@ -32943,7 +32947,7 @@ var make38 = (options = {}) => exports_Effect.gen(function* () {
         }
       ])))), exports_Effect.mapError(memoryError));
     },
-    forget: (input) => store.delete({ key: input.key }).pipe(exports_Effect.mapError(memoryError))
+    forget: (input) => store.delete(input).pipe(exports_Effect.mapError(memoryError))
   };
 });
 var makeSemanticRecall = make38;
@@ -33069,7 +33073,24 @@ var make39 = (options = {}) => exports_Ref.make(exports_HashMap.empty()).pipe(ex
         yield* exports_Ref.update(states, exports_HashMap.set(id2, nextState));
       });
     },
-    forget: (input) => exports_Ref.update(states, exports_HashMap.remove(keyId(input.key)))
+    forget: (input) => exports_Ref.update(states, (current) => {
+      const id2 = keyId(input.key);
+      if (input.id === undefined)
+        return exports_HashMap.remove(current, id2);
+      const existing = exports_HashMap.get(current, id2);
+      if (existing._tag === "None")
+        return current;
+      const summary = input.id === "working-summary" ? undefined : existing.value.summary;
+      const recent = existing.value.recent.filter((item) => item.id !== input.id);
+      if (summary === undefined && recent.length === 0)
+        return exports_HashMap.remove(current, id2);
+      const nextState = {
+        recent,
+        counter: existing.value.counter,
+        ...summary === undefined ? {} : { summary }
+      };
+      return exports_HashMap.set(current, id2, nextState);
+    })
   };
 }));
 var makeWorkingMemory = make39;

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@batonfx/memory",
-  "version": "0.3.4",
+  "version": "0.3.5",
   "private": false,
   "type": "module",
   "exports": {
@@ -14,7 +14,7 @@
     "typecheck": "bun tsc --noEmit"
   },
   "dependencies": {
-    "@batonfx/core": "0.3.4",
+    "@batonfx/core": "0.3.5",
     "effect": "4.0.0-beta.93"
   },
   "devDependencies": {

package/src/semantic-recall.ts

@@ -109,7 +109,7 @@ export const make = (
           Effect.mapError(memoryError),
         )
       },
-      forget: (input) => store.delete({ key: input.key }).pipe(Effect.mapError(memoryError)),
+      forget: (input) => store.delete(input).pipe(Effect.mapError(memoryError)),
     }
   })
 

package/src/vector-store.ts

@@ -31,6 +31,7 @@ export interface Query {
 /** @experimental */
 export interface DeleteInput {
   readonly key: Memory.Key
+  readonly id?: string | undefined
 }
 
 /** @experimental */
@@ -113,7 +114,12 @@ const make = Ref.make(HashMap.empty<string, Embedded>()).pipe(
           return matches.toSorted((left, right) => right.score - left.score).slice(0, input.limit)
         }),
       delete: (input) =>
-        Ref.update(documents, (current) => HashMap.filter(current, (document) => !sameKey(document.key, input.key))),
+        Ref.update(documents, (current) =>
+          HashMap.filter(current, (document) => {
+            if (!sameKey(document.key, input.key)) return true
+            return input.id === undefined ? false : document.id !== input.id
+          }),
+        ),
     }),
   ),
 )

package/src/working-memory.ts

@@ -180,7 +180,22 @@ export const make = (options: Options = {}): Effect.Effect<Memory.Interface> =>
             yield* Ref.update(states, HashMap.set(id, nextState))
           })
         },
-        forget: (input) => Ref.update(states, HashMap.remove(keyId(input.key))),
+        forget: (input) =>
+          Ref.update(states, (current) => {
+            const id = keyId(input.key)
+            if (input.id === undefined) return HashMap.remove(current, id)
+            const existing = HashMap.get(current, id)
+            if (existing._tag === "None") return current
+            const summary = input.id === "working-summary" ? undefined : existing.value.summary
+            const recent = existing.value.recent.filter((item) => item.id !== input.id)
+            if (summary === undefined && recent.length === 0) return HashMap.remove(current, id)
+            const nextState: KeyState = {
+              recent,
+              counter: existing.value.counter,
+              ...(summary === undefined ? {} : { summary }),
+            }
+            return HashMap.set(current, id, nextState)
+          }),
       }
     }),
   )

package/test/semantic-recall.test.ts

@@ -91,6 +91,39 @@ describe("SemanticRecall", () => {
     }).pipe(Effect.provide(memoryLayer)),
   )
 
+  it.effect("forgets one semantic memory id within the exact memory key", () =>
+    Effect.gen(function* () {
+      const memory = yield* Memory.Memory
+
+      yield* memory.remember({
+        key,
+        turn: 0,
+        terminal: true,
+        transcript: prompt(user("What color is the sky?"), assistant("blue")),
+      })
+      yield* memory.remember({
+        key,
+        turn: 1,
+        terminal: true,
+        transcript: prompt(user("What color is the ocean?"), assistant("blue")),
+      })
+      yield* memory.remember({
+        key: otherKey,
+        turn: 0,
+        terminal: true,
+        transcript: prompt(user("What color is the door?"), assistant("blue")),
+      })
+
+      yield* memory.forget({ key, id: "semantic-1" })
+
+      const retained = yield* memory.recall({ key, turn: 0, prompt: prompt(user("color")) })
+      const otherRetained = yield* memory.recall({ key: otherKey, turn: 0, prompt: prompt(user("color")) })
+
+      expect(retained.map(itemText)).toEqual(["User: What color is the ocean?\nAssistant: blue"])
+      expect(otherRetained.map(itemText)).toEqual(["User: What color is the door?\nAssistant: blue"])
+    }).pipe(Effect.provide(memoryLayer)),
+  )
+
   it.effect("maps embedding failures to MemoryError", () => {
     const embeddingError = AiError.make({
       module: "SemanticRecallTest",

package/test/vector-store.test.ts

@@ -98,4 +98,24 @@ describe("VectorStore", () => {
       expect(remainingMatches.map((match) => match.document.text)).toEqual(["other subject"])
     }).pipe(Effect.provide(VectorStore.memoryLayer)),
   )
+
+  it.effect("deletes one document id within the exact memory key", () =>
+    Effect.gen(function* () {
+      const store = yield* VectorStore.VectorStore
+
+      yield* store.upsert([
+        document("first", key, "first", [1, 0]),
+        document("second", key, "second", [0, 1]),
+        document("first", otherSubject, "other subject", [1, 0]),
+      ])
+
+      yield* store.delete({ key, id: "first" })
+
+      const deletedKeyMatches = yield* store.query({ key, embedding: [1, 0], limit: 10 })
+      const otherSubjectMatches = yield* store.query({ key: otherSubject, embedding: [1, 0], limit: 10 })
+
+      expect(deletedKeyMatches.map((match) => match.document.text)).toEqual(["second"])
+      expect(otherSubjectMatches.map((match) => match.document.text)).toEqual(["other subject"])
+    }).pipe(Effect.provide(VectorStore.memoryLayer)),
+  )
 })

package/test/working-memory.test.ts

@@ -125,4 +125,31 @@ describe("WorkingMemory", () => {
       expect(retained.map(itemText)).toEqual(["User: three", "Assistant: four"])
     }).pipe(Effect.provide(WorkingMemory.layer({ maxMessages: 2 }))),
   )
+
+  it.effect("forgets one recalled item id within the exact memory key", () =>
+    Effect.gen(function* () {
+      const memory = yield* Memory.Memory
+
+      yield* memory.remember({
+        key,
+        turn: 0,
+        terminal: true,
+        transcript: prompt(user("one"), assistant("two")),
+      })
+      yield* memory.remember({
+        key: otherKey,
+        turn: 0,
+        terminal: true,
+        transcript: prompt(user("three"), assistant("four")),
+      })
+
+      yield* memory.forget({ key, id: "working-1" })
+
+      const retained = yield* memory.recall({ key, turn: 0, prompt: prompt(user("current")) })
+      const otherRetained = yield* memory.recall({ key: otherKey, turn: 0, prompt: prompt(user("current")) })
+
+      expect(retained.map(itemText)).toEqual(["Assistant: two"])
+      expect(otherRetained.map(itemText)).toEqual(["User: three", "Assistant: four"])
+    }).pipe(Effect.provide(WorkingMemory.layer({ maxMessages: 2 }))),
+  )
 })