@lota-sdk/core 0.4.9 → 0.4.11

package/src/db/memory.ts

@@ -1,4 +1,5 @@
-import { Schema, Effect } from 'effect'
+import type { Context } from 'effect'
+import { Effect } from 'effect'
 import type { z } from 'zod'
 
 import { aiLogger } from '../config/logger'
@@ -15,6 +16,8 @@ import { getFactRetrievalMessages } from '../runtime/memory/memory-prompts-fact'
 import { parseMessages } from '../runtime/memory/memory-prompts-parse'
 import { getClassifyMemoryDeltaPrompt } from '../runtime/memory/memory-prompts-update'
 import type { ResolvedLotaRuntimeConfig } from '../runtime/runtime-config'
+import type { BackgroundWorkService } from '../services/background-work.service'
+import { MemoryServiceError, tryMemoryPromise } from '../services/memory/memory-errors'
 import { sha256Hex } from '../utils/crypto'
 import { compactWhitespace, truncateText } from '../utils/string'
 import type { SurrealMemoryStore } from './memory-store'
@@ -54,32 +57,6 @@ interface PreparedScopeUpdate {
   existingMemories: Array<{ id: string; text: string }>
 }
 
-class MemoryServiceError extends Schema.TaggedErrorClass<MemoryServiceError>()('MemoryServiceError', {
-  message: Schema.String,
-  cause: Schema.Defect,
-}) {}
-
-function tryMemoryPromise<A, R = never>(
-  message: string,
-  thunk: () => PromiseLike<A> | Effect.Effect<A, unknown, R>,
-): Effect.Effect<A, MemoryServiceError, R> {
-  return Effect.suspend(() => {
-    try {
-      const value = thunk()
-      if (Effect.isEffect(value)) {
-        return value.pipe(Effect.mapError((cause) => new MemoryServiceError({ message, cause })))
-      }
-
-      return Effect.tryPromise({
-        try: () => Promise.resolve(value),
-        catch: (cause) => new MemoryServiceError({ message, cause }),
-      })
-    } catch (cause) {
-      return Effect.fail(new MemoryServiceError({ message, cause }))
-    }
-  })
-}
-
 export class Memory {
   private store: SurrealMemoryStore
   private createAgent: CreateHelperAgentFn
@@ -89,14 +66,23 @@ export class Memory {
   private helperModelRuntime: HelperModelRuntime
 
   constructor(
-    deps: { db: SurrealDBService; runtimeConfig: ResolvedLotaRuntimeConfig; helperModelRuntime: HelperModelRuntime },
+    deps: {
+      db: SurrealDBService
+      runtimeConfig: ResolvedLotaRuntimeConfig
+      helperModelRuntime: HelperModelRuntime
+      background: Context.Service.Shape<typeof BackgroundWorkService>
+    },
     agent: { createAgent: CreateHelperAgentFn; maxOutputTokens?: number },
     config: MemoryConfig = {},
   ) {
-    this.store = createMemoryStore(deps.db, {
-      embeddingModel: deps.runtimeConfig.aiGateway.embeddingModel,
-      openRouterApiKey: deps.runtimeConfig.aiGateway.openRouterApiKey,
-    })
+    this.store = createMemoryStore(
+      deps.db,
+      {
+        embeddingModel: deps.runtimeConfig.aiGateway.embeddingModel,
+        openRouterApiKey: deps.runtimeConfig.aiGateway.openRouterApiKey,
+      },
+      deps.background,
+    )
     this.runtimeConfig = deps.runtimeConfig
     this.helperModelRuntime = deps.helperModelRuntime
     this.createAgent = agent.createAgent
@@ -142,73 +128,77 @@ export class Memory {
   }
 
   search(query: string, options: SearchOptions): Effect.Effect<string, MemoryServiceError, never> {
-    const self = this
-    return Effect.gen(function* () {
-      const limit = options.limit ?? self.runtimeConfig.memory.searchK
-      const results = yield* tryMemoryPromise('Failed to search memory.', () =>
-        self.store.search(query, options.scopeId, limit, options.memoryType),
-      )
-      return formatResults(results)
-    })
+    return Effect.gen(
+      function* (this: Memory) {
+        const limit = options.limit ?? this.runtimeConfig.memory.searchK
+        const results = yield* tryMemoryPromise('Failed to search memory.', () =>
+          this.store.search(query, options.scopeId, limit, options.memoryType),
+        )
+        return formatResults(results)
+      }.bind(this),
+    )
   }
 
   hybridSearch(query: string, options: SearchOptions): Effect.Effect<string, MemoryServiceError, never> {
-    const self = this
-    return Effect.gen(function* () {
-      const limit = options.limit ?? self.runtimeConfig.memory.searchK
-      const results = yield* tryMemoryPromise('Failed to perform hybrid search.', () =>
-        self.store.hybridSearch(query, options.scopeId, limit, options.memoryType),
-      )
-      return formatResults(results)
-    })
+    return Effect.gen(
+      function* (this: Memory) {
+        const limit = options.limit ?? this.runtimeConfig.memory.searchK
+        const results = yield* tryMemoryPromise('Failed to perform hybrid search.', () =>
+          this.store.hybridSearch(query, options.scopeId, limit, options.memoryType),
+        )
+        return formatResults(results)
+      }.bind(this),
+    )
   }
 
   hybridSearchWeighted(
     query: string,
     options: SearchOptions & { weights?: [number, number]; normalization?: 'minmax' | 'zscore' },
   ): Effect.Effect<string, MemoryServiceError, never> {
-    const self = this
-    return Effect.gen(function* () {
-      const limit = options.limit ?? self.runtimeConfig.memory.searchK
-      const results = yield* tryMemoryPromise('Failed to perform weighted hybrid search.', () =>
-        self.store.hybridSearchWeighted(query, {
-          scopeId: options.scopeId,
-          limit,
-          memoryType: options.memoryType,
-          weights: options.weights,
-          normalization: options.normalization,
-        }),
-      )
-      return formatResults(results)
-    })
+    return Effect.gen(
+      function* (this: Memory) {
+        const limit = options.limit ?? this.runtimeConfig.memory.searchK
+        const results = yield* tryMemoryPromise('Failed to perform weighted hybrid search.', () =>
+          this.store.hybridSearchWeighted(query, {
+            scopeId: options.scopeId,
+            limit,
+            memoryType: options.memoryType,
+            weights: options.weights,
+            normalization: options.normalization,
+          }),
+        )
+        return formatResults(results)
+      }.bind(this),
+    )
   }
 
   searchCandidates(
     query: string,
     options: WeightedSearchOptions,
   ): Effect.Effect<MemorySearchResult[], MemoryServiceError, never> {
-    const self = this
-    return Effect.gen(function* () {
-      const limit = options.limit ?? self.runtimeConfig.memory.searchK
-      const results = yield* tryMemoryPromise('Failed to search memory candidates.', () =>
-        self.store.hybridSearchWeighted(query, {
-          scopeId: options.scopeId,
-          limit,
-          memoryType: options.memoryType,
-          weights: options.weights,
-          normalization: options.normalization,
-          fastMode: options.fastMode,
-        }),
-      )
+    return Effect.gen(
+      function* (this: Memory) {
+        const limit = options.limit ?? this.runtimeConfig.memory.searchK
+        const results = yield* tryMemoryPromise('Failed to search memory candidates.', () =>
+          this.store.hybridSearchWeighted(query, {
+            scopeId: options.scopeId,
+            limit,
+            memoryType: options.memoryType,
+            weights: options.weights,
+            normalization: options.normalization,
+            fastMode: options.fastMode,
+          }),
+        )
 
-      if (options.fastMode || options.includeNeighborContext === false) {
-        return results
-      }
+        if (options.fastMode || options.includeNeighborContext === false) {
+          return results
+        }
 
-      return yield* tryMemoryPromise('Failed to enrich memory candidates.', () =>
-        self.store.enrichWithNeighbors(results),
-      )
-    })
+        return yield* tryMemoryPromise('Failed to enrich memory candidates.', () =>
+          this.store.enrichWithNeighbors(results),
+        )
+      }.bind(this),
+    )
   }
 
   listTopMemories(options: {
@@ -248,28 +238,30 @@ export class Memory {
     messages: Message[],
     extractionOptions?: { customPrompt?: string; maxFacts?: number },
   ): Effect.Effect<ExtractedFact[], MemoryServiceError, never> {
-    const self = this
-    return Effect.gen(function* () {
-      if (messages.length === 0) return []
-
-      const parsedMessages = parseMessages(messages)
-      const facts = yield* self.extractFactsEffect(parsedMessages, extractionOptions)
-      if (facts.length === 0) {
-        aiLogger.debug`No facts extracted from conversation`
-        return []
-      }
+    return Effect.gen(
+      function* (this: Memory) {
+        if (messages.length === 0) return []
 
-      return facts
-    })
+        const parsedMessages = parseMessages(messages)
+        const facts = yield* this.extractFactsEffect(parsedMessages, extractionOptions)
+        if (facts.length === 0) {
+          aiLogger.debug`No facts extracted from conversation`
+          return []
+        }
+
+        return facts
+      }.bind(this),
+    )
   }
 
   applyFactsToScopes(facts: ExtractedFact[], scopes: AddOptions[]): Effect.Effect<void, MemoryServiceError, never> {
-    const self = this
-    return Effect.gen(function* () {
-      if (facts.length === 0 || scopes.length === 0) return
-      const prepared = yield* self.prepareFactsToScopesEffect(facts, scopes)
-      yield* self.applyPreparedScopeUpdates(prepared)
-    })
+    return Effect.gen(
+      function* (this: Memory) {
+        if (facts.length === 0 || scopes.length === 0) return
+        const prepared = yield* this.prepareFactsToScopesEffect(facts, scopes)
+        yield* this.applyPreparedScopeUpdates(prepared)
+      }.bind(this),
+    )
   }
 
   prepareFactsToScopes(
@@ -551,105 +543,106 @@ export class Memory {
     factMaps: ReturnType<typeof buildMemoryFactMaps>,
     existingMemories: Array<{ id: string; text: string }>,
   ): Effect.Effect<void, MemoryServiceError, never> {
-    const self = this
-    return Effect.gen(function* () {
-      const plan = createMemoryActionPlan({
-        updates,
-        memoryType: options.memoryType,
-        explicitImportance: options.importance,
-        extractedImportanceByKey: factMaps.extractedImportanceByKey,
-        confidenceByKey: factMaps.confidenceByKey,
-        durabilityByKey: factMaps.durabilityByKey,
-        categoryByKey: factMaps.categoryByKey,
-        existingMemories,
-      })
-
-      const idMap = new Map<string, string>()
-      for (const action of plan.actions) {
-        switch (action.type) {
-          case 'add': {
-            const truncatedContent = truncateText(action.text, 50)
-            const metadata = { ...options.metadata, memoryCategory: action.category }
-            const hash = hashContent(action.text, options.scopeId, options.memoryType)
-
-            const newId = yield* tryMemoryPromise(`Failed to insert memory for scope ${options.scopeId}.`, () =>
-              self.store.insert(
-                action.text,
-                options.scopeId,
-                options.memoryType,
-                metadata,
-                action.importance,
-                action.durability as Durability,
-              ),
-            ).pipe(
-              Effect.catchTag('MemoryServiceError', (error) => {
-                if (!isUniqueIndexConflict(error.cause, 'memoryHashIdx')) {
-                  return Effect.fail(error)
-                }
-
-                return tryMemoryPromise(`Failed to look up memory hash ${hash}.`, () =>
-                  self.store.getByHash(hash),
-                ).pipe(
-                  Effect.flatMap((existing) => {
-                    if (!existing) {
-                      return Effect.fail(error)
-                    }
-
-                    return Effect.sync(() => {
-                      aiLogger.debug`Skipped duplicate memory insert due to hash conflict: ${existing.id}`
-                      return existing.id
-                    })
-                  }),
-                )
-              }),
-            )
+    return Effect.gen(
+      function* (this: Memory) {
+        const plan = createMemoryActionPlan({
+          updates,
+          memoryType: options.memoryType,
+          explicitImportance: options.importance,
+          extractedImportanceByKey: factMaps.extractedImportanceByKey,
+          confidenceByKey: factMaps.confidenceByKey,
+          durabilityByKey: factMaps.durabilityByKey,
+          categoryByKey: factMaps.categoryByKey,
+          existingMemories,
+        })
 
-            idMap.set(action.refId, newId)
-            aiLogger.debug`Added new memory (memoryType: ${options.memoryType}, category: ${action.category}, durability: ${action.durability}, importance: ${action.importance.toFixed(2)}, content: ${truncatedContent})`
-            break
+        const idMap = new Map<string, string>()
+        for (const action of plan.actions) {
+          switch (action.type) {
+            case 'add': {
+              const truncatedContent = truncateText(action.text, 50)
+              const metadata = { ...options.metadata, memoryCategory: action.category }
+              const hash = hashContent(action.text, options.scopeId, options.memoryType)
+
+              const newId = yield* tryMemoryPromise(`Failed to insert memory for scope ${options.scopeId}.`, () =>
+                this.store.insert(
+                  action.text,
+                  options.scopeId,
+                  options.memoryType,
+                  metadata,
+                  action.importance,
+                  action.durability as Durability,
+                ),
+              ).pipe(
+                Effect.catchTag('MemoryServiceError', (error) => {
+                  if (!isUniqueIndexConflict(error.cause, 'memoryHashIdx')) {
+                    return Effect.fail(error)
+                  }
+
+                  return tryMemoryPromise(`Failed to look up memory hash ${hash}.`, () =>
+                    this.store.getByHash(hash),
+                  ).pipe(
+                    Effect.flatMap((existing) => {
+                      if (!existing) {
+                        return Effect.fail(error)
+                      }
+
+                      return Effect.sync(() => {
+                        aiLogger.debug`Skipped duplicate memory insert due to hash conflict: ${existing.id}`
+                        return existing.id
+                      })
+                    }),
+                  )
+                }),
+              )
+
+              idMap.set(action.refId, newId)
+              aiLogger.debug`Added new memory (memoryType: ${options.memoryType}, category: ${action.category}, durability: ${action.durability}, importance: ${action.importance.toFixed(2)}, content: ${truncatedContent})`
+              break
+            }
+
+            case 'update': {
+              const metadata = { ...options.metadata, ...(action.category ? { memoryCategory: action.category } : {}) }
+              yield* tryMemoryPromise(`Failed to update memory ${action.refId}.`, () =>
+                this.store.update(action.refId, action.text, {
+                  importance: action.importance,
+                  durability: action.durability as Durability | undefined,
+                  metadata: Object.keys(metadata).length > 0 ? metadata : undefined,
+                }),
+              )
+              idMap.set(action.refId, action.refId)
+              aiLogger.debug`Updated memory ${action.refId}: ${truncateText(action.text, 50)}`
+              break
+            }
+
+            case 'delete':
+              yield* tryMemoryPromise(`Failed to delete memory ${action.refId}.`, () => this.store.delete(action.refId))
+              aiLogger.debug`Deleted memory ${action.refId}`
+              break
           }
+        }
 
-          case 'update': {
-            const metadata = { ...options.metadata, ...(action.category ? { memoryCategory: action.category } : {}) }
-            yield* tryMemoryPromise(`Failed to update memory ${action.refId}.`, () =>
-              self.store.update(action.refId, action.text, {
-                importance: action.importance,
-                durability: action.durability as Durability | undefined,
-                metadata: Object.keys(metadata).length > 0 ? metadata : undefined,
+        for (const relation of plan.relations) {
+          const fromId = idMap.get(relation.fromRefId)
+          if (!fromId) continue
+
+          const toId = idMap.get(relation.toRefId) ?? relation.toRefId
+          yield* tryMemoryPromise(`Failed to create memory relation ${relation.relation}.`, () =>
+            this.store.addRelation(fromId, toId, relation.relation),
+          ).pipe(
+            Effect.tap(() =>
+              Effect.sync(() => {
+                aiLogger.debug`Created ${relation.relation} relation: ${fromId} -> ${toId}`
               }),
-            )
-            idMap.set(action.refId, action.refId)
-            aiLogger.debug`Updated memory ${action.refId}: ${truncateText(action.text, 50)}`
-            break
-          }
-
-          case 'delete':
-            yield* tryMemoryPromise(`Failed to delete memory ${action.refId}.`, () => self.store.delete(action.refId))
-            aiLogger.debug`Deleted memory ${action.refId}`
-            break
+            ),
+            Effect.catchTag('MemoryServiceError', (error) =>
+              Effect.sync(() => {
+                aiLogger.warn`Failed to create memory relation (non-fatal, graph may be incomplete): ${error.message}`
+              }),
+            ),
+          )
         }
-      }
-
-      for (const relation of plan.relations) {
-        const fromId = idMap.get(relation.fromRefId)
-        if (!fromId) continue
-
-        const toId = idMap.get(relation.toRefId) ?? relation.toRefId
-        yield* tryMemoryPromise(`Failed to create memory relation ${relation.relation}.`, () =>
-          self.store.addRelation(fromId, toId, relation.relation),
-        ).pipe(
-          Effect.tap(() =>
-            Effect.sync(() => {
-              aiLogger.debug`Created ${relation.relation} relation: ${fromId} -> ${toId}`
-            }),
-          ),
-          Effect.catchTag('MemoryServiceError', (error) =>
-            Effect.sync(() => {
-              aiLogger.warn`Failed to create memory relation (non-fatal, graph may be incomplete): ${error.message}`
-            }),
-          ),
-        )
-      }
-    })
+      }.bind(this),
+    )
   }
 }