@batonfx/memory 0.4.0 → 0.4.1

package/src/vector-store.ts

@@ -1,132 +0,0 @@
-import { Context, Effect, HashMap, Layer, Ref, Schema } from "effect"
-import { Memory } from "@batonfx/core"
-
-/** @experimental */
-export interface Document {
-  readonly id: string
-  readonly key: Memory.Key
-  readonly text: string
-  readonly metadata?: Memory.Metadata
-}
-
-/** @experimental */
-export interface Embedded extends Document {
-  readonly embedding: ReadonlyArray<number>
-}
-
-/** @experimental */
-export interface Match {
-  readonly document: Embedded
-  readonly score: number
-}
-
-/** @experimental */
-export interface Query {
-  readonly key: Memory.Key
-  readonly embedding: ReadonlyArray<number>
-  readonly limit: number
-  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,
-}) {}
-
-/** @experimental */
-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 */
-export class VectorStore extends Context.Service<VectorStore, Interface>()("@batonfx/memory/VectorStore") {}
-
-const storageKey = (key: Memory.Key, id: string): string => JSON.stringify([key.agent, key.subject, id])
-
-const sameKey = (left: Memory.Key, right: Memory.Key): boolean =>
-  left.agent === right.agent && left.subject === right.subject
-
-const validateVector = (label: string, vector: ReadonlyArray<number>): Effect.Effect<void, VectorStoreError> => {
-  const invalid = vector.find((value) => !Number.isFinite(value))
-  return invalid === undefined
-    ? Effect.void
-    : Effect.fail(new VectorStoreError({ message: `${label} contains a non-finite value` }))
-}
-
-const cosine = (left: ReadonlyArray<number>, right: ReadonlyArray<number>): number => {
-  let dot = 0
-  let leftMagnitude = 0
-  let rightMagnitude = 0
-  for (let index = 0; index < left.length; index += 1) {
-    const leftValue = left[index] ?? 0
-    const rightValue = right[index] ?? 0
-    dot += leftValue * rightValue
-    leftMagnitude += leftValue * leftValue
-    rightMagnitude += rightValue * rightValue
-  }
-  if (leftMagnitude === 0 || rightMagnitude === 0) return 0
-  return dot / (Math.sqrt(leftMagnitude) * Math.sqrt(rightMagnitude))
-}
-
-const make = Ref.make(HashMap.empty<string, Embedded>()).pipe(
-  Effect.map(
-    (documents): Interface => ({
-      upsert: (nextDocuments) =>
-        Effect.gen(function* () {
-          for (const document of nextDocuments) {
-            yield* validateVector(`document ${document.id} embedding`, document.embedding)
-          }
-          yield* Ref.update(documents, (current) => {
-            let next = current
-            for (const document of nextDocuments) {
-              next = HashMap.set(next, storageKey(document.key, document.id), document)
-            }
-            return next
-          })
-        }),
-      query: (input) =>
-        Effect.gen(function* () {
-          if (input.limit <= 0) return []
-          yield* validateVector("query embedding", input.embedding)
-          const current = yield* Ref.get(documents)
-          const matches: Array<Match> = []
-          for (const [, document] of current) {
-            if (!sameKey(document.key, input.key)) continue
-            if (document.embedding.length !== input.embedding.length) {
-              return yield* Effect.fail(
-                new VectorStoreError({
-                  message: `document ${document.id} embedding dimension ${document.embedding.length} does not match query dimension ${input.embedding.length}`,
-                }),
-              )
-            }
-            const score = cosine(document.embedding, input.embedding)
-            if (input.minScore !== undefined && score < input.minScore) continue
-            matches.push({ document, score })
-          }
-          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
-          }),
-        ),
-    }),
-  ),
-)
-
-/** @experimental */
-export const memoryLayer: Layer.Layer<VectorStore> = Layer.effect(VectorStore, make.pipe(Effect.map(VectorStore.of)))
-
-/** @experimental */
-export const testLayer = (implementation: Interface): Layer.Layer<VectorStore> =>
-  Layer.succeed(VectorStore, VectorStore.of(implementation))

package/src/working-memory.ts

@@ -1,208 +0,0 @@
-import { Effect, HashMap, Layer, Ref } from "effect"
-import { LanguageModel, Prompt, Toolkit } from "effect/unstable/ai"
-import { Memory } from "@batonfx/core"
-
-/** @experimental */
-export interface SummarizeOptions {
-  readonly model: Layer.Layer<LanguageModel.LanguageModel>
-  readonly prompt?: string
-}
-
-/** @experimental */
-export interface Options {
-  readonly maxMessages?: number
-  readonly summarize?: SummarizeOptions
-}
-
-type StoredRole = "user" | "assistant"
-
-interface IncomingItem {
-  readonly role: StoredRole
-  readonly text: string
-}
-
-interface StoredItem extends IncomingItem {
-  readonly id: string
-}
-
-interface KeyState {
-  readonly summary?: string
-  readonly recent: ReadonlyArray<StoredItem>
-  readonly counter: number
-}
-
-const emptyState: KeyState = {
-  recent: [],
-  counter: 0,
-}
-
-const defaultSummaryPrompt = "Summarize the conversation memory while preserving stable user preferences and facts."
-
-const errorMessage = (error: unknown) => (error instanceof Error ? `${error.name}: ${error.message}` : String(error))
-
-const memoryError = (error: unknown): Memory.MemoryError => new Memory.MemoryError({ message: errorMessage(error) })
-
-const keyId = (key: Memory.Key): string => JSON.stringify([key.agent, key.subject])
-
-const textPart = (text: string) => Prompt.makePart("text", { text })
-
-const textFromParts = (parts: ReadonlyArray<Prompt.Part>): string =>
-  parts
-    .filter((part): part is Prompt.TextPart => part.type === "text")
-    .map((part) => part.text)
-    .join("")
-
-const roleLabel = (role: StoredRole): string => (role === "user" ? "User" : "Assistant")
-
-const formatItem = (item: IncomingItem): string => `${roleLabel(item.role)}: ${item.text}`
-
-const normalize = (prompt: Prompt.Prompt): ReadonlyArray<IncomingItem> =>
-  prompt.content.flatMap((message) => {
-    if (message.role !== "user" && message.role !== "assistant") return []
-    const text = textFromParts(message.content).trim()
-    return text.length === 0 ? [] : [{ role: message.role, text }]
-  })
-
-const sameItem = (left: IncomingItem, right: IncomingItem): boolean =>
-  left.role === right.role && left.text === right.text
-
-const appendStart = (recent: ReadonlyArray<StoredItem>, incoming: ReadonlyArray<IncomingItem>): number => {
-  if (recent.length === 0) return 0
-  for (let start = Math.max(0, incoming.length - recent.length); start >= 0; start -= 1) {
-    if (start + recent.length > incoming.length) continue
-    let matches = true
-    for (let offset = 0; offset < recent.length; offset += 1) {
-      const stored = recent[offset]
-      const next = incoming[start + offset]
-      if (stored === undefined || next === undefined || !sameItem(stored, next)) {
-        matches = false
-        break
-      }
-    }
-    if (matches) return start + recent.length
-  }
-  return 0
-}
-
-const trimToWindow = (
-  items: ReadonlyArray<StoredItem>,
-  maxMessages: number,
-): { readonly overflow: ReadonlyArray<StoredItem>; readonly recent: ReadonlyArray<StoredItem> } => {
-  if (items.length <= maxMessages) return { overflow: [], recent: items }
-  if (maxMessages === 0) return { overflow: items, recent: [] }
-  return {
-    overflow: items.slice(0, items.length - maxMessages),
-    recent: items.slice(-maxMessages),
-  }
-}
-
-const renderSummaryPrompt = (
-  prompt: string,
-  summary: string | undefined,
-  overflow: ReadonlyArray<StoredItem>,
-): string =>
-  [
-    prompt,
-    ...(summary === undefined ? [] : [`Existing summary:\n${summary}`]),
-    `New messages:\n${overflow.map(formatItem).join("\n")}`,
-    "Return only the updated summary.",
-  ].join("\n\n")
-
-const summarizeOverflow = (
-  options: SummarizeOptions,
-  summary: string | undefined,
-  overflow: ReadonlyArray<StoredItem>,
-): Effect.Effect<string | undefined, Memory.MemoryError> =>
-  Effect.gen(function* () {
-    const model = yield* LanguageModel.LanguageModel
-    const response = yield* model.generateText({
-      prompt: renderSummaryPrompt(options.prompt ?? defaultSummaryPrompt, summary, overflow),
-      toolkit: Toolkit.empty,
-      toolChoice: "none",
-    })
-    const text = response.text.trim()
-    return text.length === 0 ? summary : text
-  }).pipe(Effect.provide(options.model), Effect.mapError(memoryError))
-
-const recallItems = (state: KeyState): ReadonlyArray<Memory.Item> => [
-  ...(state.summary === undefined
-    ? []
-    : [
-        {
-          id: "working-summary",
-          parts: [textPart(`<working-memory-summary>\n${state.summary}\n</working-memory-summary>`)],
-        },
-      ]),
-  ...state.recent.map((item) => ({ id: item.id, parts: [textPart(formatItem(item))] })),
-]
-
-/** @experimental */
-export const make = (options: Options = {}): Effect.Effect<Memory.Interface> =>
-  Ref.make(HashMap.empty<string, KeyState>()).pipe(
-    Effect.map((states): Memory.Interface => {
-      const maxMessages = Math.max(0, Math.floor(options.maxMessages ?? 20))
-      return {
-        recall: (input) =>
-          Ref.get(states).pipe(
-            Effect.map((current) => HashMap.get(current, keyId(input.key))),
-            Effect.map((state) => (state._tag === "Some" ? recallItems(state.value) : [])),
-          ),
-        remember: (input) => {
-          const incoming = normalize(input.transcript)
-          if (incoming.length === 0) return Effect.void
-          return Effect.gen(function* () {
-            const current = yield* Ref.get(states)
-            const id = keyId(input.key)
-            const existing = HashMap.get(current, id).pipe((option) =>
-              option._tag === "Some" ? option.value : emptyState,
-            )
-            const start = appendStart(existing.recent, incoming)
-            const appended = incoming.slice(start)
-            if (appended.length === 0) return
-            let counter = existing.counter
-            const stored = appended.map((item) => {
-              counter += 1
-              return { id: `working-${counter}`, role: item.role, text: item.text }
-            })
-            const combined = [...existing.recent, ...stored]
-            const trimmed = trimToWindow(combined, maxMessages)
-            const summary =
-              trimmed.overflow.length === 0
-                ? existing.summary
-                : options.summarize === undefined
-                  ? existing.summary
-                  : yield* summarizeOverflow(options.summarize, existing.summary, trimmed.overflow)
-            const nextState: KeyState = {
-              recent: trimmed.recent,
-              counter,
-              ...(summary === undefined ? {} : { summary }),
-            }
-            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)
-          }),
-      }
-    }),
-  )
-
-/** @experimental */
-export const makeWorkingMemory = make
-
-/** @experimental */
-export const layer = (options: Options = {}): Layer.Layer<Memory.Memory> =>
-  Layer.effect(Memory.Memory, make(options).pipe(Effect.map(Memory.Memory.of)))

package/test/index.test.ts

@@ -1,55 +0,0 @@
-import { describe, expect, it } from "@effect/vitest"
-import { Effect, Layer } from "effect"
-import { EmbeddingModel, Prompt } from "effect/unstable/ai"
-import { Memory } from "@batonfx/core"
-import { combinedLayer, VectorStore } from "../src/index"
-
-const key: Memory.Key = { agent: "memory-agent", subject: "subject-a" }
-
-const textPart = (text: string) => Prompt.makePart("text", { text })
-const user = (text: string) => Prompt.makeMessage("user", { content: [textPart(text)] })
-const assistant = (text: string) => Prompt.makeMessage("assistant", { content: [textPart(text)] })
-const prompt = (...messages: ReadonlyArray<Prompt.Message>) => Prompt.fromMessages(messages)
-
-const itemText = (item: Memory.Item): string =>
-  item.parts
-    .filter((part): part is Prompt.TextPart => part.type === "text")
-    .map((part) => part.text)
-    .join("")
-
-const embeddingLayer = Layer.effect(
-  EmbeddingModel.EmbeddingModel,
-  EmbeddingModel.make({
-    embedMany: ({ inputs }) =>
-      Effect.succeed({
-        results: inputs.map(() => [1, 0]),
-        usage: { inputTokens: undefined },
-      }),
-  }),
-)
-
-describe("@batonfx/memory", () => {
-  it.effect("combinedLayer recalls working memory before semantic matches", () =>
-    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")),
-      })
-
-      const recalled = yield* memory.recall({ key, turn: 0, prompt: prompt(user("color")) })
-
-      expect(recalled.map(itemText)).toEqual(["Assistant: blue", "User: What color is the sky?\nAssistant: blue"])
-    }).pipe(
-      Effect.provide(
-        combinedLayer({ working: { maxMessages: 1 }, semantic: { limit: 5 } }).pipe(
-          Layer.provideMerge(VectorStore.memoryLayer),
-          Layer.provideMerge(embeddingLayer),
-        ),
-      ),
-    ),
-  )
-})

package/test/semantic-recall.test.ts

@@ -1,154 +0,0 @@
-import { describe, expect, it } from "@effect/vitest"
-import { Effect, Layer } from "effect"
-import { AiError, EmbeddingModel, Prompt } from "effect/unstable/ai"
-import { Memory } from "@batonfx/core"
-import { SemanticRecall, VectorStore } from "../src/index"
-
-const key: Memory.Key = { agent: "memory-agent", subject: "subject-a" }
-const otherKey: Memory.Key = { agent: "memory-agent", subject: "subject-b" }
-
-const textPart = (text: string) => Prompt.makePart("text", { text })
-const user = (text: string) => Prompt.makeMessage("user", { content: [textPart(text)] })
-const assistant = (text: string) => Prompt.makeMessage("assistant", { content: [textPart(text)] })
-const prompt = (...messages: ReadonlyArray<Prompt.Message>) => Prompt.fromMessages(messages)
-
-const itemText = (item: Memory.Item): string =>
-  item.parts
-    .filter((part): part is Prompt.TextPart => part.type === "text")
-    .map((part) => part.text)
-    .join("")
-
-const vectorForText = (text: string): Array<number> =>
-  text.toLowerCase().includes("color") || text.toLowerCase().includes("blue") ? [1, 0] : [0, 1]
-
-const embeddingLayer = Layer.effect(
-  EmbeddingModel.EmbeddingModel,
-  EmbeddingModel.make({
-    embedMany: ({ inputs }) =>
-      Effect.succeed({
-        results: inputs.map(vectorForText),
-        usage: { inputTokens: undefined },
-      }),
-  }),
-)
-
-const memoryLayer = SemanticRecall.layer({ limit: 5 }).pipe(
-  Layer.provideMerge(VectorStore.memoryLayer),
-  Layer.provideMerge(embeddingLayer),
-)
-
-describe("SemanticRecall", () => {
-  it.effect("remembers a terminal user and assistant exchange for later recall", () =>
-    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")),
-      })
-
-      const recalled = yield* memory.recall({ key, turn: 0, prompt: prompt(user("color")) })
-
-      expect(recalled).toHaveLength(1)
-      expect(itemText(recalled[0]!)).toContain("User: What color is the sky?")
-      expect(itemText(recalled[0]!)).toContain("Assistant: blue")
-    }).pipe(Effect.provide(memoryLayer)),
-  )
-
-  it.effect("does not upsert nonterminal turns", () =>
-    Effect.gen(function* () {
-      const memory = yield* Memory.Memory
-
-      yield* memory.remember({
-        key,
-        turn: 0,
-        terminal: false,
-        transcript: prompt(user("What color is the sky?"), assistant("blue")),
-      })
-
-      const recalled = yield* memory.recall({ key, turn: 0, prompt: prompt(user("color")) })
-
-      expect(recalled).toEqual([])
-    }).pipe(Effect.provide(memoryLayer)),
-  )
-
-  it.effect("isolates recall by 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")),
-      })
-
-      const recalled = yield* memory.recall({ key: otherKey, turn: 0, prompt: prompt(user("color")) })
-
-      expect(recalled).toEqual([])
-    }).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",
-      method: "embedMany",
-      reason: new AiError.UnknownError({ description: "embedding failed" }),
-    })
-    const failingEmbedding = Layer.effect(
-      EmbeddingModel.EmbeddingModel,
-      EmbeddingModel.make({ embedMany: () => Effect.fail(embeddingError) }),
-    )
-
-    return Effect.gen(function* () {
-      const memory = yield* Memory.Memory
-
-      const failure = yield* Effect.flip(memory.recall({ key, turn: 0, prompt: prompt(user("color")) }))
-
-      expect(failure._tag).toBe("@batonfx/core/MemoryError")
-      expect(failure.message).toContain("embedding failed")
-    }).pipe(
-      Effect.provide(
-        SemanticRecall.layer({ limit: 5 }).pipe(
-          Layer.provideMerge(VectorStore.memoryLayer),
-          Layer.provideMerge(failingEmbedding),
-        ),
-      ),
-    )
-  })
-})

package/test/vector-store.test.ts

@@ -1,121 +0,0 @@
-import { describe, expect, it } from "@effect/vitest"
-import { Effect } from "effect"
-import { Memory } from "@batonfx/core"
-import { VectorStore } from "../src/index"
-
-const key: Memory.Key = { agent: "agent-a", subject: "subject-a" }
-const otherSubject: Memory.Key = { agent: "agent-a", subject: "subject-b" }
-const otherAgent: Memory.Key = { agent: "agent-b", subject: "subject-a" }
-
-const document = (
-  id: string,
-  memoryKey: Memory.Key,
-  text: string,
-  embedding: ReadonlyArray<number>,
-): VectorStore.Embedded => ({
-  id,
-  key: memoryKey,
-  text,
-  embedding,
-})
-
-describe("VectorStore", () => {
-  it.effect("ranks matching-key documents by cosine score", () =>
-    Effect.gen(function* () {
-      const store = yield* VectorStore.VectorStore
-
-      yield* store.upsert([
-        document("near", key, "near", [1, 0]),
-        document("far", key, "far", [0, 1]),
-        document("also-near", key, "also-near", [0.8, 0.2]),
-      ])
-
-      const matches = yield* store.query({ key, embedding: [1, 0], limit: 2 })
-
-      expect(matches.map((match) => match.document.text)).toEqual(["near", "also-near"])
-      expect(matches[0]?.score).toBeGreaterThan(matches[1]?.score ?? 0)
-    }).pipe(Effect.provide(VectorStore.memoryLayer)),
-  )
-
-  it.effect("enforces exact agent and subject key isolation", () =>
-    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]),
-        document("same-id", otherAgent, "other agent", [1, 0]),
-      ])
-
-      const matches = yield* store.query({ key, embedding: [1, 0], limit: 10 })
-
-      expect(matches.map((match) => match.document.text)).toEqual(["visible"])
-    }).pipe(Effect.provide(VectorStore.memoryLayer)),
-  )
-
-  it.effect("applies limit and minScore", () =>
-    Effect.gen(function* () {
-      const store = yield* VectorStore.VectorStore
-
-      yield* store.upsert([document("near", key, "near", [1, 0]), document("also-near", key, "also-near", [0.8, 0.2])])
-
-      const limited = yield* store.query({ key, embedding: [1, 0], limit: 1 })
-      const thresholded = yield* store.query({ key, embedding: [1, 0], limit: 10, minScore: 0.99 })
-
-      expect(limited.map((match) => match.document.text)).toEqual(["near"])
-      expect(thresholded.map((match) => match.document.text)).toEqual(["near"])
-    }).pipe(Effect.provide(VectorStore.memoryLayer)),
-  )
-
-  it.effect("fails loudly on matching-key dimension mismatch", () =>
-    Effect.gen(function* () {
-      const store = yield* VectorStore.VectorStore
-
-      yield* store.upsert([document("bad", key, "bad", [1, 0, 0])])
-
-      const failure = yield* Effect.flip(store.query({ key, embedding: [1, 0], limit: 1 }))
-
-      expect(failure._tag).toBe("@batonfx/memory/VectorStoreError")
-      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)),
-  )
-})