@lota-sdk/core 0.4.9 → 0.4.10

package/src/db/memory-query-builder.ts

@@ -3,8 +3,9 @@
  * Builds type-safe SQL queries with proper parameterization
  */
 
+import { VECTOR_SEARCH_OVERFETCH_MULTIPLIER } from '@lota-sdk/shared'
+
 import { validateKnnLimit } from '../config/constants'
-import { VECTOR_SEARCH_OVERFETCH_MULTIPLIER } from '../config/search'
 import { TABLES } from './tables'
 
 const MEMORY_TABLE = TABLES.MEMORY

package/src/db/memory-store.ts

@@ -1,9 +1,10 @@
+import type { Context } from 'effect'
 import { Schema, Duration, Effect, Metric, Schedule } from 'effect'
 import { BoundQuery, eq, inside } from 'surrealdb'
 
 import { aiLogger } from '../config/logger'
-import { DEFAULT_MEMORY_SEARCH_LIMIT } from '../config/search'
 import { ProviderEmbeddings } from '../embeddings/provider'
+import type { BackgroundWorkService } from '../services/background-work.service'
 import { clampImportance, truncateText } from '../utils/string'
 import { memoryQueryBuilder } from './memory-query-builder'
 import type { RelationCounts } from './memory-store.helpers'
@@ -24,9 +25,12 @@ import type { SurrealDBError } from './service-normalization'
 import { TABLES } from './tables'
 import { isRetriableTransactionConflict } from './transaction-conflict'
 
+type BackgroundWorker = Context.Service.Shape<typeof BackgroundWorkService>
+
 const MEMORY_TABLE = TABLES.MEMORY
 const MEMORY_HISTORY_TABLE = TABLES.MEMORY_HISTORY
 const MEMORY_RELATION_TABLE = TABLES.MEMORY_RELATION
+const DEFAULT_MEMORY_SEARCH_LIMIT = 10
 const MIN_RELEVANCE_SCORE = 0.25
 const STRONG_GRAPH_BOOSTS = { support: 0.1, contradict: 0.2 } as const
 const WEAK_GRAPH_BOOSTS = { support: 0.05, contradict: 0.1 } as const
@@ -46,13 +50,9 @@ class MemoryStoreError extends Schema.TaggedErrorClass<MemoryStoreError>()('Memo
   cause: Schema.Defect,
 }) {}
 
-function recordMemorySearchDuration(elapsed: number): void {
-  void Effect.runFork(Metric.update(memorySearchDuration, elapsed))
-}
-
-function tryMemoryStorePromise<A, R = never>(
+function tryMemoryStorePromise<A, E, R = never>(
   message: string,
-  thunk: () => PromiseLike<A> | Effect.Effect<A, unknown, R>,
+  thunk: () => PromiseLike<A> | Effect.Effect<A, E, R>,
 ): Effect.Effect<A, MemoryStoreError, R> {
   return Effect.suspend(() => {
     try {
@@ -75,9 +75,15 @@ interface EmbeddingClient {
 export class SurrealMemoryStore {
   private db: SurrealDBService
   private embeddings: EmbeddingClient
-  constructor(db: SurrealDBService, embeddings: EmbeddingClient) {
+  private background: BackgroundWorker
+  constructor(db: SurrealDBService, embeddings: EmbeddingClient, background: BackgroundWorker) {
     this.db = db
     this.embeddings = embeddings
+    this.background = background
+  }
+
+  private recordMemorySearchDuration(elapsed: number): Effect.Effect<void> {
+    return this.background.runForget(Metric.update(memorySearchDuration, elapsed), 'memory-store.recordSearchDuration')
   }
 
   private toMetadataFieldPathEffect(key: string): Effect.Effect<string, MemoryStoreError> {
@@ -214,7 +220,7 @@ export class SurrealMemoryStore {
           MIN_RELEVANCE_SCORE,
         )
 
-        this.touchMemories(processed.map((row) => row.id))
+        yield* this.touchMemories(processed.map((row) => row.id))
         return processed
       }.bind(this),
     )
@@ -295,8 +301,8 @@ export class SurrealMemoryStore {
     )
   }
 
-  private touchMemories(memoryIds: string[]): void {
-    if (memoryIds.length === 0) return
+  private touchMemories(memoryIds: string[]): Effect.Effect<void> {
+    if (memoryIds.length === 0) return Effect.void
     const uniqueIds = [...new Set(memoryIds)]
     const memoryRefs = uniqueIds.map((id) => ensureRecordId(id, TABLES.MEMORY))
     const sql = `
@@ -306,7 +312,7 @@ export class SurrealMemoryStore {
     `
     const query = new BoundQuery(sql, { memoryIds: memoryRefs })
 
-    void Effect.runFork(this.runTouchMemoriesWithRetry(query))
+    return this.background.runForget(this.runTouchMemoriesWithRetry(query), 'memory-store.touchMemories')
   }
 
   private runTouchMemoriesWithRetry(query: BoundQuery): Effect.Effect<void, never, never> {
@@ -387,7 +393,7 @@ export class SurrealMemoryStore {
           MIN_RELEVANCE_SCORE,
         )
 
-        this.touchMemories(processed.map((row) => row.id))
+        yield* this.touchMemories(processed.map((row) => row.id))
         return processed
       }.bind(this),
     )
@@ -569,7 +575,7 @@ export class SurrealMemoryStore {
         )
 
         aiLogger.debug`Memory store search final results: ${processed.length} memories after filtering`
-        this.touchMemories(processed.map((row) => row.id))
+        yield* this.touchMemories(processed.map((row) => row.id))
         return processed
       }.bind(this),
     )
@@ -614,7 +620,7 @@ export class SurrealMemoryStore {
           MIN_RELEVANCE_SCORE,
         )
 
-        this.touchMemories(processed.map((row) => row.id))
+        yield* this.touchMemories(processed.map((row) => row.id))
         return processed
       }.bind(this),
     )
@@ -676,12 +682,13 @@ export class SurrealMemoryStore {
 
         type LinearRow = BasicSearchRow & { linearScore: number }
 
+        const recordSearchDuration = this.recordMemorySearchDuration.bind(this)
         const linearResults = yield* this.queryFinalStatementEffect<LinearRow>(sql, bindVars).pipe(
           Effect.timeout(Duration.millis(SurrealMemoryStore.HYBRID_SEARCH_TIMEOUT_MS)),
           Effect.catchTag('TimeoutError', () =>
-            Effect.sync(() => {
+            Effect.gen(function* () {
               const elapsed = performance.now() - searchStart
-              recordMemorySearchDuration(elapsed)
+              yield* recordSearchDuration(elapsed)
               aiLogger.warn`Hybrid search timed out after ${elapsed.toFixed(0)}ms (scopeId: ${options.scopeId}). Falling back to vector-only.`
               return null
             }),
@@ -737,9 +744,9 @@ export class SurrealMemoryStore {
         }
 
         const elapsed = performance.now() - searchStart
-        recordMemorySearchDuration(elapsed)
-        aiLogger.info`[SUCCESS_WEIGHTED_SEARCH] Weighted hybrid search succeeded (scopeId: ${options.scopeId}, rawResults: ${linearResults.length}, returned: ${processed.length}, weights: ${weights.join(',')}, normalization: ${normalization}, latencyMs: ${elapsed.toFixed(0)})`
-        this.touchMemories(processed.map((row) => row.id))
+        yield* this.recordMemorySearchDuration(elapsed)
+        aiLogger.debug`[SUCCESS_WEIGHTED_SEARCH] Weighted hybrid search succeeded (scopeId: ${options.scopeId}, rawResults: ${linearResults.length}, returned: ${processed.length}, weights: ${weights.join(',')}, normalization: ${normalization}, latencyMs: ${elapsed.toFixed(0)})`
+        yield* this.touchMemories(processed.map((row) => row.id))
         return processed
       }.bind(this),
     )
@@ -1247,9 +1254,11 @@ export class SurrealMemoryStore {
 export function createMemoryStore(
   db: SurrealDBService,
   options: { embeddingModel: string; openRouterApiKey?: string },
+  background: BackgroundWorker,
 ): SurrealMemoryStore {
   return new SurrealMemoryStore(
     db,
     new ProviderEmbeddings({ modelId: options.embeddingModel, openRouterApiKey: options.openRouterApiKey }),
+    background,
   )
 }

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