@batonfx/memory 0.3.2 → 0.3.4

package/.turbo/turbo-build.log

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

package/dist/index.js

@@ -32538,6 +32538,18 @@ var entryFromInput = (input, id2, parentId) => {
   switch (input._tag) {
     case "Message":
       return { ...base2, _tag: "Message", message: input.message };
+    case "ToolCall":
+      return { ...base2, _tag: "ToolCall", part: input.part };
+    case "ToolResult":
+      return { ...base2, _tag: "ToolResult", part: input.part };
+    case "Memory":
+      return { ...base2, _tag: "Memory", items: input.items };
+    case "Skill":
+      return { ...base2, _tag: "Skill", name: input.name, body: input.body };
+    case "Steering":
+      return { ...base2, _tag: "Steering", message: input.message };
+    case "Handoff":
+      return { ...base2, _tag: "Handoff", target: input.target, summary: input.summary };
     case "Compaction":
       return { ...base2, _tag: "Compaction", summary: input.summary, firstKeptEntryId: input.firstKeptEntryId };
     case "BranchSummary":
@@ -32650,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));
@@ -32850,7 +32864,8 @@ 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) => !sameKey(document.key, input.key)))
 })));
 var memoryLayer2 = exports_Layer.effect(VectorStore, make37.pipe(exports_Effect.map(VectorStore.of)));
 var testLayer2 = (implementation) => exports_Layer.succeed(VectorStore, VectorStore.of(implementation));
@@ -32927,7 +32942,8 @@ var make38 = (options = {}) => exports_Effect.gen(function* () {
           embedding: embedding.vector
         }
       ])))), exports_Effect.mapError(memoryError));
-    }
+    },
+    forget: (input) => store.delete({ key: input.key }).pipe(exports_Effect.mapError(memoryError))
   };
 });
 var makeSemanticRecall = make38;
@@ -33052,7 +33068,8 @@ 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)))
   };
 }));
 var makeWorkingMemory = make39;

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@batonfx/memory",
-  "version": "0.3.2",
+  "version": "0.3.4",
   "private": false,
   "type": "module",
   "exports": {
@@ -14,7 +14,7 @@
     "typecheck": "bun tsc --noEmit"
   },
   "dependencies": {
-    "@batonfx/core": "0.3.2",
+    "@batonfx/core": "0.3.4",
     "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({ key: input.key }).pipe(Effect.mapError(memoryError)),
     }
   })
 

package/src/vector-store.ts

@@ -28,6 +28,11 @@ export interface Query {
   readonly minScore?: number
 }
 
+/** @experimental */
+export interface DeleteInput {
+  readonly key: Memory.Key
+}
+
 /** @experimental */
 export class VectorStoreError extends Schema.TaggedErrorClass<VectorStoreError>()("@batonfx/memory/VectorStoreError", {
   message: Schema.String,
@@ -37,6 +42,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 +112,8 @@ 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))),
     }),
   ),
 )

package/src/working-memory.ts

@@ -180,6 +180,7 @@ 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))),
       }
     }),
   )

package/test/vector-store.test.ts

@@ -79,4 +79,23 @@ 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)),
+  )
 })

package/test/working-memory.test.ts

@@ -98,4 +98,31 @@ 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 }))),
+  )
 })