@lota-sdk/core 0.4.12 → 0.4.14

package/src/services/memory/memory-rerank.ts

@@ -1,11 +1,13 @@
 import { Effect, Schema } from 'effect'
 import { z } from 'zod'
 
+import type { AiGatewayModels } from '../../ai-gateway/ai-gateway'
 import { aiLogger } from '../../config/logger'
 import type { MemorySearchResult } from '../../db/memory-types'
+import { ERROR_TAGS } from '../../effect/errors'
 import type { HelperModelRuntime } from '../../runtime/helper-model'
 import type { MemoryRerankerStrategy, ResolvedLotaRuntimeConfig } from '../../runtime/runtime-config'
-import { createMemoryRerankerAgent, MEMORY_RERANKER_PROMPT } from '../../system-agents/memory-reranker.agent'
+import { makeMemoryRerankerAgentFactory, MEMORY_RERANKER_PROMPT } from '../../system-agents/memory-reranker.agent'
 import { compactWhitespace, truncateText } from '../../utils/string'
 import type { makeRerankService } from './rerank.service'
 
@@ -36,7 +38,7 @@ const RERANK_MULTI_SCOPE_PROMPT_SCHEMA = Schema.Struct({
 const stringifyRerankPrompt = Schema.encodeSync(Schema.fromJsonString(RERANK_PROMPT_SCHEMA))
 const stringifyRerankMultiScopePrompt = Schema.encodeSync(Schema.fromJsonString(RERANK_MULTI_SCOPE_PROMPT_SCHEMA))
 
-class MemoryRerankError extends Schema.TaggedErrorClass<MemoryRerankError>()('MemoryRerankError', {
+class MemoryRerankError extends Schema.TaggedErrorClass<MemoryRerankError>()(ERROR_TAGS.MemoryRerankError, {
   scope: Schema.Literals(['single', 'multi-scope']),
   message: Schema.String,
   cause: Schema.optional(Schema.Unknown),
@@ -119,6 +121,7 @@ function logRerankError(scope: 'single' | 'multi-scope', error: unknown): void {
 
 function rerankCandidatesWithHelperEffect(
   helperModelRuntime: HelperModelRuntime,
+  aiGatewayModels: AiGatewayModels,
   query: string,
   candidates: MemorySearchResult[],
   maxItems: number,
@@ -127,7 +130,7 @@ function rerankCandidatesWithHelperEffect(
     try: () =>
       helperModelRuntime.generateHelperStructured({
         tag: 'memory-reranker',
-        createAgent: createMemoryRerankerAgent,
+        createAgent: makeMemoryRerankerAgentFactory(aiGatewayModels),
         defaultSystemPrompt: MEMORY_RERANKER_PROMPT,
         messages: [
           {
@@ -179,6 +182,7 @@ function rerankCandidatesWithRerankServiceEffect(
 export function rerankCandidates(
   runtimeConfig: ResolvedLotaRuntimeConfig,
   helperModelRuntime: HelperModelRuntime,
+  aiGatewayModels: AiGatewayModels,
   query: string,
   candidates: MemorySearchResult[],
   maxItems: number,
@@ -191,7 +195,7 @@ export function rerankCandidates(
       return yield* rerankCandidatesWithRerankServiceEffect(query, candidates, maxItems, reranker)
     }
 
-    return yield* rerankCandidatesWithHelperEffect(helperModelRuntime, query, candidates, maxItems)
+    return yield* rerankCandidatesWithHelperEffect(helperModelRuntime, aiGatewayModels, query, candidates, maxItems)
   }).pipe(
     Effect.catchCause((cause) =>
       Effect.sync(() => {
@@ -204,6 +208,7 @@ export function rerankCandidates(
 
 function rerankCandidatesMultiScopeWithHelperEffect(
   helperModelRuntime: HelperModelRuntime,
+  aiGatewayModels: AiGatewayModels,
   query: string,
   flattenedCandidates: Array<MemorySearchResult & { scopeTag: string }>,
   maxItems: number,
@@ -212,7 +217,7 @@ function rerankCandidatesMultiScopeWithHelperEffect(
     try: () =>
       helperModelRuntime.generateHelperStructured({
         tag: 'memory-reranker-multi-scope',
-        createAgent: createMemoryRerankerAgent,
+        createAgent: makeMemoryRerankerAgentFactory(aiGatewayModels),
         defaultSystemPrompt: MEMORY_RERANKER_PROMPT,
         messages: [
           {
@@ -270,6 +275,7 @@ function rerankCandidatesMultiScopeWithRerankServiceEffect(
 export function rerankCandidatesMultiScope(
   runtimeConfig: ResolvedLotaRuntimeConfig,
   helperModelRuntime: HelperModelRuntime,
+  aiGatewayModels: AiGatewayModels,
   query: string,
   scopedCandidates: Array<{ scopeTag: string; candidates: MemorySearchResult[] }>,
   maxItems: number,
@@ -285,7 +291,13 @@ export function rerankCandidatesMultiScope(
       return yield* rerankCandidatesMultiScopeWithRerankServiceEffect(query, flattened, maxItems, reranker)
     }
 
-    return yield* rerankCandidatesMultiScopeWithHelperEffect(helperModelRuntime, query, flattened, maxItems)
+    return yield* rerankCandidatesMultiScopeWithHelperEffect(
+      helperModelRuntime,
+      aiGatewayModels,
+      query,
+      flattened,
+      maxItems,
+    )
   }).pipe(
     Effect.catchCause((cause) =>
       Effect.sync(() => {

package/src/services/memory/memory.service.ts

@@ -1,5 +1,7 @@
 import { Context, Schema, Effect, Layer } from 'effect'
 
+import { AiGatewayModelsTag, RuntimeBridgeTag } from '../../ai-gateway/ai-gateway'
+import type { AiGatewayModels } from '../../ai-gateway/ai-gateway'
 import type { ResolvedAgentConfig } from '../../config/agent-defaults'
 import { aiLogger } from '../../config/logger'
 import type { Memory } from '../../db/memory'
@@ -13,6 +15,7 @@ import type {
   MemoryType,
   RelationType,
 } from '../../db/memory-types'
+import { ERROR_TAGS } from '../../effect/errors'
 import { AgentConfigServiceTag, DatabaseServiceTag, RuntimeConfigServiceTag } from '../../effect/services'
 import { withOrgMemoryLockEffect } from '../../redis/org-memory-lock'
 import type { HelperModelRuntime } from '../../runtime/helper-model'
@@ -25,9 +28,8 @@ import {
 } from '../../runtime/retrieval-adapters'
 import type { ResolvedLotaRuntimeConfig } from '../../runtime/runtime-config'
 import { clampImportance, compactWhitespace } from '../../utils/string'
-import { BackgroundWorkService } from '../background-work.service'
-import type { MemoryServiceError } from './memory-errors'
-import { tryMemoryPromise as memoryTryPromise } from './memory-errors'
+import { BackgroundWorkServiceTag } from '../background-work.service'
+import { MemoryServiceError } from './memory-errors'
 import type { MemoryRerankOutput } from './memory-rerank'
 import { formatMemoryResults, formatRerankedResults, getCandidateLimit } from './memory-utils'
 export type { MemoryRerankOutput } from './memory-rerank'
@@ -52,7 +54,7 @@ const ONBOARDING_MEMORY_EXTRACTION_PROMPT =
 const DIRECT_MEMORY_ASSESSMENT_PROMPT =
   'The user is submitting a direct memory candidate. Keep the wording faithful. Return one fact only when the statement is durable enough for memory; otherwise return no facts.'
 
-class InvalidAgentNameError extends Schema.TaggedErrorClass<InvalidAgentNameError>()('InvalidAgentNameError', {
+class InvalidAgentNameError extends Schema.TaggedErrorClass<InvalidAgentNameError>()(ERROR_TAGS.InvalidAgentNameError, {
   agentName: Schema.String,
 }) {}
 
@@ -61,6 +63,7 @@ type EffectSuccess<T> = T extends Effect.Effect<infer A, infer _E, infer _R> ? A
 function searchMemoriesEffect({
   runtimeConfig,
   helperModelRuntime,
+  aiGatewayModels,
   resolveReranker,
   query,
   memory,
@@ -70,6 +73,7 @@ function searchMemoriesEffect({
 }: {
   runtimeConfig: ResolvedLotaRuntimeConfig
   helperModelRuntime: HelperModelRuntime
+  aiGatewayModels: AiGatewayModels
   resolveReranker: () => ReturnType<typeof makeRerankService>
   query: string
   memory: Memory
@@ -80,15 +84,17 @@ function searchMemoriesEffect({
   return Effect.gen(function* () {
     const limit = runtimeConfig.memory.searchK
     const candidateLimit = fastMode ? limit : getCandidateLimit(limit)
-    const candidates = yield* memoryTryPromise('Failed to search memory candidates.', () =>
-      memory.searchCandidates(query, {
+    const candidates = yield* memory
+      .searchCandidates(query, {
         scopeId,
         limit: candidateLimit,
         memoryType,
         fastMode,
         includeNeighborContext: !fastMode,
-      }),
-    )
+      })
+      .pipe(
+        Effect.mapError((cause) => new MemoryServiceError({ message: 'Failed to search memory candidates.', cause })),
+      )
 
     aiLogger.debug`Memory search candidates (scopeId: ${scopeId}, candidates: ${candidates.length})`
 
@@ -104,6 +110,7 @@ function searchMemoriesEffect({
     const reranked = yield* rerankCandidates(
       runtimeConfig,
       helperModelRuntime,
+      aiGatewayModels,
       query,
       candidates,
       limit,
@@ -125,16 +132,24 @@ function applyPreparedScopeUpdatesEffect(params: {
     }
 
     if (params.acquireLock === false) {
-      yield* memoryTryPromise('Failed to apply prepared memory scope updates.', () =>
-        params.orgMemory.applyPreparedScopeUpdates(params.preparedUpdates),
-      )
+      yield* params.orgMemory
+        .applyPreparedScopeUpdates(params.preparedUpdates)
+        .pipe(
+          Effect.mapError(
+            (cause) => new MemoryServiceError({ message: 'Failed to apply prepared memory scope updates.', cause }),
+          ),
+        )
       return
     }
 
     yield* withOrgMemoryLockEffect(params.orgId, () =>
-      memoryTryPromise('Failed to apply prepared memory scope updates.', () =>
-        params.orgMemory.applyPreparedScopeUpdates(params.preparedUpdates),
-      ),
+      params.orgMemory
+        .applyPreparedScopeUpdates(params.preparedUpdates)
+        .pipe(
+          Effect.mapError(
+            (cause) => new MemoryServiceError({ message: 'Failed to apply prepared memory scope updates.', cause }),
+          ),
+        ),
     )
   })
 }
@@ -179,10 +194,11 @@ interface MemoryServiceDeps {
   helperModelRuntime: HelperModelRuntime
   orgMemoryCache: OrgMemoryCache
   agentConfig: ResolvedAgentConfig
+  aiGatewayModels: AiGatewayModels
 }
 
 export function createMemoryService(deps: MemoryServiceDeps) {
-  const { runtimeConfig, helperModelRuntime, orgMemoryCache, agentConfig } = deps
+  const { runtimeConfig, helperModelRuntime, orgMemoryCache, agentConfig, aiGatewayModels } = deps
   const resolveRerankService = () => deps.rerankService
   const service = {
     searchOrganizationMemories: Effect.fn('MemoryService.searchOrganizationMemories')(function* (
@@ -195,6 +211,7 @@ export function createMemoryService(deps: MemoryServiceDeps) {
       const results = yield* searchMemoriesEffect({
         runtimeConfig,
         helperModelRuntime,
+        aiGatewayModels,
         resolveReranker: resolveRerankService,
         query,
         memory,
@@ -205,24 +222,20 @@ export function createMemoryService(deps: MemoryServiceDeps) {
       return results
     }),
 
-    getStaleMemories(orgId: string) {
-      return Effect.gen(function* () {
-        const orgScopeId = yield* scopeId(ORG_SCOPE_PREFIX, orgId)
-        const memory = yield* getOrgMemory(orgMemoryCache, orgId)
-        return yield* memoryTryPromise('Failed to load stale memories.', () => memory.getStaleMemories(orgScopeId))
-      }).pipe(
-        Effect.withSpan('MemoryService.getStaleMemories'),
-        Effect.map((stale) => {
-          if (stale.length === 0) return ''
-          const items = stale.map((m) => `- [NEEDS REVIEW] ${m.content}`).join('\n')
-          return `Memories flagged for review (parent fact was superseded):\n${items}`
-        }),
+    getStaleMemories: Effect.fn('MemoryService.getStaleMemories')(function* (orgId: string) {
+      const orgScopeId = yield* scopeId(ORG_SCOPE_PREFIX, orgId)
+      const memory = yield* getOrgMemory(orgMemoryCache, orgId)
+      const stale = yield* memory.getStaleMemories(orgScopeId).pipe(
+        Effect.mapError((cause) => new MemoryServiceError({ message: 'Failed to load stale memories.', cause })),
         Effect.catch((error) => {
           aiLogger.error`Failed to get stale memories: ${error.cause}`
-          return Effect.succeed('')
+          return Effect.succeed<MemorySearchResult[]>([])
         }),
       )
-    },
+      if (stale.length === 0) return ''
+      const items = stale.map((m) => `- [NEEDS REVIEW] ${m.content}`).join('\n')
+      return `Memories flagged for review (parent fact was superseded):\n${items}`
+    }),
 
     searchOrganizationMemoriesRaw: Effect.fn('MemoryService.searchOrganizationMemoriesRaw')(function* (
       orgId: string,
@@ -235,15 +248,19 @@ export function createMemoryService(deps: MemoryServiceDeps) {
       const fastMode = options?.fastMode ?? true
       const searchK = runtimeConfig.memory.searchK
       const limit = options?.limit ?? (fastMode ? Math.min(searchK, 4) : searchK)
-      const candidates = yield* memoryTryPromise('Failed to search organization memories.', () =>
-        memory.searchCandidates(query, {
+      const candidates = yield* memory
+        .searchCandidates(query, {
           scopeId: orgScopeId,
           limit,
           memoryType: ORG_MEMORY_TYPE,
           fastMode,
           includeNeighborContext: !fastMode,
-        }),
-      )
+        })
+        .pipe(
+          Effect.mapError(
+            (cause) => new MemoryServiceError({ message: 'Failed to search organization memories.', cause }),
+          ),
+        )
       aiLogger.debug`Organization memory search (raw) completed (candidates: ${candidates.length})`
       return formatMemoryResults(candidates)
     }),
@@ -264,6 +281,7 @@ export function createMemoryService(deps: MemoryServiceDeps) {
       const results = yield* searchMemoriesEffect({
         runtimeConfig,
         helperModelRuntime,
+        aiGatewayModels,
         resolveReranker: resolveRerankService,
         query,
         memory,
@@ -285,9 +303,13 @@ export function createMemoryService(deps: MemoryServiceDeps) {
       const { orgId, ...listOptions } = params
       const orgMemory = yield* getOrgMemory(orgMemoryCache, orgId)
       const orgScopeId = yield* scopeId(ORG_SCOPE_PREFIX, orgId)
-      return yield* memoryTryPromise('Failed to list organization memory records.', () =>
-        orgMemory.list({ scopeId: orgScopeId, ...listOptions }),
-      )
+      return yield* orgMemory
+        .list({ scopeId: orgScopeId, ...listOptions })
+        .pipe(
+          Effect.mapError(
+            (cause) => new MemoryServiceError({ message: 'Failed to list organization memory records.', cause }),
+          ),
+        )
     }),
 
     getTopMemories(params: { orgId: string; agentName?: string; limit?: number }) {
@@ -346,8 +368,10 @@ export function createMemoryService(deps: MemoryServiceDeps) {
         })
       }
 
-      const results = yield* memoryTryPromise('Failed to execute scoped memory retrieval.', () =>
-        executeScopedRetrieval(retrievalTasks),
+      const results = yield* executeScopedRetrieval(retrievalTasks).pipe(
+        Effect.mapError(
+          (cause) => new MemoryServiceError({ message: 'Failed to execute scoped memory retrieval.', cause }),
+        ),
       )
       const totalCandidates = countScopedRetrievalCandidates(results)
       aiLogger.debug`Batched memory search candidates (scopes: ${results.length}, total: ${totalCandidates})`
@@ -364,6 +388,7 @@ export function createMemoryService(deps: MemoryServiceDeps) {
       const reranked = yield* rerankCandidatesMultiScope(
         runtimeConfig,
         helperModelRuntime,
+        aiGatewayModels,
         query,
         results,
         limit,
@@ -372,7 +397,7 @@ export function createMemoryService(deps: MemoryServiceDeps) {
       return formatBatchedResults(reranked, candidatesByScopeTag, limit, agentName)
     }),
 
-    createOrganizationMemory({
+    createOrganizationMemory: Effect.fn('MemoryService.createOrganizationMemory')(function* ({
       orgId,
       content,
       memoryType,
@@ -387,35 +412,30 @@ export function createMemoryService(deps: MemoryServiceDeps) {
       importance?: number
       durability?: MemoryRecord['durability']
     }) {
-      return Effect.gen(function* () {
-        const memory = yield* getOrgMemory(orgMemoryCache, orgId)
-        const orgScopeId = yield* scopeId(ORG_SCOPE_PREFIX, orgId)
-        return yield* memoryTryPromise('Failed to create organization memory.', () =>
-          memory.insert(content, {
-            scopeId: orgScopeId,
-            memoryType,
-            importance: importance ?? 1,
-            durability,
-            metadata: { orgId, ...metadata },
+      const memory = yield* getOrgMemory(orgMemoryCache, orgId)
+      const orgScopeId = yield* scopeId(ORG_SCOPE_PREFIX, orgId)
+      aiLogger.debug`createOrganizationMemory - orgId: "${orgId}", scopeId: "${orgScopeId}", content preview: "${content.slice(0, 50)}"`
+      return yield* memory
+        .insert(content, {
+          scopeId: orgScopeId,
+          memoryType,
+          importance: importance ?? 1,
+          durability,
+          metadata: { orgId, ...metadata },
+        })
+        .pipe(
+          Effect.mapError(
+            (cause) => new MemoryServiceError({ message: 'Failed to create organization memory.', cause }),
+          ),
+          Effect.catch((error) => {
+            if (isUniqueIndexConflict(error, 'memoryHashIdx')) {
+              aiLogger.debug`Organization memory already exists (hash conflict)`
+              return Effect.succeed('')
+            }
+            return Effect.fail(error)
           }),
         )
-      }).pipe(
-        Effect.withSpan('MemoryService.createOrganizationMemory'),
-        Effect.tap(() =>
-          Effect.gen(function* () {
-            const orgScopeId = yield* scopeId(ORG_SCOPE_PREFIX, orgId)
-            aiLogger.debug`createOrganizationMemory - orgId: "${orgId}", scopeId: "${orgScopeId}", content preview: "${content.slice(0, 50)}"`
-          }),
-        ),
-        Effect.catch((error) => {
-          if (isUniqueIndexConflict(error, 'memoryHashIdx')) {
-            aiLogger.debug`Organization memory already exists (hash conflict)`
-            return Effect.succeed('')
-          }
-          return Effect.fail(error)
-        }),
-      )
-    },
+    }),
 
     addOrganizationMemoryRelation: Effect.fn('MemoryService.addOrganizationMemoryRelation')(function* ({
       orgId,
@@ -431,12 +451,16 @@ export function createMemoryService(deps: MemoryServiceDeps) {
       confidence?: number
     }) {
       const memory = yield* getOrgMemory(orgMemoryCache, orgId)
-      return yield* memoryTryPromise('Failed to add organization memory relation.', () =>
-        memory.addRelation(fromMemoryId, toMemoryId, relationType, confidence),
-      )
+      return yield* memory
+        .addRelation(fromMemoryId, toMemoryId, relationType, confidence)
+        .pipe(
+          Effect.mapError(
+            (cause) => new MemoryServiceError({ message: 'Failed to add organization memory relation.', cause }),
+          ),
+        )
     }),
 
-    createAgentMemory({
+    createAgentMemory: Effect.fn('MemoryService.createAgentMemory')(function* ({
       orgId,
       agentName,
       content,
@@ -452,31 +476,28 @@ export function createMemoryService(deps: MemoryServiceDeps) {
       importance?: number
     }) {
       if (!isRoutableAgentName(agentConfig, agentName)) {
-        return Effect.fail(new InvalidAgentNameError({ agentName }))
+        return yield* new InvalidAgentNameError({ agentName })
       }
-
-      return Effect.gen(function* () {
-        const scoped = yield* agentScopeId(orgId, agentName)
-        const memory = yield* getOrgMemory(orgMemoryCache, orgId)
-        return yield* memoryTryPromise('Failed to create agent memory.', () =>
-          memory.insert(content, {
-            scopeId: scoped,
-            memoryType,
-            importance: importance ?? 1,
-            metadata: { orgId, agentName, memoryScope: 'agent', ...metadata },
+      const scoped = yield* agentScopeId(orgId, agentName)
+      const memory = yield* getOrgMemory(orgMemoryCache, orgId)
+      return yield* memory
+        .insert(content, {
+          scopeId: scoped,
+          memoryType,
+          importance: importance ?? 1,
+          metadata: { orgId, agentName, memoryScope: 'agent', ...metadata },
+        })
+        .pipe(
+          Effect.mapError((cause) => new MemoryServiceError({ message: 'Failed to create agent memory.', cause })),
+          Effect.catch((error) => {
+            if (isUniqueIndexConflict(error, 'memoryHashIdx')) {
+              aiLogger.debug`Agent memory already exists (hash conflict)`
+              return Effect.succeed('')
+            }
+            return Effect.fail(error)
           }),
         )
-      }).pipe(
-        Effect.withSpan('MemoryService.createAgentMemory'),
-        Effect.catch((error) => {
-          if (isUniqueIndexConflict(error, 'memoryHashIdx')) {
-            aiLogger.debug`Agent memory already exists (hash conflict)`
-            return Effect.succeed('')
-          }
-          return Effect.fail(error)
-        }),
-      )
-    },
+    }),
 
     assessMemoryCandidate: Effect.fn('MemoryService.assessMemoryCandidate')(function* (params: {
       orgId: string
@@ -486,12 +507,16 @@ export function createMemoryService(deps: MemoryServiceDeps) {
       if (!trimmed) return null
 
       const memory = yield* getOrgMemory(orgMemoryCache, params.orgId)
-      const facts = yield* memoryTryPromise('Failed to assess direct memory candidate.', () =>
-        memory.extractFactsFromMessages([{ role: 'user', content: trimmed }], {
+      const facts = yield* memory
+        .extractFactsFromMessages([{ role: 'user', content: trimmed }], {
           maxFacts: 1,
           customPrompt: DIRECT_MEMORY_ASSESSMENT_PROMPT,
-        }),
-      )
+        })
+        .pipe(
+          Effect.mapError(
+            (cause) => new MemoryServiceError({ message: 'Failed to assess direct memory candidate.', cause }),
+          ),
+        )
       if (facts.length === 0) return null
       const fact = facts[0]
 
@@ -513,9 +538,13 @@ export function createMemoryService(deps: MemoryServiceDeps) {
       content: string
     }) {
       const memory = yield* getOrgMemory(orgMemoryCache, orgId)
-      return yield* memoryTryPromise('Failed to update organization memory.', () =>
-        memory.updateMemory(memoryId, content),
-      )
+      return yield* memory
+        .updateMemory(memoryId, content)
+        .pipe(
+          Effect.mapError(
+            (cause) => new MemoryServiceError({ message: 'Failed to update organization memory.', cause }),
+          ),
+        )
     }),
 
     addExtractedFactsToScopes: Effect.fn('MemoryService.addExtractedFactsToScopes')(function* (params: {
@@ -553,9 +582,14 @@ export function createMemoryService(deps: MemoryServiceDeps) {
         })
       }
 
-      const preparedUpdates = yield* memoryTryPromise('Failed to prepare extracted facts for memory scopes.', () =>
-        orgMemory.prepareFactsToScopes(params.facts, scopes),
-      )
+      const preparedUpdates = yield* orgMemory
+        .prepareFactsToScopes(params.facts, scopes)
+        .pipe(
+          Effect.mapError(
+            (cause) =>
+              new MemoryServiceError({ message: 'Failed to prepare extracted facts for memory scopes.', cause }),
+          ),
+        )
       yield* applyPreparedScopeUpdatesEffect({
         orgId: params.orgId,
         orgMemory,
@@ -637,17 +671,26 @@ export function createMemoryService(deps: MemoryServiceDeps) {
         })
       }
 
-      const extractedFacts = yield* memoryTryPromise('Failed to extract conversation memories.', () =>
-        orgMemory.extractFactsFromMessages(messages, extractionConfig),
-      )
+      const extractedFacts = yield* orgMemory
+        .extractFactsFromMessages(messages, extractionConfig)
+        .pipe(
+          Effect.mapError(
+            (cause) => new MemoryServiceError({ message: 'Failed to extract conversation memories.', cause }),
+          ),
+        )
       if (shouldSkipExtractedFacts(extractedFacts)) {
         aiLogger.debug`Skipping transient conversation memory`
         return
       }
 
-      const preparedUpdates = yield* memoryTryPromise('Failed to prepare conversation memories for scopes.', () =>
-        orgMemory.prepareFactsToScopes(extractedFacts, scopes),
-      )
+      const preparedUpdates = yield* orgMemory
+        .prepareFactsToScopes(extractedFacts, scopes)
+        .pipe(
+          Effect.mapError(
+            (cause) =>
+              new MemoryServiceError({ message: 'Failed to prepare conversation memories for scopes.', cause }),
+          ),
+        )
       yield* applyPreparedScopeUpdatesEffect({ orgId, orgMemory, preparedUpdates })
       if (preparedUpdates.length > 0) {
         aiLogger.debug`Conversation memories added to ${scopes.length} scope(s) from ${messages.length} message(s)`
@@ -669,9 +712,25 @@ export const MemoryServiceLive = Layer.effect(
     const runtimeConfig = yield* RuntimeConfigServiceTag
     const rerankService = yield* RerankServiceTag
     const helperModelRuntime = yield* HelperModelTag
-    const background = yield* BackgroundWorkService
+    const background = yield* BackgroundWorkServiceTag
     const agentConfig = yield* AgentConfigServiceTag
-    const orgMemoryCache = yield* makeOrgMemoryCache({ db, runtimeConfig, helperModelRuntime, background })
-    return createMemoryService({ runtimeConfig, rerankService, helperModelRuntime, orgMemoryCache, agentConfig })
+    const aiGatewayModels = yield* AiGatewayModelsTag
+    const bridge = yield* RuntimeBridgeTag
+    const orgMemoryCache = yield* makeOrgMemoryCache({
+      db,
+      runtimeConfig,
+      helperModelRuntime,
+      background,
+      aiGatewayModels,
+      runPromise: bridge.runPromise,
+    })
+    return createMemoryService({
+      runtimeConfig,
+      rerankService,
+      helperModelRuntime,
+      orgMemoryCache,
+      agentConfig,
+      aiGatewayModels,
+    })
   }),
 )

package/src/services/memory/rerank.service.ts

@@ -3,7 +3,7 @@ import * as Schema from 'effect/Schema'
 import { z } from 'zod'
 
 import { OPENROUTER_FAST_RERANK_MODEL_ID } from '../../config/model-constants'
-import { makeEffectTryPromiseWithOperation } from '../../effect/helpers'
+import { ERROR_TAGS } from '../../effect/errors'
 import { RuntimeConfigServiceTag } from '../../effect/services'
 import { toValidationError } from '../../effect/zod'
 import { normalizeDirectOpenRouterModelId, resolveOpenRouterApiKey } from '../../openrouter/direct-provider'
@@ -11,7 +11,16 @@ import type { ResolvedLotaRuntimeConfig } from '../../runtime/runtime-config'
 
 const OPENROUTER_RERANK_URL = 'https://openrouter.ai/api/v1/rerank' as const
 
-class RerankServiceError extends Schema.TaggedErrorClass<RerankServiceError>()('RerankServiceError', {
+const RerankRequestBodySchema = Schema.Struct({
+  model: Schema.String,
+  query: Schema.String,
+  documents: Schema.Array(Schema.String),
+  top_n: Schema.Number,
+})
+
+const encodeRerankRequestBody = Schema.encodeSync(Schema.fromJsonString(RerankRequestBodySchema))
+
+class RerankServiceError extends Schema.TaggedErrorClass<RerankServiceError>()(ERROR_TAGS.RerankServiceError, {
   operation: Schema.String,
   message: Schema.String,
   cause: Schema.Defect,
@@ -21,8 +30,6 @@ function toRerankServiceError(operation: string, message: string, cause: unknown
   return new RerankServiceError({ operation, message, cause })
 }
 
-const tryRerankPromise = makeEffectTryPromiseWithOperation(toRerankServiceError)
-
 const RerankResponseSchema = z
   .object({
     model: z.string().optional(),
@@ -112,25 +119,27 @@ export function makeRerankService(config: ResolvedLotaRuntimeConfig) {
         const apiKey = resolveOpenRouterApiKey(config.aiGateway.openRouterApiKey)
         const modelId = resolveRerankModelId(params.modelId)
         const topN = clampTopN(params.topN, params.documents.length)
+        const requestBody = encodeRerankRequestBody({
+          model: modelId,
+          query: params.query,
+          documents: params.documents.map((document) => document.text),
+          top_n: topN,
+        })
 
-        const response = yield* tryRerankPromise('fetch-rerank', 'Failed to fetch rerank results.', () =>
-          Bun.fetch(OPENROUTER_RERANK_URL, {
-            method: 'POST',
-            headers: { Authorization: `Bearer ${apiKey}`, 'Content-Type': 'application/json' },
-            body: JSON.stringify({
-              model: modelId,
-              query: params.query,
-              documents: params.documents.map((document) => document.text),
-              top_n: topN,
+        const response = yield* Effect.tryPromise({
+          try: () =>
+            Bun.fetch(OPENROUTER_RERANK_URL, {
+              method: 'POST',
+              headers: { Authorization: `Bearer ${apiKey}`, 'Content-Type': 'application/json' },
+              body: requestBody,
             }),
-          }),
-        )
+          catch: (cause) => toRerankServiceError('fetch-rerank', 'Failed to fetch rerank results.', cause),
+        })
 
-        const responseText = yield* tryRerankPromise(
-          'read-rerank-response',
-          'Failed to read rerank response body.',
-          () => response.text(),
-        )
+        const responseText = yield* Effect.tryPromise({
+          try: () => response.text(),
+          catch: (cause) => toRerankServiceError('read-rerank-response', 'Failed to read rerank response body.', cause),
+        })
 
         if (!response.ok) {
           return yield* new RerankServiceError({

package/src/services/organization-member.service.ts

@@ -29,7 +29,7 @@ type SdkOrganizationMemberRecord = z.infer<typeof organizationMemberRecordSchema
 export type SdkOrganizationMember = z.infer<typeof sdkOrganizationMemberSchema>
 
 class OrganizationMemberServiceError extends Schema.TaggedErrorClass<OrganizationMemberServiceError>()(
-  'OrganizationMemberServiceError',
+  '@lota-sdk/core/OrganizationMemberServiceError',
   { operation: Schema.String, cause: Schema.Defect },
 ) {}