@lota-sdk/core 0.4.12 → 0.4.14

package/src/services/graph-full-routing.ts

@@ -14,14 +14,11 @@ import { serverLogger } from '../config/logger'
 import { recordIdToString } from '../db/record-id'
 import { TABLES } from '../db/tables'
 import { BadRequestError, ServiceError } from '../effect/errors'
-import { makeEffectTryPromiseWithMessage } from '../effect/helpers'
 import type { PlanAgentHeartbeatQueueRuntime } from '../queues/plan-agent-heartbeat.queue'
 import { shouldPlanNodeUseVisibleTurn } from '../runtime/execution-plan-visibility'
 import type { makePlanExecutorService } from './plan/plan-executor.service'
 import type { makePlanRunService } from './plan/plan-run.service'
 
-const tryGraphFullPromise = makeEffectTryPromiseWithMessage((message, cause) => new ServiceError({ message, cause }))
-
 function classifyDispatchFailure(ownerType: string, error: unknown): PlanFailureClass {
   const errorMessage = error instanceof Error ? error.message.toLowerCase() : String(error).toLowerCase()
   if (errorMessage.includes('timeout')) return 'timeout_exceeded'
@@ -82,15 +79,17 @@ export function routeGraphFullEffect<E>(params: { threadId: string; runId: strin
       yield* Effect.forEach(
         readyNodes,
         (nodeRun) =>
-          tryGraphFullPromise(
-            () => deps.planExecutorService.transitionNodeToRunning({ runId: params.runId, nodeId: nodeRun.nodeId }),
-            'Failed to transition plan node to running.',
-          ),
+          deps.planExecutorService
+            .transitionNodeToRunning({ runId: params.runId, nodeId: nodeRun.nodeId })
+            .pipe(
+              Effect.mapError(
+                (cause) => new ServiceError({ message: 'Failed to transition plan node to running.', cause }),
+              ),
+            ),
         { concurrency: 'unbounded' },
       )
 
       if (visibleNodes.length > 0) {
-        const enqueuePlanAgentHeartbeatWake = deps.planAgentHeartbeatQueue.enqueuePlanAgentHeartbeatWake
         const updatedRunForWake = yield* deps.planRunService.getRunById(params.runId)
         yield* Effect.forEach(
           visibleNodes,
@@ -101,9 +100,9 @@ export function routeGraphFullEffect<E>(params: { threadId: string; runId: strin
                 return
               }
 
-              yield* tryGraphFullPromise(
-                () =>
-                  enqueuePlanAgentHeartbeatWake({
+              yield* Effect.tryPromise({
+                try: () =>
+                  deps.planAgentHeartbeatQueue.enqueuePlanAgentHeartbeatWake({
                     organizationId: recordIdToString(updatedRunForWake.organizationId, TABLES.ORGANIZATION),
                     threadId: recordIdToString(updatedRunForWake.threadId, TABLES.THREAD),
                     runId: recordIdToString(updatedRunForWake.id, TABLES.PLAN_RUN),
@@ -111,8 +110,8 @@ export function routeGraphFullEffect<E>(params: { threadId: string; runId: strin
                     agentId: ns.owner.ref,
                     reason: 'graph-full-visible',
                   }),
-                'Failed to enqueue plan agent heartbeat wake.',
-              )
+                catch: (cause) => new ServiceError({ message: 'Failed to enqueue plan agent heartbeat wake.', cause }),
+              })
             }),
           { concurrency: 'unbounded' },
         )
@@ -158,31 +157,33 @@ export function routeGraphFullEffect<E>(params: { threadId: string; runId: strin
         const nodeSpecRecord = nodeSpecs.find((ns) => ns.nodeId === nodeRun.nodeId)
 
         if (settled.status === 'fulfilled') {
-          yield* tryGraphFullPromise(
-            () =>
-              deps.planExecutorService.submitNodeResult({
-                threadId,
-                runId,
-                nodeId: settled.value.nodeId,
-                emittedBy: settled.value.ownerRef,
-                result: settled.value.result,
-              }),
-            'Failed to submit plan node result.',
-          )
+          yield* deps.planExecutorService
+            .submitNodeResult({
+              threadId,
+              runId,
+              nodeId: settled.value.nodeId,
+              emittedBy: settled.value.ownerRef,
+              result: settled.value.result,
+            })
+            .pipe(
+              Effect.mapError((cause) => new ServiceError({ message: 'Failed to submit plan node result.', cause })),
+            )
         } else {
           serverLogger.warn`routeGraphFull: dispatch failed for node "${nodeRun.nodeId}": ${settled.reason}`
-          yield* tryGraphFullPromise(
-            () =>
-              deps.planExecutorService.blockNodeOnDispatchFailure({
-                threadId,
-                runId,
-                nodeId: nodeRun.nodeId,
-                emittedBy: nodeSpecRecord?.owner.ref ?? 'unknown',
-                message: formatDispatchError(settled.reason),
-                failureClass: classifyDispatchFailure(nodeSpecRecord?.owner.executorType ?? 'agent', settled.reason),
-              }),
-            'Failed to block plan node on dispatch failure.',
-          )
+          yield* deps.planExecutorService
+            .blockNodeOnDispatchFailure({
+              threadId,
+              runId,
+              nodeId: nodeRun.nodeId,
+              emittedBy: nodeSpecRecord?.owner.ref ?? 'unknown',
+              message: formatDispatchError(settled.reason),
+              failureClass: classifyDispatchFailure(nodeSpecRecord?.owner.executorType ?? 'agent', settled.reason),
+            })
+            .pipe(
+              Effect.mapError(
+                (cause) => new ServiceError({ message: 'Failed to block plan node on dispatch failure.', cause }),
+              ),
+            )
         }
       }
     }

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

@@ -11,7 +11,6 @@ import { BoundQuery } from 'surrealdb'
 import { ensureRecordId } from '../db/record-id'
 import type { SurrealDBService } from '../db/service'
 import { TABLES } from '../db/tables'
-import { makeEffectTryPromiseWithMessage } from '../effect/helpers'
 import { DatabaseServiceTag } from '../effect/services'
 import { unsafeDateFrom } from '../utils/date-time'
 import type { makePlanRunService } from './plan/plan-run.service'
@@ -23,21 +22,10 @@ interface InstitutionalMemoryDeps {
 }
 
 class InstitutionalMemoryServiceError extends Schema.TaggedErrorClass<InstitutionalMemoryServiceError>()(
-  'InstitutionalMemoryServiceError',
+  '@lota-sdk/core/InstitutionalMemoryServiceError',
   { message: Schema.String, cause: Schema.Defect },
 ) {}
 
-const effectTryInstitutionalMemoryPromise = makeEffectTryPromiseWithMessage(
-  (message, cause) => new InstitutionalMemoryServiceError({ message, cause }),
-)
-
-function tryInstitutionalMemoryPromise<A>(
-  message: string,
-  evaluate: () => PromiseLike<A> | Effect.Effect<A, unknown>,
-): Effect.Effect<A, InstitutionalMemoryServiceError> {
-  return effectTryInstitutionalMemoryPromise(evaluate, message)
-}
-
 export function makeInstitutionalMemoryService(deps: InstitutionalMemoryDeps) {
   const { db, planRunService } = deps
 
@@ -48,8 +36,8 @@ export function makeInstitutionalMemoryService(deps: InstitutionalMemoryDeps) {
     confidence: number
     sampleCount: number
   }) =>
-    tryInstitutionalMemoryPromise('Failed to persist institutional memory.', () =>
-      db.create(
+    db
+      .create(
         TABLES.INSTITUTIONAL_MEMORY,
         {
           organizationId: params.organizationId,
@@ -59,8 +47,12 @@ export function makeInstitutionalMemoryService(deps: InstitutionalMemoryDeps) {
           sampleCount: params.sampleCount,
         },
         InstitutionalMemorySchema,
-      ),
-    )
+      )
+      .pipe(
+        Effect.mapError(
+          (cause) => new InstitutionalMemoryServiceError({ message: 'Failed to persist institutional memory.', cause }),
+        ),
+      )
 
   const extractPatternsEffect = (params: { organizationId: string; runId: string }) =>
     Effect.gen(function* () {
@@ -172,20 +164,26 @@ export function makeInstitutionalMemoryService(deps: InstitutionalMemoryDeps) {
       const orgRef = ensureRecordId(params.organizationId, TABLES.ORGANIZATION)
       const limit = params.limit ?? 10
       const fetchLimit = Math.max(limit * 3, 30)
-      const records = yield* tryInstitutionalMemoryPromise(
-        `Failed to query institutional memory for organization ${params.organizationId}.`,
-        () =>
-          db.queryMany(
-            new BoundQuery(
-              `SELECT * FROM ${TABLES.INSTITUTIONAL_MEMORY}
-           WHERE organizationId = $orgId
-           ORDER BY confidence DESC, createdAt DESC
-           LIMIT $fetchLimit`,
-              { orgId: orgRef, fetchLimit },
-            ),
-            InstitutionalMemorySchema,
+      const records = yield* db
+        .queryMany(
+          new BoundQuery(
+            `SELECT * FROM ${TABLES.INSTITUTIONAL_MEMORY}
+             WHERE organizationId = $orgId
+             ORDER BY confidence DESC, createdAt DESC
+             LIMIT $fetchLimit`,
+            { orgId: orgRef, fetchLimit },
           ),
-      )
+          InstitutionalMemorySchema,
+        )
+        .pipe(
+          Effect.mapError(
+            (cause) =>
+              new InstitutionalMemoryServiceError({
+                message: `Failed to query institutional memory for organization ${params.organizationId}.`,
+                cause,
+              }),
+          ),
+        )
 
       const objectiveTerms = params.objective
         .toLowerCase()

package/src/services/learned-skill.service.ts

@@ -3,17 +3,19 @@ import { Cache, Context, Schema, Duration, Effect, Layer } from 'effect'
 import { BoundQuery } from 'surrealdb'
 import { z } from 'zod'
 
+import { RuntimeBridgeTag } from '../ai-gateway/ai-gateway'
+import type { RuntimeBridge } from '../ai-gateway/ai-gateway'
 import { renderLearnedSkillInstructions } from '../ai/definitions'
 import { serverLogger } from '../config/logger'
 import { ensureRecordId, recordIdToString } from '../db/record-id'
 import type { SurrealDBService } from '../db/service'
 import { TABLES } from '../db/tables'
-import { makeEffectTryPromiseWithMessage } from '../effect/helpers'
+import { ERROR_TAGS } from '../effect/errors'
 import { DatabaseServiceTag, RuntimeConfigServiceTag } from '../effect/services'
 import { ProviderEmbeddings } from '../embeddings/provider'
 import { sha256HexFromParts } from '../utils/crypto'
 import { nowDate } from '../utils/date-time'
-import { BackgroundWorkService } from './background-work.service'
+import { BackgroundWorkServiceTag } from './background-work.service'
 
 const PROMOTION_MIN_USES = 5
 const PROMOTION_MIN_SUCCESS_RATE = 0.6
@@ -56,25 +58,18 @@ const SearchResultRowSchema = z.object({
   similarity: z.number(),
 })
 
-class LearnedSkillServiceError extends Schema.TaggedErrorClass<LearnedSkillServiceError>()('LearnedSkillServiceError', {
-  message: Schema.String,
-  cause: Schema.Defect,
-}) {}
+class LearnedSkillServiceError extends Schema.TaggedErrorClass<LearnedSkillServiceError>()(
+  ERROR_TAGS.LearnedSkillServiceError,
+  { message: Schema.String, cause: Schema.Defect },
+) {}
 
 class LearnedSkillNotFoundError extends Schema.TaggedErrorClass<LearnedSkillNotFoundError>()(
-  'LearnedSkillNotFoundError',
+  '@lota-sdk/core/LearnedSkillNotFoundError',
   { message: Schema.String },
 ) {}
 
-const effectTryLearnedSkillPromise = makeEffectTryPromiseWithMessage(
-  (message, cause) => new LearnedSkillServiceError({ message, cause }),
-)
-
-function tryLearnedSkillPromise<A>(
-  message: string,
-  evaluate: () => PromiseLike<A> | Effect.Effect<A, unknown>,
-): Effect.Effect<A, LearnedSkillServiceError> {
-  return effectTryLearnedSkillPromise(evaluate, message)
+function toLearnedSkillServiceError(message: string, cause: unknown): LearnedSkillServiceError {
+  return new LearnedSkillServiceError({ message, cause })
 }
 
 interface CreateLearnedSkillInput {
@@ -116,13 +111,14 @@ interface RetrieveForTurnParams {
 
 export function makeLearnedSkillService(
   db: SurrealDBService,
-  options: { embeddingModel: string; openRouterApiKey?: string },
+  options: { embeddingModel: string; openRouterApiKey?: string; runPromise: RuntimeBridge['runPromise'] },
   skillExistsCache: Cache.Cache<string, boolean, LearnedSkillServiceError>,
-  background: Context.Service.Shape<typeof BackgroundWorkService>,
+  background: Context.Service.Shape<typeof BackgroundWorkServiceTag>,
 ) {
   const embeddings = new ProviderEmbeddings({
     modelId: options.embeddingModel,
     openRouterApiKey: options.openRouterApiKey,
+    runPromise: options.runPromise,
   })
 
   const hasSkillsForAgent = (orgId: string, agentId: string) => Cache.get(skillExistsCache, `${orgId}:${agentId}`)
@@ -159,9 +155,9 @@ export function makeLearnedSkillService(
         hash: input.hash,
       }
 
-      const result = yield* tryLearnedSkillPromise('Failed to create learned skill.', () =>
-        db.create(TABLES.LEARNED_SKILL, data, LearnedSkillRowSchema),
-      )
+      const result = yield* db
+        .create(TABLES.LEARNED_SKILL, data, LearnedSkillRowSchema)
+        .pipe(Effect.mapError((cause) => toLearnedSkillServiceError('Failed to create learned skill.', cause)))
       yield* invalidateSkillExistsCache(input.organizationId, input.agentId)
       return result
     })
@@ -183,9 +179,11 @@ export function makeLearnedSkillService(
       if (input.hash !== undefined) data.hash = input.hash
       if (input.supersedes !== undefined) data.supersedes = ensureRecordId(input.supersedes, TABLES.LEARNED_SKILL)
 
-      const updated = yield* tryLearnedSkillPromise(`Failed to update learned skill ${skillId}.`, () =>
-        db.update(TABLES.LEARNED_SKILL, ref, data, LearnedSkillRowSchema),
-      )
+      const updated = yield* db
+        .update(TABLES.LEARNED_SKILL, ref, data, LearnedSkillRowSchema)
+        .pipe(
+          Effect.mapError((cause) => toLearnedSkillServiceError(`Failed to update learned skill ${skillId}.`, cause)),
+        )
       if (!updated) {
         return yield* new LearnedSkillNotFoundError({ message: `Learned skill ${skillId} not found` })
       }
@@ -196,18 +194,20 @@ export function makeLearnedSkillService(
     Effect.gen(function* () {
       const ref = ensureRecordId(skillId, TABLES.LEARNED_SKILL)
       const skill = yield* getById(skillId)
-      yield* tryLearnedSkillPromise(`Failed to archive learned skill ${skillId}.`, () =>
-        db.update(TABLES.LEARNED_SKILL, ref, { status: 'archived', archivedAt: nowDate() }, LearnedSkillRowSchema),
-      )
+      yield* db
+        .update(TABLES.LEARNED_SKILL, ref, { status: 'archived', archivedAt: nowDate() }, LearnedSkillRowSchema)
+        .pipe(
+          Effect.mapError((cause) => toLearnedSkillServiceError(`Failed to archive learned skill ${skillId}.`, cause)),
+        )
       if (skill) {
         yield* invalidateSkillExistsCache(recordIdToString(skill.organizationId), skill.agentId ?? null)
       }
     })
 
   const getById = (skillId: string): Effect.Effect<LearnedSkillRow | null, LearnedSkillServiceError> =>
-    tryLearnedSkillPromise(`Failed to load learned skill ${skillId}.`, () =>
-      db.findOne(TABLES.LEARNED_SKILL, { id: ensureRecordId(skillId, TABLES.LEARNED_SKILL) }, LearnedSkillRowSchema),
-    )
+    db
+      .findOne(TABLES.LEARNED_SKILL, { id: ensureRecordId(skillId, TABLES.LEARNED_SKILL) }, LearnedSkillRowSchema)
+      .pipe(Effect.mapError((cause) => toLearnedSkillServiceError(`Failed to load learned skill ${skillId}.`, cause)))
 
   const searchForTurn = Effect.fn('LearnedSkillService.searchForTurn')(function* (params: RetrieveForTurnParams) {
     const orgRef = ensureRecordId(params.orgId, TABLES.ORGANIZATION)
@@ -242,22 +242,26 @@ export function makeLearnedSkillService(
       return []
     }
 
-    const queryEmbedding = yield* tryLearnedSkillPromise('Failed to embed learned skill query.', () =>
-      embeddings.embedQuery(params.query),
-    ).pipe(Effect.withSpan('LearnedSkillService.embedQuery'))
+    const queryEmbedding = yield* Effect.tryPromise({
+      try: () => embeddings.embedQuery(params.query),
+      catch: (cause) => toLearnedSkillServiceError('Failed to embed learned skill query.', cause),
+    }).pipe(Effect.withSpan('LearnedSkillService.embedQuery'))
     yield* Effect.annotateCurrentSpan('embeddingLength', queryEmbedding.length)
     if (queryEmbedding.length === 0) return []
 
-    const rows = yield* tryLearnedSkillPromise('Failed to query learned skills.', () =>
-      db.query<unknown>(
+    const rows = yield* db
+      .query<unknown>(
         new BoundQuery(sql, {
           organizationId: orgRef,
           embedding: queryEmbedding,
           agentId: params.agentId,
           minConfidence: params.minConfidence,
         }),
-      ),
-    ).pipe(Effect.withSpan('LearnedSkillService.queryNearestSkills'))
+      )
+      .pipe(
+        Effect.mapError((cause) => toLearnedSkillServiceError('Failed to query learned skills.', cause)),
+        Effect.withSpan('LearnedSkillService.queryNearestSkills'),
+      )
     const parsedRows = yield* Effect.try({
       try: () => rows.map((row) => SearchResultRowSchema.parse(row)),
       catch: (cause) =>
@@ -295,24 +299,32 @@ export function makeLearnedSkillService(
   const recordUsage = (skillId: string) =>
     Effect.gen(function* () {
       const ref = ensureRecordId(skillId, TABLES.LEARNED_SKILL)
-      yield* tryLearnedSkillPromise(`Failed to record usage for learned skill ${skillId}.`, () =>
-        db.query<unknown>(
+      yield* db
+        .query<unknown>(
           new BoundQuery(
             `UPDATE ${TABLES.LEARNED_SKILL} SET usageCount += 1, lastUsedAt = time::now() WHERE id = $id`,
             { id: ref },
           ),
-        ),
-      )
+        )
+        .pipe(
+          Effect.mapError((cause) =>
+            toLearnedSkillServiceError(`Failed to record usage for learned skill ${skillId}.`, cause),
+          ),
+        )
     })
 
   const recordSuccess = (skillId: string) =>
     Effect.gen(function* () {
       const ref = ensureRecordId(skillId, TABLES.LEARNED_SKILL)
-      yield* tryLearnedSkillPromise(`Failed to record success for learned skill ${skillId}.`, () =>
-        db.query<unknown>(
+      yield* db
+        .query<unknown>(
           new BoundQuery(`UPDATE ${TABLES.LEARNED_SKILL} SET successCount += 1 WHERE id = $id`, { id: ref }),
-        ),
-      )
+        )
+        .pipe(
+          Effect.mapError((cause) =>
+            toLearnedSkillServiceError(`Failed to record success for learned skill ${skillId}.`, cause),
+          ),
+        )
     })
 
   const promoteIfEligible = (skillId: string) =>
@@ -326,14 +338,16 @@ export function makeLearnedSkillService(
       if (successRate < PROMOTION_MIN_SUCCESS_RATE) return false
 
       const ref = ensureRecordId(skillId, TABLES.LEARNED_SKILL)
-      yield* tryLearnedSkillPromise(`Failed to promote learned skill ${skillId}.`, () =>
-        db.update(
+      yield* db
+        .update(
           TABLES.LEARNED_SKILL,
           ref,
           { status: 'verified', confidence: Math.min(skill.confidence + 0.1, 1.0) },
           LearnedSkillRowSchema,
-        ),
-      )
+        )
+        .pipe(
+          Effect.mapError((cause) => toLearnedSkillServiceError(`Failed to promote learned skill ${skillId}.`, cause)),
+        )
       return true
     })
 
@@ -353,14 +367,17 @@ export function makeLearnedSkillService(
         LIMIT 1
       `
 
-      const descEmbedding = yield* tryLearnedSkillPromise('Failed to embed learned skill description.', () =>
-        embeddings.embedQuery(description),
-      )
+      const descEmbedding = yield* Effect.tryPromise({
+        try: () => embeddings.embedQuery(description),
+        catch: (cause) => toLearnedSkillServiceError('Failed to embed learned skill description.', cause),
+      })
       if (descEmbedding.length === 0) return null
 
-      const rows = yield* tryLearnedSkillPromise('Failed to query most similar learned skill.', () =>
-        db.query<unknown>(new BoundQuery(sql, { organizationId: orgRef, embedding: descEmbedding })),
-      )
+      const rows = yield* db
+        .query<unknown>(new BoundQuery(sql, { organizationId: orgRef, embedding: descEmbedding }))
+        .pipe(
+          Effect.mapError((cause) => toLearnedSkillServiceError('Failed to query most similar learned skill.', cause)),
+        )
       if (rows.length === 0) return null
       return yield* Effect.try({
         try: () => LearnedSkillRowSchema.parse(rows[0]),
@@ -370,8 +387,8 @@ export function makeLearnedSkillService(
     })
 
   const listForOrg = (orgId: string) =>
-    tryLearnedSkillPromise(`Failed to list learned skills for organization ${orgId}.`, () =>
-      db.queryMany(
+    db
+      .queryMany(
         new BoundQuery(
           `SELECT *, type::string(id) AS id, type::string(organizationId) AS organizationId
            FROM ${TABLES.LEARNED_SKILL}
@@ -381,15 +398,19 @@ export function makeLearnedSkillService(
           { organizationId: ensureRecordId(orgId, TABLES.ORGANIZATION) },
         ),
         LearnedSkillRowSchema,
-      ),
-    )
+      )
+      .pipe(
+        Effect.mapError((cause) =>
+          toLearnedSkillServiceError(`Failed to list learned skills for organization ${orgId}.`, cause),
+        ),
+      )
 
   const findByNameOrTag = (orgId: string, nameOrTag: string) =>
     Effect.gen(function* () {
       const orgRef = ensureRecordId(orgId, TABLES.ORGANIZATION)
       const normalizedRef = nameOrTag.trim().toLowerCase()
-      const rows = yield* tryLearnedSkillPromise(`Failed to find learned skill by name or tag for org ${orgId}.`, () =>
-        db.queryMany(
+      const rows = yield* db
+        .queryMany(
           new BoundQuery(
             `SELECT *, type::string(id) AS id, type::string(organizationId) AS organizationId
            FROM ${TABLES.LEARNED_SKILL}
@@ -401,16 +422,20 @@ export function makeLearnedSkillService(
             { organizationId: orgRef, nameRef: normalizedRef },
           ),
           LearnedSkillRowSchema,
-        ),
-      )
+        )
+        .pipe(
+          Effect.mapError((cause) =>
+            toLearnedSkillServiceError(`Failed to find learned skill by name or tag for org ${orgId}.`, cause),
+          ),
+        )
       return rows[0] ?? null
     })
 
   const findByHash = (orgId: string, hash: string): Effect.Effect<LearnedSkillRow | null, LearnedSkillServiceError> =>
     Effect.gen(function* () {
       const orgRef = ensureRecordId(orgId, TABLES.ORGANIZATION)
-      const rows = yield* tryLearnedSkillPromise(`Failed to find learned skill by hash for org ${orgId}.`, () =>
-        db.queryMany(
+      const rows = yield* db
+        .queryMany(
           new BoundQuery(
             `SELECT *, type::string(id) AS id, type::string(organizationId) AS organizationId
            FROM ${TABLES.LEARNED_SKILL}
@@ -421,8 +446,12 @@ export function makeLearnedSkillService(
             { organizationId: orgRef, hash },
           ),
           LearnedSkillRowSchema,
-        ),
-      )
+        )
+        .pipe(
+          Effect.mapError((cause) =>
+            toLearnedSkillServiceError(`Failed to find learned skill by hash for org ${orgId}.`, cause),
+          ),
+        )
       return rows[0] ?? null
     })
 
@@ -458,14 +487,15 @@ export const LearnedSkillServiceLive = Layer.effect(
   Effect.gen(function* () {
     const db = yield* DatabaseServiceTag
     const runtimeConfig = yield* RuntimeConfigServiceTag
-    const background = yield* BackgroundWorkService
+    const background = yield* BackgroundWorkServiceTag
+    const bridge = yield* RuntimeBridgeTag
     const skillExistsCache = yield* Cache.make({
       lookup: (key: string) =>
         Effect.gen(function* () {
           const [orgId, agentId] = key.split(':', 2) as [string, string]
           const orgRef = ensureRecordId(orgId, TABLES.ORGANIZATION)
-          const rows = yield* tryLearnedSkillPromise('Failed to check learned skill existence cache.', () =>
-            db.query<{ id: unknown }>(
+          const rows = yield* db
+            .query<{ id: unknown }>(
               new BoundQuery(
                 `SELECT id FROM ${TABLES.LEARNED_SKILL}
                  WHERE organizationId = $orgRef
@@ -474,8 +504,12 @@ export const LearnedSkillServiceLive = Layer.effect(
                  LIMIT 1`,
                 { orgRef, agentId },
               ),
-            ),
-          )
+            )
+            .pipe(
+              Effect.mapError((cause) =>
+                toLearnedSkillServiceError('Failed to check learned skill existence cache.', cause),
+              ),
+            )
           return rows.length > 0
         }),
       capacity: 256,
@@ -486,6 +520,7 @@ export const LearnedSkillServiceLive = Layer.effect(
       {
         embeddingModel: runtimeConfig.aiGateway.embeddingModel,
         openRouterApiKey: runtimeConfig.aiGateway.openRouterApiKey,
+        runPromise: bridge.runPromise,
       },
       skillExistsCache,
       background,

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

@@ -1,27 +1,8 @@
-import { Effect, Schema } from 'effect'
+import { Schema } from 'effect'
 
-export class MemoryServiceError extends Schema.TaggedErrorClass<MemoryServiceError>()('MemoryServiceError', {
+import { ERROR_TAGS } from '../../effect/errors'
+
+export class MemoryServiceError extends Schema.TaggedErrorClass<MemoryServiceError>()(ERROR_TAGS.MemoryServiceError, {
   message: Schema.String,
   cause: Schema.Defect,
 }) {}
-
-export function tryMemoryPromise<A, E, R = never>(
-  message: string,
-  thunk: () => PromiseLike<A> | Effect.Effect<A, E, 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 }))
-    }
-  })
-}

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

@@ -1,14 +1,15 @@
-import type { Context } from 'effect'
+import type { Context, Effect as EffectType } from 'effect'
 import { Cache, Duration, Effect } from 'effect'
 
+import type { AiGatewayModels } from '../../ai-gateway/ai-gateway'
 import { aiLogger } from '../../config/logger'
 import { Memory } from '../../db/memory'
 import type { SurrealDBService } from '../../db/service'
 import type { HelperModelRuntime } from '../../runtime/helper-model'
 import { ORG_SCOPE_PREFIX, scopeId } from '../../runtime/memory/memory-scope'
 import type { ResolvedLotaRuntimeConfig } from '../../runtime/runtime-config'
-import { createOrgMemoryAgent, ORG_MEMORY_PROMPT } from '../../system-agents/memory.agent'
-import type { BackgroundWorkService } from '../background-work.service'
+import { makeOrgMemoryAgentFactory, ORG_MEMORY_PROMPT } from '../../system-agents/memory.agent'
+import type { BackgroundWorkServiceTag } from '../background-work.service'
 
 const MAX_ORG_MEMORY_CLIENTS = 128
 
@@ -16,12 +17,15 @@ interface OrgMemoryDeps {
   db: SurrealDBService
   runtimeConfig: ResolvedLotaRuntimeConfig
   helperModelRuntime: HelperModelRuntime
-  background: Context.Service.Shape<typeof BackgroundWorkService>
+  background: Context.Service.Shape<typeof BackgroundWorkServiceTag>
+  aiGatewayModels: AiGatewayModels
+  runPromise: <A, E>(effect: EffectType.Effect<A, E>) => Promise<A>
 }
 
 export type OrgMemoryCache = Cache.Cache<string, Memory>
 
 export function makeOrgMemoryCache(deps: OrgMemoryDeps) {
+  const createAgent = makeOrgMemoryAgentFactory(deps.aiGatewayModels)
   return Cache.make({
     lookup: (cacheKey: string) =>
       Effect.sync(() => {
@@ -32,8 +36,9 @@ export function makeOrgMemoryCache(deps: OrgMemoryDeps) {
             runtimeConfig: deps.runtimeConfig,
             helperModelRuntime: deps.helperModelRuntime,
             background: deps.background,
+            runPromise: deps.runPromise,
           },
-          { createAgent: createOrgMemoryAgent },
+          { createAgent },
           { customPrompt: ORG_MEMORY_PROMPT },
         )
       }),