@lota-sdk/core 0.4.9 → 0.4.11

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

@@ -33,7 +33,7 @@ export function makeSkillResolverService(deps: {
 }
 
 export class SkillResolverServiceTag extends Context.Service<SkillResolverServiceTag, SkillResolverService>()(
-  'SkillResolverService',
+  '@lota-sdk/core/SkillResolverService',
 ) {}
 
 export const SkillResolverServiceLive = Layer.effect(

package/src/services/social-chat-history.service.ts

@@ -1,12 +1,22 @@
 import { normalizeMessageBatch } from '@lota-sdk/shared'
-import { Context, Effect, Layer } from 'effect'
+import { Context, Effect, Layer, Schema } from 'effect'
 import { z } from 'zod'
 
+import { makeEffectTryPromiseWithMessage } from '../effect/helpers'
 import { RedisServiceTag, RuntimeConfigServiceTag } from '../effect/services'
 import type { RedisConnectionManager } from '../redis/connection'
 import type { ResolvedLotaRuntimeConfig } from '../runtime/runtime-config'
 import type { LotaRuntimeBackgroundCursor, LotaRuntimeBackgroundCursorKind } from '../runtime/runtime-extensions'
 
+export class SocialChatHistoryError extends Schema.TaggedErrorClass<SocialChatHistoryError>()(
+  'SocialChatHistoryError',
+  { message: Schema.String, cause: Schema.optional(Schema.Defect) },
+) {}
+
+const tryRedisPromise = makeEffectTryPromiseWithMessage(
+  (message, cause) => new SocialChatHistoryError({ message, cause }),
+)
+
 const DEFAULT_SOCIAL_CHAT_HISTORY_PREFIX = 'lota:social:history'
 
 const SocialChatMessageRoleSchema = z.enum(['user', 'assistant'])
@@ -57,6 +67,8 @@ const SocialChatHistoryMessageSchema = z.object({
   metadata: SocialChatHistoryMetadataSchema.optional(),
   cursor: z.object({ createdAt: z.coerce.date(), id: z.string().trim().min(1) }),
 })
+const SocialChatHistoryCursorSchema = z.object({ createdAt: z.coerce.date(), id: z.string().trim().min(1) })
+const decodeJsonStringEffect = Schema.decodeUnknownEffect(Schema.UnknownFromJsonString)
 
 export type SocialChatHistoryPart = z.infer<typeof SocialChatHistoryPartSchema>
 export type SocialChatHistoryMetadata = z.infer<typeof SocialChatHistoryMetadataSchema>
@@ -101,7 +113,7 @@ export function makeSocialChatHistoryService(
   const parseStoredMessageEffect = (value: string | null): Effect.Effect<SocialChatHistoryMessage | null> => {
     if (!value) return Effect.succeed(null)
 
-    return Effect.try({ try: (): unknown => JSON.parse(value), catch: (cause) => cause }).pipe(
+    return decodeJsonStringEffect(value).pipe(
       Effect.map((parsed) => {
         const validated = SocialChatHistoryMessageSchema.safeParse(parsed)
         return validated.success ? validated.data : null
@@ -116,9 +128,9 @@ export function makeSocialChatHistoryService(
   const parseCursorEffect = (value: string | null): Effect.Effect<LotaRuntimeBackgroundCursor | null> => {
     if (!value) return Effect.succeed(null)
 
-    return Effect.try({ try: (): unknown => JSON.parse(value), catch: (cause) => cause }).pipe(
+    return decodeJsonStringEffect(value).pipe(
       Effect.map((parsed) => {
-        const validated = z.object({ createdAt: z.coerce.date(), id: z.string().trim().min(1) }).safeParse(parsed)
+        const validated = SocialChatHistoryCursorSchema.safeParse(parsed)
         return validated.success ? validated.data : null
       }),
       Effect.catch(() => Effect.succeed(null)),
@@ -145,19 +157,20 @@ export function makeSocialChatHistoryService(
         multi.zadd(workspaceIndexKey(message.workspaceId), score, storageKey)
       }
 
-      yield* Effect.tryPromise(() => multi.exec())
+      yield* tryRedisPromise(() => multi.exec(), 'Failed to upsert social chat messages.')
       return normalizedMessages
     })
 
   const listThreadMessagesEffect = (params: { workspaceId: string; threadId: string }) =>
     Effect.gen(function* () {
       const conn = redis.getConnection()
-      const storageKeys = yield* Effect.tryPromise(() =>
-        conn.zrange(threadIndexKey(params.workspaceId, params.threadId), 0, -1),
+      const storageKeys = yield* tryRedisPromise(
+        () => conn.zrange(threadIndexKey(params.workspaceId, params.threadId), 0, -1),
+        'Failed to list thread message keys.',
       )
       if (storageKeys.length === 0) return [] as SocialChatHistoryMessage[]
 
-      const storedValues = yield* Effect.tryPromise(() => conn.mget(storageKeys))
+      const storedValues = yield* tryRedisPromise(() => conn.mget(storageKeys), 'Failed to read thread messages.')
       const parsedMessages = yield* Effect.forEach(storedValues, parseStoredMessageEffect)
       return parsedMessages
         .filter((message): message is SocialChatHistoryMessage => message !== null)
@@ -175,14 +188,16 @@ export function makeSocialChatHistoryService(
       const scoreStart =
         params.cursor?.createdAt.getTime() ??
         (params.onboardingCutoff ? params.onboardingCutoff.getTime() : Number.NEGATIVE_INFINITY)
-      const storageKeys = yield* Effect.tryPromise(() =>
-        params.cursor || params.onboardingCutoff
-          ? conn.zrangebyscore(indexKey, scoreStart, '+inf')
-          : conn.zrange(indexKey, 0, -1),
+      const storageKeys = yield* tryRedisPromise(
+        () =>
+          params.cursor || params.onboardingCutoff
+            ? conn.zrangebyscore(indexKey, scoreStart, '+inf')
+            : conn.zrange(indexKey, 0, -1),
+        'Failed to list workspace message keys.',
       )
       if (storageKeys.length === 0) return [] as SocialChatHistoryMessage[]
 
-      const storedValues = yield* Effect.tryPromise(() => conn.mget(storageKeys))
+      const storedValues = yield* tryRedisPromise(() => conn.mget(storageKeys), 'Failed to read workspace messages.')
       const parsedMessages = yield* Effect.forEach(storedValues, parseStoredMessageEffect)
       return parsedMessages
         .filter((message): message is SocialChatHistoryMessage => message !== null)
@@ -210,18 +225,20 @@ export function makeSocialChatHistoryService(
     }).pipe(Effect.map((messages) => messages.length > 0))
 
   const getBackgroundCursorEffect = (kind: LotaRuntimeBackgroundCursorKind, workspaceId: string) =>
-    Effect.tryPromise(() => redis.getConnection().get(cursorKey(kind, workspaceId))).pipe(
-      Effect.flatMap((value) => parseCursorEffect(value)),
-    )
+    tryRedisPromise(
+      () => redis.getConnection().get(cursorKey(kind, workspaceId)),
+      'Failed to read background cursor.',
+    ).pipe(Effect.flatMap((value) => parseCursorEffect(value)))
 
   const setBackgroundCursorEffect = (
     kind: LotaRuntimeBackgroundCursorKind,
     workspaceId: string,
     cursor: LotaRuntimeBackgroundCursor,
   ) =>
-    Effect.tryPromise(() => redis.getConnection().set(cursorKey(kind, workspaceId), serializeCursor(cursor))).pipe(
-      Effect.asVoid,
-    )
+    tryRedisPromise(
+      () => redis.getConnection().set(cursorKey(kind, workspaceId), serializeCursor(cursor)),
+      'Failed to write background cursor.',
+    ).pipe(Effect.asVoid)
 
   return {
     upsertMessages: upsertMessagesEffect,
@@ -236,7 +253,7 @@ export function makeSocialChatHistoryService(
 export class SocialChatHistoryServiceTag extends Context.Service<
   SocialChatHistoryServiceTag,
   ReturnType<typeof makeSocialChatHistoryService>
->()('SocialChatHistoryService') {}
+>()('@lota-sdk/core/SocialChatHistoryService') {}
 
 export const SocialChatHistoryServiceLive = Layer.effect(
   SocialChatHistoryServiceTag,

package/src/services/system-executor.service.ts

@@ -1,8 +1,13 @@
 import type { OwnershipDispatchContext, PlanNodeResult, PlanNodeSpec, SystemPlanNodeOwner } from '@lota-sdk/shared'
 import { Context, Effect, Layer } from 'effect'
 
-import { BadRequestError } from '../effect/errors'
+import { BadRequestError, ServiceError } from '../effect/errors'
+import { makeEffectTryPromiseWithMessage } from '../effect/helpers'
 import { RuntimeConfigServiceTag } from '../effect/services'
+
+const trySystemExecutorPromise = makeEffectTryPromiseWithMessage(
+  (message, cause) => new ServiceError({ message, cause }),
+)
 import type { SystemNodeExecutor, PluginNodeExecutionParams } from '../runtime/plugin-types'
 import type { ResolvedLotaRuntimeConfig } from '../runtime/runtime-config'
 import type { PlanValidationIssueInput } from './plan/plan-validator.service'
@@ -86,27 +91,27 @@ export function makeSystemExecutorService(config: ResolvedLotaRuntimeConfig) {
       return []
     },
 
-    executeNode(params: {
+    executeNode: Effect.fn('SystemExecutor.executeNode')(function* (params: {
       nodeSpec: PlanNodeSpec
       resolvedInput: Record<string, unknown>
       context: OwnershipDispatchContext
     }) {
-      return Effect.gen(function* () {
-        const owner = params.nodeSpec.owner
-        if (!isSystemOwner(owner)) {
-          return yield* new BadRequestError({
-            message: `SystemExecutor cannot execute owner type "${owner.executorType}".`,
-          })
-        }
+      const owner = params.nodeSpec.owner
+      if (!isSystemOwner(owner)) {
+        return yield* new BadRequestError({
+          message: `SystemExecutor cannot execute owner type "${owner.executorType}".`,
+        })
+      }
 
-        const executor = getSystemExecutors()[owner.ref]
-        if (!executor || !executor.supportedOperations.includes(owner.operation)) {
-          return yield* new BadRequestError({
-            message: `System executor ${owner.ref}.${owner.operation} is not registered.`,
-          })
-        }
+      const executor = getSystemExecutors()[owner.ref]
+      if (!executor || !executor.supportedOperations.includes(owner.operation)) {
+        return yield* new BadRequestError({
+          message: `System executor ${owner.ref}.${owner.operation} is not registered.`,
+        })
+      }
 
-        return yield* Effect.tryPromise(() =>
+      return yield* trySystemExecutorPromise(
+        () =>
           executor.executeNode(
             buildSystemExecutionParams({
               owner,
@@ -115,16 +120,16 @@ export function makeSystemExecutorService(config: ResolvedLotaRuntimeConfig) {
               context: params.context,
             }),
           ),
-        )
-      })
-    },
+        `System executor "${owner.ref}.${owner.operation}" failed.`,
+      ).pipe(Effect.withSpan('SystemExecutor.invoke'))
+    }),
   }
 }
 
 export class SystemExecutorServiceTag extends Context.Service<
   SystemExecutorServiceTag,
   ReturnType<typeof makeSystemExecutorService>
->()('SystemExecutorService') {}
+>()('@lota-sdk/core/SystemExecutorService') {}
 
 export const SystemExecutorServiceLive = Layer.effect(
   SystemExecutorServiceTag,

package/src/services/thread/thread-bootstrap.ts

@@ -1,13 +1,14 @@
 import { THREAD } from '@lota-sdk/shared'
 import { Effect } from 'effect'
 
-import { getAgentDisplayNames, getAgentRoster, getCoreThreadProfile } from '../../config/agent-defaults'
+import type { ResolvedAgentConfig } from '../../config/agent-defaults'
 import { serverLogger } from '../../config/logger'
-import { getThreadBootstrapConfig } from '../../config/thread-defaults'
+import type { ResolvedThreadBootstrapConfig } from '../../config/thread-defaults'
 import type { RecordIdRef } from '../../db/record-id'
 import { ensureRecordId, recordIdToString } from '../../db/record-id'
 import { TABLES } from '../../db/tables'
 import { BadRequestError, DatabaseError } from '../../effect/errors'
+import type { LockAcquisitionError, LockLostError, NotFoundError, RedisError, ServiceError } from '../../effect/errors'
 import type { RedisConnectionManager } from '../../redis/connection'
 import { withLeaseLock } from '../../redis/redis-lease-lock'
 import type { makeThreadMessageService } from './thread-message.service'
@@ -19,8 +20,8 @@ const THREAD_BOOTSTRAP_LOCK_REFRESH_INTERVAL_MS = 5_000
 const THREAD_BOOTSTRAP_LOCK_MAX_WAIT_MS = 5_000
 const THREAD_BOOTSTRAP_LOCK_RETRY_DELAY_MS = 100
 
-function getAgentDisplayName(agentId: string): string {
-  return getAgentDisplayNames()[agentId] ?? agentId
+function getAgentDisplayName(agentConfig: ResolvedAgentConfig, agentId: string): string {
+  return agentConfig.displayNames[agentId] ?? agentId
 }
 
 function buildBootstrapThreadsLockKey(userId: RecordIdRef, orgId: RecordIdRef): string {
@@ -31,9 +32,26 @@ function haveSameMembers(left: string[], right: string[]): boolean {
   return left.length === right.length && left.every((value, index) => value === right[index])
 }
 
-type NormalizedThreadFactory = (thread: ThreadRecord) => Effect.Effect<NormalizedThread, unknown>
+type ThreadNormalizationError = BadRequestError | ServiceError
+type ThreadBootstrapError =
+  | BadRequestError
+  | DatabaseError
+  | LockAcquisitionError
+  | LockLostError
+  | NotFoundError
+  | RedisError
+  | ServiceError
+
+type NormalizedThreadFactory = (thread: ThreadRecord) => Effect.Effect<NormalizedThread, ThreadNormalizationError>
+type DuplicateCreateErrorLike = { cause?: unknown; message?: unknown }
+
+function isDuplicateCreateErrorLike(value: unknown): value is DuplicateCreateErrorLike {
+  return (typeof value === 'object' || typeof value === 'function') && value !== null
+}
 
 export function createThreadBootstrapHelpers(deps: {
+  agentConfig: ResolvedAgentConfig
+  threadBootstrapConfig: ResolvedThreadBootstrapConfig
   threadStore: ThreadRecordStore
   threadMessageService: Pick<ReturnType<typeof makeThreadMessageService>, 'ensureBootstrapWelcomeMessageEffect'>
   redis: RedisConnectionManager
@@ -85,26 +103,26 @@ export function createThreadBootstrapHelpers(deps: {
     const seen = new Set<unknown>()
     let current = error
 
-    while ((typeof current === 'object' || typeof current === 'function') && current !== null && !seen.has(current)) {
+    while (isDuplicateCreateErrorLike(current) && !seen.has(current)) {
       seen.add(current)
-      const message = Reflect.get(current, 'message')
-      if (typeof message === 'string' && message.includes('already contains')) {
+      if (typeof current.message === 'string' && current.message.includes('already contains')) {
         return true
       }
-      current = Reflect.get(current, 'cause')
+      current = current.cause
     }
 
     return false
   }
 
-  const normalizeThreadEffect = (thread: ThreadRecord) => deps.normalizeThread(thread)
+  const normalizeThreadEffect = (thread: ThreadRecord): Effect.Effect<NormalizedThread, ThreadNormalizationError> =>
+    deps.normalizeThread(thread)
 
   const getOrCreateDefaultEffect = (
     orgId: RecordIdRef,
     userId: RecordIdRef,
     agentId: string,
     config?: { title?: string; nameGenerated?: boolean },
-  ) => {
+  ): Effect.Effect<{ created: boolean; record: ThreadRecord }, DatabaseError | NotFoundError> => {
     const lookup = { type: 'default' as const, organizationId: orgId, userId, agentId }
 
     return Effect.gen(function* () {
@@ -121,7 +139,7 @@ export function createThreadBootstrapHelpers(deps: {
           userId,
           agentId,
           members: [agentId],
-          title: config?.title ?? getAgentDisplayName(agentId),
+          title: config?.title ?? getAgentDisplayName(deps.agentConfig, agentId),
           status: 'active',
           nameGenerated: config?.nameGenerated ?? false,
           isCompacting: false,
@@ -150,7 +168,7 @@ export function createThreadBootstrapHelpers(deps: {
     userId: RecordIdRef,
     threadType: string,
     config: { members: string[]; title: string; nameGenerated?: boolean },
-  ) => {
+  ): Effect.Effect<{ created: boolean; record: ThreadRecord }, DatabaseError | NotFoundError> => {
     const lookup = { type: 'thread' as const, organizationId: orgId, userId, threadType }
 
     return Effect.gen(function* () {
@@ -199,7 +217,7 @@ export function createThreadBootstrapHelpers(deps: {
     threadType?: string
     members?: string[]
     title?: string
-  }) =>
+  }): Effect.Effect<NormalizedThread, ThreadBootstrapError> =>
     Effect.gen(function* () {
       switch (input.type) {
         case 'default':
@@ -234,7 +252,7 @@ export function createThreadBootstrapHelpers(deps: {
         const threadType = input.threadType
         if (!threadType) return yield* new BadRequestError({ message: 'Thread threads require threadType' })
         const { record } = yield* getOrCreateThreadEffect(input.organizationId, input.userId, threadType, {
-          members: input.members ?? [...getAgentRoster()],
+          members: input.members ?? [...deps.agentConfig.roster],
           title,
           nameGenerated,
         })
@@ -247,7 +265,7 @@ export function createThreadBootstrapHelpers(deps: {
         type: input.type,
         agentId: input.agentId,
         threadType: input.threadType,
-        members: input.members ?? [...getAgentRoster()],
+        members: input.members ?? [...deps.agentConfig.roster],
         title,
         status: 'active',
         nameGenerated,
@@ -262,8 +280,8 @@ export function createThreadBootstrapHelpers(deps: {
     userId: RecordIdRef,
     orgId: RecordIdRef,
     options?: { onboardStatus?: string; userName?: string | null },
-  ) => {
-    const bootstrapConfig = getThreadBootstrapConfig()
+  ): Effect.Effect<void, ThreadBootstrapError> => {
+    const bootstrapConfig = deps.threadBootstrapConfig
 
     return withLeaseLock(
       {
@@ -326,7 +344,7 @@ export function createThreadBootstrapHelpers(deps: {
           if (onboardingCompleted) {
             for (const wsType of bootstrapConfig.threadTypesAfterOnboarding) {
               if (threadThreadsByType.has(wsType)) continue
-              const profile = getCoreThreadProfile(wsType)
+              const profile = deps.agentConfig.getCoreThreadProfile(wsType)
               yield* getOrCreateThreadEffect(orgId, userId, wsType, {
                 members: [...profile.members],
                 title: profile.config.title,

package/src/services/thread/thread-listing.ts

@@ -5,6 +5,7 @@ import { BoundQuery } from 'surrealdb'
 import type { RecordIdRef } from '../../db/record-id'
 import type { SurrealDBService } from '../../db/service'
 import { TABLES } from '../../db/tables'
+import type { BadRequestError, ServiceError } from '../../effect/errors'
 import { makeEffectTryPromiseWithMessage } from '../../effect/helpers'
 import { ThreadSchema } from './thread.types'
 import type { NormalizedThread, ThreadRecord } from './thread.types'
@@ -38,7 +39,7 @@ export function createThreadListingHelpers(deps: {
   normalizeThreads(
     threads: ThreadRecord[],
     options?: { checkLease?: boolean },
-  ): Effect.Effect<NormalizedThread[], unknown>
+  ): Effect.Effect<NormalizedThread[], BadRequestError | ServiceError>
 }) {
   class ThreadListingError extends Schema.TaggedErrorClass<ThreadListingError>()('ThreadListingError', {
     message: Schema.String,

package/src/services/thread/thread-memory-block.ts

@@ -1,3 +1,4 @@
+import type { Context } from 'effect'
 import { Schema, Effect } from 'effect'
 
 import { serverLogger } from '../../config/logger'
@@ -9,16 +10,19 @@ import {
   appendToMemoryBlock,
   compactMemoryBlockEntries,
   formatPersistedMemoryBlockForPrompt,
+  MemoryBlockCompactError,
   parseMemoryBlock,
   serializeMemoryBlock,
 } from '../../runtime/memory/memory-block'
+import type { BackgroundWorkService } from '../background-work.service'
+import type { makeContextCompactionService } from '../context-compaction.service'
 import { MEMORY_BLOCK_COMPACTION_CHUNK_ENTRIES, MEMORY_BLOCK_COMPACTION_TRIGGER_ENTRIES } from './thread-constants'
 import type { ThreadRecordStore } from './thread-record-store'
 import type { ThreadRecord } from './thread.types'
 
-type ContextCompactionServiceLike = {
-  compactMemoryBlock(params: { previousSummary: string; newEntriesText: string }): Effect.Effect<string, unknown>
-}
+type ContextCompactionServiceLike = Pick<ReturnType<typeof makeContextCompactionService>, 'compactMemoryBlock'>
+
+type BackgroundWorker = Context.Service.Shape<typeof BackgroundWorkService>
 
 class ThreadMemoryBlockError extends Schema.TaggedErrorClass<ThreadMemoryBlockError>()('ThreadMemoryBlockError', {
   message: Schema.String,
@@ -39,6 +43,7 @@ export function formatMemoryBlockForPrompt(thread: Pick<ThreadRecord, 'memoryBlo
 export function createThreadMemoryBlockHelpers(deps: {
   threadStore: ThreadRecordStore
   contextCompactionService: ContextCompactionServiceLike
+  background: BackgroundWorker
 }) {
   function appendMemoryBlock(threadId: RecordIdRef, entry: string): Effect.Effect<string, ThreadMemoryBlockError> {
     return Effect.gen(function* () {
@@ -63,7 +68,7 @@ export function createThreadMemoryBlockHelpers(deps: {
       )
 
       if (updatedEntries.length >= MEMORY_BLOCK_COMPACTION_TRIGGER_ENTRIES) {
-        yield* Effect.forkDetach(
+        yield* deps.background.run(
           compactMemoryBlock(threadRef).pipe(
             Effect.catch((error: unknown) =>
               Effect.sync(() => {
@@ -71,6 +76,7 @@ export function createThreadMemoryBlockHelpers(deps: {
               }),
             ),
           ),
+          'thread-memory-block.compactMemoryBlock',
         )
       }
 
@@ -93,7 +99,14 @@ export function createThreadMemoryBlockHelpers(deps: {
             entries: parseMemoryBlock(thread.memoryBlock),
             triggerEntries: MEMORY_BLOCK_COMPACTION_TRIGGER_ENTRIES,
             chunkEntries: MEMORY_BLOCK_COMPACTION_CHUNK_ENTRIES,
-            compact: (params) => deps.contextCompactionService.compactMemoryBlock(params),
+            compact: (params) =>
+              deps.contextCompactionService
+                .compactMemoryBlock(params)
+                .pipe(
+                  Effect.mapError(
+                    (cause) => new MemoryBlockCompactError({ message: 'compact callback failed', cause }),
+                  ),
+                ),
           }),
         `Failed to compact memory block for thread ${threadIdString}`,
       )

package/src/services/thread/thread-message.service.ts

@@ -3,8 +3,9 @@ import type { ChatMessage } from '@lota-sdk/shared'
 import { Context, Effect, Layer } from 'effect'
 import { RecordId, surql } from 'surrealdb'
 import { z } from 'zod'
+import type { ZodTypeAny } from 'zod'
 
-import { getAgentDisplayNames } from '../../config/agent-defaults'
+import type { ResolvedAgentConfig } from '../../config/agent-defaults'
 import { CursorRowSchema, listMessageHistoryPageEffect } from '../../db/cursor-pagination'
 import type { CursorPaginationConfig } from '../../db/cursor-pagination'
 import { ensureRecordId, recordIdToString } from '../../db/record-id'
@@ -15,12 +16,23 @@ import { ThreadMessageRowSchema } from '../../db/thread-message-row'
 import type { ThreadMessageRow } from '../../db/thread-message-row'
 import { ServiceError } from '../../effect/errors'
 import { effectTryServicePromise } from '../../effect/helpers'
-import { DatabaseServiceTag } from '../../effect/services'
+import { AgentConfigServiceTag, DatabaseServiceTag } from '../../effect/services'
 import { sha256Hex } from '../../utils/crypto'
 import { nowEpochMillis, unsafeDateFrom } from '../../utils/date-time'
 
 const ThreadMessageExistingRowSchema = z.object({ id: recordIdSchema, createdAt: z.coerce.date() })
 
+function parseRowOrFail<TSchema extends ZodTypeAny>(
+  schema: TSchema,
+  value: unknown,
+  operation: string,
+): Effect.Effect<z.infer<TSchema>, ServiceError> {
+  return Effect.try({
+    try: () => schema.parse(value) as z.infer<TSchema>,
+    catch: (cause) => new ServiceError({ message: `Failed to parse row for ${operation}.`, cause }),
+  })
+}
+
 function toMessageId(value: string | RecordIdRef): string {
   return recordIdToString(value, TABLES.THREAD_MESSAGE)
 }
@@ -94,7 +106,7 @@ const threadPaginationConfig: CursorPaginationConfig = {
   `,
 }
 
-export function makeThreadMessageService(db: SurrealDBService) {
+export function makeThreadMessageService(db: SurrealDBService, agentConfig: ResolvedAgentConfig) {
   function upsertMessages(params: { threadId: RecordIdRef; messages: ChatMessage[] }) {
     const threadId = toThreadRef(params.threadId)
     return Effect.forEach(params.messages, (message) =>
@@ -160,7 +172,10 @@ export function makeThreadMessageService(db: SurrealDBService) {
       `),
         'Failed to list thread messages.',
       ).pipe(
-        Effect.map((rows) => rows.map((row) => ThreadMessageRowSchema.parse(row)).map((row) => toChatMessage(row))),
+        Effect.flatMap((rows) =>
+          Effect.forEach(rows, (row) => parseRowOrFail(ThreadMessageRowSchema, row, 'listMessages')),
+        ),
+        Effect.map((rows) => rows.map((row) => toChatMessage(row))),
       )
     },
     listMessagesEffect(threadId: RecordIdRef) {
@@ -210,7 +225,10 @@ export function makeThreadMessageService(db: SurrealDBService) {
           `),
           'Failed to list thread messages after cursor.',
         )
-        return rows.map((row) => ThreadMessageRowSchema.parse(row)).map((row) => toChatMessage(row))
+        const parsedRows = yield* Effect.forEach(rows, (row) =>
+          parseRowOrFail(ThreadMessageRowSchema, row, 'listMessagesAfterCursor'),
+        )
+        return parsedRows.map((row) => toChatMessage(row))
       })
     },
     listMessagesAfterCursorEffect(threadId: RecordIdRef, afterMessageId?: string) {
@@ -229,12 +247,10 @@ export function makeThreadMessageService(db: SurrealDBService) {
       `),
         'Failed to list recent thread messages.',
       ).pipe(
-        Effect.map((rows) =>
-          rows
-            .map((row) => ThreadMessageRowSchema.parse(row))
-            .reverse()
-            .map((row) => toChatMessage(row)),
+        Effect.flatMap((rows) =>
+          Effect.forEach(rows, (row) => parseRowOrFail(ThreadMessageRowSchema, row, 'listRecentMessages')),
         ),
+        Effect.map((rows) => rows.reverse().map((row) => toChatMessage(row))),
       )
     },
     listRecentMessagesEffect(threadId: RecordIdRef, limit: number) {
@@ -333,7 +349,7 @@ export function makeThreadMessageService(db: SurrealDBService) {
               parts: [{ type: 'text', text: messageText }],
               metadata: {
                 agentId: params.agentId,
-                agentName: getAgentDisplayNames()[params.agentId] ?? params.agentId,
+                agentName: agentConfig.displayNames[params.agentId] ?? params.agentId,
                 createdAt: nowEpochMillis(),
               },
             },
@@ -352,12 +368,13 @@ export function makeThreadMessageService(db: SurrealDBService) {
 export class ThreadMessageServiceTag extends Context.Service<
   ThreadMessageServiceTag,
   ReturnType<typeof makeThreadMessageService>
->()('ThreadMessageService') {}
+>()('@lota-sdk/core/ThreadMessageService') {}
 
 export const ThreadMessageServiceLive = Layer.effect(
   ThreadMessageServiceTag,
   Effect.gen(function* () {
     const db = yield* DatabaseServiceTag
-    return makeThreadMessageService(db)
+    const agentConfig = yield* AgentConfigServiceTag
+    return makeThreadMessageService(db, agentConfig)
   }),
 )

package/src/services/thread/thread-title.service.ts

@@ -62,7 +62,7 @@ export function makeThreadTitleService(
 export class ThreadTitleServiceTag extends Context.Service<
   ThreadTitleServiceTag,
   ReturnType<typeof makeThreadTitleService>
->()('ThreadTitleService') {}
+>()('@lota-sdk/core/ThreadTitleService') {}
 
 export const ThreadTitleServiceLive = Layer.effect(
   ThreadTitleServiceTag,