@batonfx/memory 0.1.0

package/package.json

@@ -0,0 +1,26 @@
+{
+  "$schema": "https://json.schemastore.org/package.json",
+  "name": "@batonfx/memory",
+  "version": "0.1.0",
+  "private": false,
+  "type": "module",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "scripts": {
+    "build": "bun build ./src/index.ts --outdir dist --target bun --format esm",
+    "lint": "bun --cwd ../.. oxlint packages/memory/src packages/memory/test",
+    "test": "bun --cwd ../.. vitest run packages/memory/test --passWithNoTests",
+    "typecheck": "bun tsc --noEmit"
+  },
+  "dependencies": {
+    "@batonfx/core": "0.1.0",
+    "effect": "4.0.0-beta.93"
+  },
+  "devDependencies": {
+    "@effect/vitest": "4.0.0-beta.93",
+    "@types/bun": "1.3.13",
+    "typescript": "5.8.2",
+    "vitest": "4.0.16"
+  }
+}

package/src/index.ts

@@ -0,0 +1,29 @@
+import { Effect, Layer } from "effect"
+import * as Ai from "effect/unstable/ai"
+import { Memory } from "@batonfx/core"
+import * as SemanticRecall from "./semantic-recall"
+import * as VectorStore from "./vector-store"
+import * as WorkingMemory from "./working-memory"
+
+export * as SemanticRecall from "./semantic-recall"
+export * as VectorStore from "./vector-store"
+export * as WorkingMemory from "./working-memory"
+
+/** @experimental */
+export interface CombinedOptions {
+  readonly working?: WorkingMemory.Options
+  readonly semantic?: SemanticRecall.Options
+}
+
+/** @experimental */
+export const combinedLayer = (
+  options: CombinedOptions = {},
+): Layer.Layer<Memory.Memory, never, VectorStore.VectorStore | Ai.EmbeddingModel.EmbeddingModel> =>
+  Layer.effect(
+    Memory.Memory,
+    Effect.gen(function* () {
+      const working = yield* WorkingMemory.make(options.working)
+      const semantic = yield* SemanticRecall.make(options.semantic)
+      return Memory.Memory.of(Memory.merge(working, semantic))
+    }),
+  )

package/src/semantic-recall.ts

@@ -0,0 +1,119 @@
+import { Effect, Layer, Ref } from "effect"
+import * as Ai from "effect/unstable/ai"
+import { Memory } from "@batonfx/core"
+import * as VectorStore from "./vector-store"
+
+/** @experimental */
+export interface Options {
+  readonly limit?: number
+  readonly minScore?: number
+}
+
+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 textPart = (text: string) => Ai.Prompt.makePart("text", { text })
+
+const textFromParts = (parts: ReadonlyArray<Ai.Prompt.Part>): string =>
+  parts
+    .filter((part): part is Ai.Prompt.TextPart => part.type === "text")
+    .map((part) => part.text)
+    .join("")
+
+const userText = (prompt: Ai.Prompt.Prompt): string =>
+  prompt.content
+    .filter((message): message is Ai.Prompt.UserMessage => message.role === "user")
+    .map((message) => textFromParts(message.content))
+    .filter((text) => text.length > 0)
+    .join("\n\n")
+
+const finalExchangeText = (prompt: Ai.Prompt.Prompt): string | undefined => {
+  let assistant: string | undefined
+  let assistantIndex = -1
+  for (let index = prompt.content.length - 1; index >= 0; index -= 1) {
+    const message = prompt.content[index]
+    if (message?.role !== "assistant") continue
+    const text = textFromParts(message.content).trim()
+    if (text.length === 0) continue
+    assistant = text
+    assistantIndex = index
+    break
+  }
+  if (assistant === undefined) return undefined
+  for (let index = assistantIndex - 1; index >= 0; index -= 1) {
+    const message = prompt.content[index]
+    if (message?.role !== "user") continue
+    const text = textFromParts(message.content).trim()
+    if (text.length === 0) continue
+    return `User: ${text}\nAssistant: ${assistant}`
+  }
+  return undefined
+}
+
+const itemFromMatch = (match: VectorStore.Match): Memory.Item => ({
+  id: match.document.id,
+  parts: [textPart(match.document.text)],
+  metadata: { ...match.document.metadata, score: match.score },
+})
+
+/** @experimental */
+export const make = (
+  options: Options = {},
+): Effect.Effect<Memory.Interface, never, VectorStore.VectorStore | Ai.EmbeddingModel.EmbeddingModel> =>
+  Effect.gen(function* () {
+    const store = yield* VectorStore.VectorStore
+    const embeddingModel = yield* Ai.EmbeddingModel.EmbeddingModel
+    const counter = yield* Ref.make(0)
+    const limit = options.limit ?? 5
+
+    return {
+      recall: (input) => {
+        const text = userText(input.prompt)
+        if (text.length === 0) return Effect.succeed([])
+        return embeddingModel.embed(text).pipe(
+          Effect.mapError(memoryError),
+          Effect.flatMap((embedding) =>
+            store
+              .query({
+                key: input.key,
+                embedding: embedding.vector,
+                limit,
+                ...(options.minScore === undefined ? {} : { minScore: options.minScore }),
+              })
+              .pipe(Effect.mapError(memoryError)),
+          ),
+          Effect.map((matches) => matches.map(itemFromMatch)),
+        )
+      },
+      remember: (input) => {
+        if (!input.terminal) return Effect.void
+        const text = finalExchangeText(input.transcript)
+        if (text === undefined) return Effect.void
+        return embeddingModel.embed(text).pipe(
+          Effect.mapError(memoryError),
+          Effect.flatMap((embedding) =>
+            Ref.modify(counter, (current) => [`semantic-${current + 1}`, current + 1]).pipe(
+              Effect.flatMap((id) =>
+                store.upsert([
+                  {
+                    id,
+                    key: input.key,
+                    text,
+                    embedding: embedding.vector,
+                  },
+                ]),
+              ),
+            ),
+          ),
+          Effect.mapError(memoryError),
+        )
+      },
+    }
+  })
+
+/** @experimental */
+export const layer = (
+  options: Options = {},
+): Layer.Layer<Memory.Memory, never, VectorStore.VectorStore | Ai.EmbeddingModel.EmbeddingModel> =>
+  Layer.effect(Memory.Memory, make(options).pipe(Effect.map(Memory.Memory.of)))

package/src/vector-store.ts

@@ -0,0 +1,118 @@
+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 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>
+}
+
+/** @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)
+        }),
+    }),
+  ),
+)
+
+/** @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

@@ -0,0 +1,189 @@
+import { Effect, HashMap, Layer, Ref } from "effect"
+import * as Ai from "effect/unstable/ai"
+import { Memory } from "@batonfx/core"
+
+/** @experimental */
+export interface SummarizeOptions {
+  readonly model: Layer.Layer<Ai.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) => Ai.Prompt.makePart("text", { text })
+
+const textFromParts = (parts: ReadonlyArray<Ai.Prompt.Part>): string =>
+  parts
+    .filter((part): part is Ai.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: Ai.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* Ai.LanguageModel.LanguageModel
+    const response = yield* model.generateText({
+      prompt: renderSummaryPrompt(options.prompt ?? defaultSummaryPrompt, summary, overflow),
+      toolkit: Ai.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))
+          })
+        },
+      }
+    }),
+  )
+
+/** @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

@@ -0,0 +1,55 @@
+import { describe, expect, it } from "@effect/vitest"
+import { Effect, Layer } from "effect"
+import * as Ai 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) => Ai.Prompt.makePart("text", { text })
+const user = (text: string) => Ai.Prompt.makeMessage("user", { content: [textPart(text)] })
+const assistant = (text: string) => Ai.Prompt.makeMessage("assistant", { content: [textPart(text)] })
+const prompt = (...messages: ReadonlyArray<Ai.Prompt.Message>) => Ai.Prompt.fromMessages(messages)
+
+const itemText = (item: Memory.Item): string =>
+  item.parts
+    .filter((part): part is Ai.Prompt.TextPart => part.type === "text")
+    .map((part) => part.text)
+    .join("")
+
+const embeddingLayer = Layer.effect(
+  Ai.EmbeddingModel.EmbeddingModel,
+  Ai.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

@@ -0,0 +1,121 @@
+import { describe, expect, it } from "@effect/vitest"
+import { Effect, Layer } from "effect"
+import * as Ai 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) => Ai.Prompt.makePart("text", { text })
+const user = (text: string) => Ai.Prompt.makeMessage("user", { content: [textPart(text)] })
+const assistant = (text: string) => Ai.Prompt.makeMessage("assistant", { content: [textPart(text)] })
+const prompt = (...messages: ReadonlyArray<Ai.Prompt.Message>) => Ai.Prompt.fromMessages(messages)
+
+const itemText = (item: Memory.Item): string =>
+  item.parts
+    .filter((part): part is Ai.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(
+  Ai.EmbeddingModel.EmbeddingModel,
+  Ai.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("maps embedding failures to MemoryError", () => {
+    const embeddingError = Ai.AiError.make({
+      module: "SemanticRecallTest",
+      method: "embedMany",
+      reason: new Ai.AiError.UnknownError({ description: "embedding failed" }),
+    })
+    const failingEmbedding = Layer.effect(
+      Ai.EmbeddingModel.EmbeddingModel,
+      Ai.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),
+        ),
+      ),
+    )
+  })
+})