@lota-sdk/core 0.4.9 → 0.4.11

package/src/db/base.service.ts

@@ -1,8 +1,6 @@
 import { Effect } from 'effect'
 import type { z } from 'zod'
 
-import type { AwaitableEffect } from '../effect/awaitable-effect'
-import { toAwaitableEffect } from '../effect/awaitable-effect'
 import { NotFoundError } from '../effect/errors'
 import { ensureRecordId } from './record-id'
 import type { SurrealDBService } from './service'
@@ -16,7 +14,7 @@ export abstract class BaseService<T extends z.ZodType> {
     protected readonly databaseService: SurrealDBService,
   ) {}
 
-  findById(id: unknown): AwaitableEffect<z.infer<T> | null, SurrealDBError> {
+  findById(id: unknown): Effect.Effect<z.infer<T> | null, SurrealDBError, never> {
     return this.databaseService.findOne(
       this.table,
       { id: ensureRecordId(id as Parameters<typeof ensureRecordId>[0], this.table) },
@@ -24,61 +22,55 @@ export abstract class BaseService<T extends z.ZodType> {
     )
   }
 
-  getById(id: unknown): AwaitableEffect<z.infer<T>, SurrealDBError | NotFoundError> {
+  getById(id: unknown): Effect.Effect<z.infer<T>, SurrealDBError | NotFoundError, never> {
     const { table, databaseService, schema } = this
-    return toAwaitableEffect(
-      Effect.gen(function* () {
-        const record = yield* databaseService.findOne(
-          table,
-          { id: ensureRecordId(id as Parameters<typeof ensureRecordId>[0], table) },
-          schema,
-        )
+    return Effect.gen(function* () {
+      const record = yield* databaseService.findOne(
+        table,
+        { id: ensureRecordId(id as Parameters<typeof ensureRecordId>[0], table) },
+        schema,
+      )
 
-        if (!record) {
-          return yield* new NotFoundError({ resource: table, message: `${table} record not found` })
-        }
+      if (!record) {
+        return yield* new NotFoundError({ resource: table, message: `${table} record not found` })
+      }
 
-        return record
-      }),
-    )
+      return record
+    })
   }
 
   findAll(
     filter: Record<string, unknown> = {},
     options?: { limit?: number; offset?: number; orderBy?: keyof z.infer<T> & string; orderDir?: 'ASC' | 'DESC' },
-  ): AwaitableEffect<z.infer<T>[], SurrealDBError> {
+  ): Effect.Effect<z.infer<T>[], SurrealDBError, never> {
     return this.databaseService.findMany(this.table, filter, this.schema, options)
   }
 
-  create(data: Record<string, unknown>): AwaitableEffect<z.infer<T>, SurrealDBError> {
+  create(data: Record<string, unknown>): Effect.Effect<z.infer<T>, SurrealDBError, never> {
     return this.databaseService.create(this.table, data, this.schema)
   }
 
-  update(id: unknown, data: Record<string, unknown>): AwaitableEffect<z.infer<T>, SurrealDBError | NotFoundError> {
+  update(id: unknown, data: Record<string, unknown>): Effect.Effect<z.infer<T>, SurrealDBError | NotFoundError, never> {
     const { table, databaseService, schema } = this
-    return toAwaitableEffect(
-      Effect.gen(function* () {
-        const updated = yield* databaseService.update(table, id, data, schema)
+    return Effect.gen(function* () {
+      const updated = yield* databaseService.update(table, id, data, schema)
 
-        if (!updated) {
-          return yield* new NotFoundError({ resource: table, message: `${table} record not found` })
-        }
+      if (!updated) {
+        return yield* new NotFoundError({ resource: table, message: `${table} record not found` })
+      }
 
-        return updated
-      }),
-    )
+      return updated
+    })
   }
 
-  delete(id: unknown): AwaitableEffect<void, SurrealDBError | NotFoundError> {
+  delete(id: unknown): Effect.Effect<void, SurrealDBError | NotFoundError, never> {
     const { table, databaseService } = this
-    return toAwaitableEffect(
-      Effect.gen(function* () {
-        const deleted = yield* databaseService.deleteById(table, id)
+    return Effect.gen(function* () {
+      const deleted = yield* databaseService.deleteById(table, id)
 
-        if (!deleted) {
-          return yield* new NotFoundError({ resource: table, message: `${table} record not found` })
-        }
-      }),
-    )
+      if (!deleted) {
+        return yield* new NotFoundError({ resource: table, message: `${table} record not found` })
+      }
+    })
   }
 }

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