@lota-sdk/core 0.4.10 → 0.4.12

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

@@ -1,9 +1,4 @@
-import type {
-  ExecutionPlanToolResultData,
-  PlanFailureClass,
-  PlanNodeResultSubmission,
-  SerializableExecutionPlan,
-} from '@lota-sdk/shared'
+import type { PlanFailureClass, PlanNodeResultSubmission } from '@lota-sdk/shared'
 import { PlanNodeAttemptSchema, PlanNodeRunSchema } from '@lota-sdk/shared'
 import { Context, Schema, Effect, Layer } from 'effect'
 import type { z } from 'zod'
@@ -15,8 +10,9 @@ import type { DatabaseTransaction } from '../../db/service'
 import { TABLES } from '../../db/tables'
 import { BadRequestError, NotFoundError } from '../../effect/errors'
 import { effectTryPromise as effectTryPromiseShared } from '../../effect/helpers'
-import { runPromise } from '../../effect/runtime'
 import { DatabaseServiceTag } from '../../effect/services'
+import type { DelayedNodePromotionQueueRuntime } from '../../queues/delayed-node-promotion.queue'
+import { LotaQueuesServiceTag } from '../../queues/queues.service'
 import { GeneratedDocumentStorageServiceTag } from '../../storage/generated-document-storage.service'
 import { nowDate } from '../../utils/date-time'
 import { toError } from '../../utils/errors'
@@ -76,6 +72,7 @@ interface PlanExecutorDeps {
   planSchedulerService: Context.Service.Shape<typeof PlanSchedulerServiceTag>
   planValidatorService: Context.Service.Shape<typeof PlanValidatorServiceTag>
   qualityMetricsService: Context.Service.Shape<typeof QualityMetricsServiceTag>
+  delayedNodePromotionQueue: DelayedNodePromotionQueueRuntime
 }
 
 type PlanExecutorService = ReturnType<typeof makePlanExecutorService>
@@ -1113,7 +1110,7 @@ function handleAcceptedHumanNodeResponseEffect(
   })
 }
 
-const submitNodeResultEffect = Effect.fn('PlanExecutor.submitNodeResult')(function* (
+const submitNodeResult = Effect.fn('PlanExecutor.submitNodeResult')(function* (
   context: PlanExecutorContext,
   params: {
     threadId: RecordIdInput
@@ -1231,21 +1228,7 @@ const submitNodeResultEffect = Effect.fn('PlanExecutor.submitNodeResult')(functi
   })
 })
 
-/** @lintignore */
-function submitNodeResult(
-  context: PlanExecutorContext,
-  params: {
-    threadId: RecordIdInput
-    runId: string
-    nodeId: string
-    emittedBy: string
-    result: PlanNodeResultSubmission
-  },
-): Promise<ExecutionPlanToolResultData> {
-  return submitNodeResultEffect(context, params).pipe(runPromise)
-}
-
-const submitHumanNodeResponseEffect = Effect.fn('PlanExecutor.submitHumanNodeResponse')(function* (
+const submitHumanNodeResponse = Effect.fn('PlanExecutor.submitHumanNodeResponse')(function* (
   context: PlanExecutorContext,
   params: {
     threadId: RecordIdInput
@@ -1296,21 +1279,7 @@ const submitHumanNodeResponseEffect = Effect.fn('PlanExecutor.submitHumanNodeRes
   }).pipe(Effect.withSpan('PlanExecutor.submitHumanNodeResponse.persistTransaction'))
 })
 
-/** @lintignore */
-function submitHumanNodeResponse(
-  context: PlanExecutorContext,
-  params: {
-    threadId: RecordIdInput
-    approvalId?: string
-    respondedBy: string
-    response: HumanNodeResponsePayload
-    approvalMessageId?: string
-  },
-): Promise<SerializableExecutionPlan | null> {
-  return submitHumanNodeResponseEffect(context, params).pipe(runPromise)
-}
-
-const resumeRunEffect = Effect.fn('PlanExecutor.resumeRun')(function* (
+const resumeRun = Effect.fn('PlanExecutor.resumeRun')(function* (
   context: PlanExecutorContext,
   params: { threadId: RecordIdInput; runId: string; emittedBy: string },
 ) {
@@ -1414,15 +1383,7 @@ const resumeRunEffect = Effect.fn('PlanExecutor.resumeRun')(function* (
   })
 })
 
-/** @lintignore */
-function resumeRun(
-  context: PlanExecutorContext,
-  params: { threadId: RecordIdInput; runId: string; emittedBy: string },
-): Promise<ExecutionPlanToolResultData> {
-  return resumeRunEffect(context, params).pipe(runPromise)
-}
-
-const transitionNodeToRunningEffect = Effect.fn('PlanExecutor.transitionNodeToRunning')(function* (
+const transitionNodeToRunning = Effect.fn('PlanExecutor.transitionNodeToRunning')(function* (
   context: PlanExecutorContext,
   params: { runId: string; nodeId: string },
 ) {
@@ -1455,15 +1416,7 @@ const transitionNodeToRunningEffect = Effect.fn('PlanExecutor.transitionNodeToRu
   ).pipe(Effect.withSpan('PlanExecutor.transitionNodeToRunning.persistTransaction'))
 })
 
-/** @lintignore */
-function transitionNodeToRunning(
-  context: PlanExecutorContext,
-  params: { runId: string; nodeId: string },
-): Promise<void> {
-  return transitionNodeToRunningEffect(context, params).pipe(runPromise)
-}
-
-const blockNodeOnDispatchFailureEffect = Effect.fn('PlanExecutor.blockNodeOnDispatchFailure')(function* (
+const blockNodeOnDispatchFailure = Effect.fn('PlanExecutor.blockNodeOnDispatchFailure')(function* (
   context: PlanExecutorContext,
   params: {
     threadId: RecordIdInput
@@ -1551,22 +1504,7 @@ const blockNodeOnDispatchFailureEffect = Effect.fn('PlanExecutor.blockNodeOnDisp
   }).pipe(Effect.withSpan('PlanExecutor.blockNodeOnDispatchFailure.persistTransaction'))
 })
 
-/** @lintignore */
-function blockNodeOnDispatchFailure(
-  context: PlanExecutorContext,
-  params: {
-    threadId: RecordIdInput
-    runId: string
-    nodeId: string
-    emittedBy: string
-    message: string
-    failureClass: PlanFailureClass
-  },
-): Promise<SerializableExecutionPlan> {
-  return blockNodeOnDispatchFailureEffect(context, params).pipe(runPromise)
-}
-
-const promoteDelayedNodeEffect = Effect.fn('PlanExecutor.promoteDelayedNode')(function* (
+const promoteDelayedNode = Effect.fn('PlanExecutor.promoteDelayedNode')(function* (
   context: PlanExecutorContext,
   params: { runId: string; nodeId: string; emittedBy: string },
 ) {
@@ -1647,14 +1585,6 @@ const promoteDelayedNodeEffect = Effect.fn('PlanExecutor.promoteDelayedNode')(fu
   }).pipe(Effect.withSpan('PlanExecutor.promoteDelayedNode.persistTransaction'))
 })
 
-/** @lintignore */
-function promoteDelayedNode(
-  context: PlanExecutorContext,
-  params: { runId: string; nodeId: string; emittedBy: string },
-): Promise<void> {
-  return promoteDelayedNodeEffect(context, params).pipe(runPromise)
-}
-
 export function makePlanExecutorService(deps: PlanExecutorDeps) {
   const context: PlanExecutorContext = {
     databaseService: deps.db,
@@ -1671,6 +1601,7 @@ export function makePlanExecutorService(deps: PlanExecutorDeps) {
     planSchedulerService: deps.planSchedulerService,
     planValidatorService: deps.planValidatorService,
     qualityMetricsService: deps.qualityMetricsService,
+    delayedNodePromotionQueue: deps.delayedNodePromotionQueue,
     planCompletionSideEffects: makePlanCompletionSideEffects({
       databaseService: deps.db,
       feedbackLoopService: deps.feedbackLoopService,
@@ -1683,25 +1614,14 @@ export function makePlanExecutorService(deps: PlanExecutorDeps) {
 
   return {
     submitNodeResult: (params: Parameters<typeof submitNodeResult>[1]) => submitNodeResult(context, params),
-    submitNodeResultEffect: (params: Parameters<typeof submitNodeResultEffect>[1]) =>
-      submitNodeResultEffect(context, params),
     submitHumanNodeResponse: (params: Parameters<typeof submitHumanNodeResponse>[1]) =>
       submitHumanNodeResponse(context, params),
-    submitHumanNodeResponseEffect: (params: Parameters<typeof submitHumanNodeResponseEffect>[1]) =>
-      submitHumanNodeResponseEffect(context, params),
     resumeRun: (params: Parameters<typeof resumeRun>[1]) => resumeRun(context, params),
-    resumeRunEffect: (params: Parameters<typeof resumeRunEffect>[1]) => resumeRunEffect(context, params),
     transitionNodeToRunning: (params: Parameters<typeof transitionNodeToRunning>[1]) =>
       transitionNodeToRunning(context, params),
-    transitionNodeToRunningEffect: (params: Parameters<typeof transitionNodeToRunningEffect>[1]) =>
-      transitionNodeToRunningEffect(context, params),
     blockNodeOnDispatchFailure: (params: Parameters<typeof blockNodeOnDispatchFailure>[1]) =>
       blockNodeOnDispatchFailure(context, params),
-    blockNodeOnDispatchFailureEffect: (params: Parameters<typeof blockNodeOnDispatchFailureEffect>[1]) =>
-      blockNodeOnDispatchFailureEffect(context, params),
     promoteDelayedNode: (params: Parameters<typeof promoteDelayedNode>[1]) => promoteDelayedNode(context, params),
-    promoteDelayedNodeEffect: (params: Parameters<typeof promoteDelayedNodeEffect>[1]) =>
-      promoteDelayedNodeEffect(context, params),
     syncRunGraph: (params: Parameters<typeof syncRunGraph>[1]) => syncRunGraph(context, params),
     resolveFailureAction,
     buildResolvedInput,
@@ -1717,6 +1637,7 @@ export const PlanExecutorServiceLive = Layer.effect(
   Effect.gen(function* () {
     const db = yield* DatabaseServiceTag
     const storage = yield* GeneratedDocumentStorageServiceTag
+    const queues = yield* LotaQueuesServiceTag
     return makePlanExecutorService({
       db,
       storage,
@@ -1732,6 +1653,7 @@ export const PlanExecutorServiceLive = Layer.effect(
       planSchedulerService: yield* PlanSchedulerServiceTag,
       planValidatorService: yield* PlanValidatorServiceTag,
       qualityMetricsService: yield* QualityMetricsServiceTag,
+      delayedNodePromotionQueue: queues.delayedNodePromotion,
     })
   }),
 )

package/src/services/plan/plan-scheduler.service.ts

@@ -10,6 +10,8 @@ import { TABLES } from '../../db/tables'
 import { NotFoundError } from '../../effect/errors'
 import { makeEffectTryPromiseWithMessage } from '../../effect/helpers'
 import { DatabaseServiceTag } from '../../effect/services'
+import type { PlanSchedulerQueueRuntime } from '../../queues/plan-scheduler.queue'
+import { LotaQueuesServiceTag } from '../../queues/queues.service'
 import { nowDate, nowEpochMillis, toDatabaseDateTime, unsafeDateFrom } from '../../utils/date-time'
 
 interface PlanSchedulerRuntimeDeps {
@@ -25,65 +27,75 @@ class PlanSchedulerError extends Schema.TaggedErrorClass<PlanSchedulerError>()('
 
 const effectTryPromise = makeEffectTryPromiseWithMessage((message, cause) => new PlanSchedulerError({ message, cause }))
 
-function failPlanScheduler(message: string, cause?: unknown): Effect.Effect<never, PlanSchedulerError> {
-  return Effect.fail(new PlanSchedulerError({ message, ...(cause === undefined ? {} : { cause }) }))
+function requireScheduleField<A>(value: A | undefined, message: string): A {
+  if (value === undefined) {
+    throw new PlanSchedulerError({ message })
+  }
+  return value
 }
 
-function requireScheduleField<A>(value: A | undefined, message: string): Effect.Effect<A, PlanSchedulerError> {
-  return value === undefined ? failPlanScheduler(message) : Effect.succeed(value)
-}
+function computeNextCronDate(cronExpression: string, baseTime: Date): Date {
+  const parsedCron = Cron.parse(cronExpression)
+  if (!Result.isSuccess(parsedCron)) {
+    throw new PlanSchedulerError({ message: `Invalid cron expression: "${cronExpression}".` })
+  }
 
-const computeNextCronDateEffect: (cronExpression: string, baseTime: Date) => Effect.Effect<Date, PlanSchedulerError> =
-  Effect.fn('PlanScheduler.computeNextCronDate')(function* (cronExpression: string, baseTime: Date) {
-    const parsedCron = Cron.parse(cronExpression)
-    const cron = Result.isSuccess(parsedCron)
-      ? parsedCron.success
-      : yield* failPlanScheduler(`Invalid cron expression: "${cronExpression}".`)
-
-    return yield* Effect.try({
-      try: () => Cron.next(cron, baseTime),
-      catch: (cause) =>
-        new PlanSchedulerError({
-          message: `Failed to compute the next fire time for cron expression "${cronExpression}".`,
-          cause,
-        }),
+  try {
+    return Cron.next(parsedCron.success, baseTime)
+  } catch (cause) {
+    throw new PlanSchedulerError({
+      message: `Failed to compute the next fire time for cron expression "${cronExpression}".`,
+      cause,
     })
-  })
-
-const computeNextFireAtEffect: (spec: PlanScheduleSpec, baseTime?: Date) => Effect.Effect<Date, PlanSchedulerError> =
-  Effect.fn('PlanScheduler.computeNextFireAt')(function* (spec: PlanScheduleSpec, baseTime: Date = nowDate()) {
-    switch (spec.type) {
-      case 'immediate':
-        return baseTime
+  }
+}
 
-      case 'absolute': {
-        const at = yield* requireScheduleField(spec.at, 'Absolute schedules require an "at" timestamp.')
-        return unsafeDateFrom(at)
-      }
+// `computeNextFireAt` must stay purely synchronous — no Clock, no service lookups, no async.
+// `computeNextFireAtEffect` wraps it with `Effect.try` so the same logic is composable from
+// Effect callers without an `Effect.runSync` round trip.
+function computeNextFireAt(spec: PlanScheduleSpec, baseTime: Date = nowDate()): Date {
+  switch (spec.type) {
+    case 'immediate':
+      return baseTime
 
-      case 'relative': {
-        const delayMs = yield* requireScheduleField(spec.delayMs, 'Relative schedules require "delayMs".')
-        return unsafeDateFrom(baseTime.getTime() + delayMs)
-      }
+    case 'absolute':
+      return unsafeDateFrom(requireScheduleField(spec.at, 'Absolute schedules require an "at" timestamp.'))
 
-      case 'cron': {
-        const cronExpression = yield* requireScheduleField(spec.cron, 'Cron schedules require a "cron" expression.')
-        return yield* computeNextCronDateEffect(cronExpression, baseTime)
-      }
+    case 'relative': {
+      const delayMs = requireScheduleField(spec.delayMs, 'Relative schedules require "delayMs".')
+      return unsafeDateFrom(baseTime.getTime() + delayMs)
+    }
 
-      case 'monitoring': {
-        const intervalMs = yield* requireScheduleField(spec.intervalMs, 'Monitoring schedules require "intervalMs".')
-        return unsafeDateFrom(baseTime.getTime() + intervalMs)
-      }
+    case 'cron': {
+      const cronExpression = requireScheduleField(spec.cron, 'Cron schedules require a "cron" expression.')
+      return computeNextCronDate(cronExpression, baseTime)
+    }
 
-      default:
-        return yield* failPlanScheduler('Unsupported schedule type in schedule specification.')
+    case 'monitoring': {
+      const intervalMs = requireScheduleField(spec.intervalMs, 'Monitoring schedules require "intervalMs".')
+      return unsafeDateFrom(baseTime.getTime() + intervalMs)
     }
+
+    default:
+      throw new PlanSchedulerError({ message: 'Unsupported schedule type in schedule specification.' })
+  }
+}
+
+const isPlanSchedulerError = Schema.is(PlanSchedulerError)
+
+function computeNextFireAtEffect(spec: PlanScheduleSpec, baseTime?: Date): Effect.Effect<Date, PlanSchedulerError> {
+  return Effect.try({
+    try: () => computeNextFireAt(spec, baseTime),
+    catch: (cause) =>
+      isPlanSchedulerError(cause)
+        ? cause
+        : new PlanSchedulerError({ message: 'Failed to compute the next fire time.', cause }),
   })
+}
 
-export function makePlanSchedulerService(db: SurrealDBService) {
-  const loadPlanSchedulerQueue = () =>
-    effectTryPromise(() => import('../../queues/plan-scheduler.queue'), 'Failed to load plan scheduler queue module.')
+export function makePlanSchedulerService(db: SurrealDBService, schedulerQueue: PlanSchedulerQueueRuntime) {
+  const loadPlanSchedulerQueue = (): Effect.Effect<PlanSchedulerQueueRuntime, PlanSchedulerError> =>
+    Effect.succeed(schedulerQueue)
 
   const createScheduleEffect = (params: {
     organizationId: RecordIdInput
@@ -351,7 +363,7 @@ export function makePlanSchedulerService(db: SurrealDBService) {
   return {
     createSchedule: createScheduleEffect,
     computeNextFireAt(spec: PlanScheduleSpec, baseTime: Date = nowDate()): Date {
-      return Effect.runSync(computeNextFireAtEffect(spec, baseTime))
+      return computeNextFireAt(spec, baseTime)
     },
     /** Called by the BullMQ worker when a fire-schedule job executes. */
     fireScheduleById: fireScheduleByIdEffect,
@@ -374,6 +386,7 @@ export const PlanSchedulerServiceLive = Layer.effect(
   PlanSchedulerServiceTag,
   Effect.gen(function* () {
     const db = yield* DatabaseServiceTag
-    return makePlanSchedulerService(db)
+    const queues = yield* LotaQueuesServiceTag
+    return makePlanSchedulerService(db, queues.planScheduler)
   }),
 )

package/src/services/plan/plan-transaction-events.ts

@@ -24,7 +24,7 @@ export function withTransactionAndEventsEffect<T, E, R>(params: {
         ),
       )
     yield* params.planEventDeliveryService
-      .dispatchEventsEffect(emittedEvents)
+      .dispatchEvents(emittedEvents)
       .pipe(
         Effect.mapError(
           (error) =>

package/src/services/recent-activity-title.service.ts

@@ -1,7 +1,9 @@
 import { Context, Effect, Layer } from 'effect'
 
+import type { ResolvedAgentConfig } from '../config/agent-defaults'
 import { ServiceError } from '../effect/errors'
 import { makeEffectTryPromiseWithMessage } from '../effect/helpers'
+import { AgentConfigServiceTag } from '../effect/services'
 import type { HelperModelRuntime } from '../runtime/helper-model'
 import { HelperModelTag } from '../runtime/helper-model'
 import { normalizeTitle } from '../runtime/title-helpers'
@@ -45,6 +47,7 @@ function buildRefinementPromptInput(
 }
 
 export function makeRecentActivityTitleService(
+  agentConfig: ResolvedAgentConfig,
   recentActivityService: ReturnType<typeof makeRecentActivityService>,
   helperModelRuntime: HelperModelRuntime,
 ) {
@@ -65,7 +68,7 @@ export function makeRecentActivityTitleService(
           () =>
             helperModelRuntime.generateHelperText({
               tag: 'recent-activity-title-refinement',
-              createAgent: createRecentActivityTitleRefinerAgent,
+              createAgent: (options) => createRecentActivityTitleRefinerAgent(agentConfig, options),
               defaultSystemPrompt: RECENT_ACTIVITY_TITLE_REFINER_PROMPT,
               timeoutMs: RECENT_ACTIVITY_TITLE_TIMEOUT_MS,
               messages: [{ role: 'user', content: promptInput }],
@@ -97,8 +100,9 @@ export class RecentActivityTitleServiceTag extends Context.Service<
 export const RecentActivityTitleServiceLive = Layer.effect(
   RecentActivityTitleServiceTag,
   Effect.gen(function* () {
+    const agentConfig = yield* AgentConfigServiceTag
     const recentActivityService = yield* RecentActivityServiceTag
     const helperModelRuntime = yield* HelperModelTag
-    return makeRecentActivityTitleService(recentActivityService, helperModelRuntime)
+    return makeRecentActivityTitleService(agentConfig, recentActivityService, helperModelRuntime)
   }),
 )

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

@@ -1,9 +1,9 @@
 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'
@@ -20,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 {
@@ -50,6 +50,8 @@ function isDuplicateCreateErrorLike(value: unknown): value is DuplicateCreateErr
 }
 
 export function createThreadBootstrapHelpers(deps: {
+  agentConfig: ResolvedAgentConfig
+  threadBootstrapConfig: ResolvedThreadBootstrapConfig
   threadStore: ThreadRecordStore
   threadMessageService: Pick<ReturnType<typeof makeThreadMessageService>, 'ensureBootstrapWelcomeMessageEffect'>
   redis: RedisConnectionManager
@@ -137,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,
@@ -250,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,
         })
@@ -263,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,
@@ -279,7 +281,7 @@ export function createThreadBootstrapHelpers(deps: {
     orgId: RecordIdRef,
     options?: { onboardStatus?: string; userName?: string | null },
   ): Effect.Effect<void, ThreadBootstrapError> => {
-    const bootstrapConfig = getThreadBootstrapConfig()
+    const bootstrapConfig = deps.threadBootstrapConfig
 
     return withLeaseLock(
       {
@@ -342,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-message.service.ts

@@ -5,7 +5,7 @@ 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'
@@ -16,7 +16,7 @@ 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'
 
@@ -106,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) =>
@@ -349,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(),
               },
             },
@@ -374,6 +374,7 @@ export const ThreadMessageServiceLive = Layer.effect(
   ThreadMessageServiceTag,
   Effect.gen(function* () {
     const db = yield* DatabaseServiceTag
-    return makeThreadMessageService(db)
+    const agentConfig = yield* AgentConfigServiceTag
+    return makeThreadMessageService(db, agentConfig)
   }),
 )