@batonfx/memory 0.3.3 → 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 529ms
+Bundled 176 modules in 390ms
 
   index.js  1.1 MB  (entry point)
 

package/dist/index.js

@@ -32662,11 +32662,13 @@ class Memory extends exports_Context.Service()("@batonfx/core/Memory") {
 }
 var noop = {
   recall: () => exports_Effect.succeed([]),
-  remember: () => exports_Effect.void
+  remember: () => exports_Effect.void,
+  forget: () => exports_Effect.void
 };
 var merge6 = (first, second) => ({
   recall: (input) => exports_Effect.all([first.recall(input), second.recall(input)]).pipe(exports_Effect.map(([firstItems, secondItems]) => [...firstItems, ...secondItems])),
-  remember: (input) => exports_Effect.all([first.remember(input), second.remember(input)], { discard: true })
+  remember: (input) => exports_Effect.all([first.remember(input), second.remember(input)], { discard: true }),
+  forget: (input) => exports_Effect.all([first.forget(input), second.forget(input)], { discard: true })
 });
 var noopLayer = exports_Layer.succeed(Memory, Memory.of(noop));
 var testLayer = (implementation) => exports_Layer.succeed(Memory, Memory.of(implementation));
@@ -32862,7 +32864,12 @@ var make37 = exports_Ref.make(exports_HashMap.empty()).pipe(exports_Effect.map((
       matches.push({ document, score });
     }
     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) => {
+    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));
@@ -32939,7 +32946,8 @@ var make38 = (options = {}) => exports_Effect.gen(function* () {
           embedding: embedding.vector
         }
       ])))), exports_Effect.mapError(memoryError));
-    }
+    },
+    forget: (input) => store.delete(input).pipe(exports_Effect.mapError(memoryError))
   };
 });
 var makeSemanticRecall = make38;
@@ -33064,7 +33072,25 @@ 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, (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.3",
+  "version": "0.3.5",
   "private": false,
   "type": "module",
   "exports": {
@@ -14,7 +14,7 @@
     "typecheck": "bun tsc --noEmit"
   },
   "dependencies": {
-    "@batonfx/core": "0.3.3",
+    "@batonfx/core": "0.3.5",
     "effect": "4.0.0-beta.93"
   },
   "devDependencies": {

package/src/semantic-recall.ts

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

package/src/vector-store.ts

@@ -28,6 +28,12 @@ export interface Query {
   readonly minScore?: number
 }
 
+/** @experimental */
+export interface DeleteInput {
+  readonly key: Memory.Key
+  readonly id?: string | undefined
+}
+
 /** @experimental */
 export class VectorStoreError extends Schema.TaggedErrorClass<VectorStoreError>()("@batonfx/memory/VectorStoreError", {
   message: Schema.String,
@@ -37,6 +43,7 @@ export class VectorStoreError extends Schema.TaggedErrorClass<VectorStoreError>(
 export interface Interface {
   readonly upsert: (documents: ReadonlyArray<Embedded>) => Effect.Effect<void, VectorStoreError>
   readonly query: (query: Query) => Effect.Effect<ReadonlyArray<Match>, VectorStoreError>
+  readonly delete: (input: DeleteInput) => Effect.Effect<void, VectorStoreError>
 }
 
 /** @experimental */
@@ -106,6 +113,13 @@ 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) => {
+            if (!sameKey(document.key, input.key)) return true
+            return input.id === undefined ? false : document.id !== input.id
+          }),
+        ),
     }),
   ),
 )

package/src/working-memory.ts

@@ -180,6 +180,22 @@ export const make = (options: Options = {}): Effect.Effect<Memory.Interface> =>
             yield* Ref.update(states, HashMap.set(id, nextState))
           })
         },
+        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

@@ -79,4 +79,43 @@ describe("VectorStore", () => {
       expect(failure.message).toContain("dimension")
     }).pipe(Effect.provide(VectorStore.memoryLayer)),
   )
+
+  it.effect("deletes documents for the exact memory key", () =>
+    Effect.gen(function* () {
+      const store = yield* VectorStore.VectorStore
+
+      yield* store.upsert([
+        document("same-id", key, "visible", [1, 0]),
+        document("same-id", otherSubject, "other subject", [1, 0]),
+      ])
+
+      yield* store.delete({ key })
+
+      const deletedMatches = yield* store.query({ key, embedding: [1, 0], limit: 10 })
+      const remainingMatches = yield* store.query({ key: otherSubject, embedding: [1, 0], limit: 10 })
+
+      expect(deletedMatches).toEqual([])
+      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

@@ -98,4 +98,58 @@ describe("WorkingMemory", () => {
       expect(recalled).toEqual([])
     }).pipe(Effect.provide(WorkingMemory.layer({ maxMessages: 2 }))),
   )
+
+  it.effect("forgets 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 })
+
+      const forgotten = yield* memory.recall({ key, turn: 0, prompt: prompt(user("current")) })
+      const retained = yield* memory.recall({ key: otherKey, turn: 0, prompt: prompt(user("current")) })
+
+      expect(forgotten).toEqual([])
+      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 }))),
+  )
 })