@lota-sdk/core 0.4.9 → 0.4.11

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

@@ -2,11 +2,11 @@ import type { ChatMessage } from '@lota-sdk/shared'
 import { createUIMessageStream } from 'ai'
 import { Context, Schema, Effect, Layer } from 'effect'
 
+import type { ResolvedAgentConfig } from '../../config/agent-defaults'
 import { ensureRecordId, recordIdToString } from '../../db/record-id'
 import { TABLES } from '../../db/tables'
 import { BadRequestError } from '../../effect/errors'
-import { runPromise } from '../../effect/runtime'
-import { getCurrentRuntime } from '../../effect/runtime-ref'
+import { AgentConfigServiceTag } from '../../effect/services'
 import { hasApprovalRespondedParts, isApprovalContinuationRequest } from '../../runtime/approval-continuation'
 import { shouldPlanNodeUseVisibleTurn } from '../../runtime/execution-plan-visibility'
 import { wrapResponseWithKeepalive } from '../../utils/sse-keepalive'
@@ -39,6 +39,7 @@ class ThreadTurnServiceError extends Schema.TaggedErrorClass<ThreadTurnServiceEr
 }) {}
 
 interface ThreadTurnDeps {
+  agentConfig: ResolvedAgentConfig
   planExecutor: ReturnType<typeof makePlanExecutorService>
   planRun: ReturnType<typeof makePlanRunService>
   thread: ReturnType<typeof makeThreadService>
@@ -179,7 +180,7 @@ const triggerPlanNodeTurnEffect = Effect.fn('ThreadTurn.triggerPlanNodeTurn')(fu
   const spec = yield* deps.planRun.getPlanSpecById(run.planSpecId)
   const nodeSpec = yield* deps.planRun.getNodeSpecByNodeId(spec.id, params.nodeId)
 
-  if (!shouldPlanNodeUseVisibleTurn(spec, nodeSpec) || nodeSpec.owner.executorType !== 'agent') {
+  if (!shouldPlanNodeUseVisibleTurn(deps.agentConfig, spec, nodeSpec) || nodeSpec.owner.executorType !== 'agent') {
     return yield* new BadRequestError({
       message: `Plan node "${params.nodeId}" is not eligible for a visible plan turn.`,
     })
@@ -188,10 +189,13 @@ const triggerPlanNodeTurnEffect = Effect.fn('ThreadTurn.triggerPlanNodeTurn')(fu
   let activeRun = run
   let nodeRun = yield* deps.planRun.getNodeRunByNodeId(run.id, params.nodeId)
   if (nodeRun.status === 'ready') {
-    yield* Effect.tryPromise({
-      try: () => deps.planExecutor.transitionNodeToRunning({ runId: params.runId, nodeId: params.nodeId }),
-      catch: (cause) => new ThreadTurnServiceError({ message: 'Failed to transition plan node to running.', cause }),
-    })
+    yield* deps.planExecutor
+      .transitionNodeToRunning({ runId: params.runId, nodeId: params.nodeId })
+      .pipe(
+        Effect.mapError(
+          (cause) => new ThreadTurnServiceError({ message: 'Failed to transition plan node to running.', cause }),
+        ),
+      )
     activeRun = yield* deps.planRun.getRunById(params.runId)
     nodeRun = yield* deps.planRun.getNodeRunByNodeId(run.id, params.nodeId)
   }
@@ -299,45 +303,55 @@ export function makeThreadTurnService(deps: ThreadTurnDeps) {
 export class ThreadTurnServiceTag extends Context.Service<
   ThreadTurnServiceTag,
   ReturnType<typeof makeThreadTurnService>
->()('ThreadTurnService') {}
+>()('@lota-sdk/core/ThreadTurnService') {}
 
 export const ThreadTurnServiceLive = Layer.effect(
   ThreadTurnServiceTag,
   Effect.gen(function* () {
+    const agentConfig = yield* AgentConfigServiceTag
     const planExecutor = yield* PlanExecutorServiceTag
     const planRun = yield* PlanRunServiceTag
     const thread = yield* ThreadServiceTag
     const threadTurnPreparation = yield* ThreadTurnPreparationServiceTag
     const user = yield* UserServiceTag
-    return makeThreadTurnService({ planExecutor, planRun, thread, threadTurnPreparation, user })
+    return makeThreadTurnService({ agentConfig, planExecutor, planRun, thread, threadTurnPreparation, user })
   }),
 )
 
-function getThreadTurnService() {
-  return getCurrentRuntime().runSync(Effect.service(ThreadTurnServiceTag))
-}
-
-export function createThreadApprovalContinuationStream(params: ThreadApprovalContinuationParams) {
-  return runPromise(getThreadTurnService().createThreadApprovalContinuationStream(params))
-}
+export const createThreadApprovalContinuationStream = Effect.fn('ThreadTurn.createApprovalContinuationStream')(
+  function* (params: ThreadApprovalContinuationParams) {
+    const threadTurnService = yield* ThreadTurnServiceTag
+    return yield* threadTurnService.createThreadApprovalContinuationStream(params)
+  },
+)
 
-export function createThreadNativeToolApprovalStream(params: ThreadApprovalContinuationParams) {
-  return runPromise(getThreadTurnService().createThreadNativeToolApprovalStream(params))
-}
+export const createThreadNativeToolApprovalStream = Effect.fn('ThreadTurn.createNativeToolApprovalStream')(function* (
+  params: ThreadApprovalContinuationParams,
+) {
+  const threadTurnService = yield* ThreadTurnServiceTag
+  return yield* threadTurnService.createThreadNativeToolApprovalStream(params)
+})
 
-export function createThreadTurnStream(params: ThreadTurnParams) {
-  return runPromise(getThreadTurnService().createThreadTurnStream(params))
-}
+export const createThreadTurnStream = Effect.fn('ThreadTurn.createThreadTurnStream')(function* (
+  params: ThreadTurnParams,
+) {
+  const threadTurnService = yield* ThreadTurnServiceTag
+  return yield* threadTurnService.createThreadTurnStream(params)
+})
 
-export function runThreadTurnInBackground(params: ThreadTurnParams): Promise<PreparedThreadTurnResult> {
-  return runPromise(getThreadTurnService().runThreadTurnInBackground(params))
-}
+export const runThreadTurnInBackground = Effect.fn('ThreadTurn.runThreadTurnInBackground')(function* (
+  params: ThreadTurnParams,
+) {
+  const threadTurnService = yield* ThreadTurnServiceTag
+  return yield* threadTurnService.runThreadTurnInBackground(params)
+})
 
-export function triggerPlanNodeTurn(params: {
+export const triggerPlanNodeTurn = Effect.fn('ThreadTurn.triggerPlanNodeTurn')(function* (params: {
   runId: string
   nodeId: string
   abortSignal?: AbortSignal
   streamId?: string
-}): Promise<PreparedThreadTurnResult> {
-  return runPromise(getThreadTurnService().triggerPlanNodeTurn(params))
-}
+}) {
+  const threadTurnService = yield* ThreadTurnServiceTag
+  return yield* threadTurnService.triggerPlanNodeTurn(params)
+})

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

@@ -2,17 +2,25 @@ import { THREAD, sdkThreadStatusSchema } from '@lota-sdk/shared'
 import { Context, Effect, Layer } from 'effect'
 import { surql } from 'surrealdb'
 
-import { getCoreThreadProfile, isAgentName } from '../../config/agent-defaults'
+import type { ResolvedAgentConfig } from '../../config/agent-defaults'
+import { isAgentName } from '../../config/agent-defaults'
+import type { ResolvedThreadBootstrapConfig } from '../../config/thread-defaults'
 import { ensureRecordId, isRecordIdInput, recordIdToString } from '../../db/record-id'
 import type { RecordIdRef } from '../../db/record-id'
 import type { SurrealDBService } from '../../db/service'
 import { TABLES } from '../../db/tables'
 import { BadRequestError, ServiceError } from '../../effect/errors'
 import { makeEffectTryPromiseWithMessage } from '../../effect/helpers'
-import { DatabaseServiceTag, RedisServiceTag } from '../../effect/services'
+import {
+  AgentConfigServiceTag,
+  DatabaseServiceTag,
+  RedisServiceTag,
+  ThreadConfigServiceTag,
+} from '../../effect/services'
 import type { RedisConnectionManager } from '../../redis/connection'
 import { CompactionCoordinationTag } from '../../runtime/chat-run-orchestration'
 import { toIsoDateTimeString } from '../../utils/date-time'
+import { BackgroundWorkService } from '../background-work.service'
 import { ChatRunRegistryTag } from '../chat-run-registry.service'
 import { ContextCompactionServiceTag } from '../context-compaction.service'
 import type { makeContextCompactionService } from '../context-compaction.service'
@@ -34,9 +42,9 @@ function assertMutableThreadEffect(thread: ThreadRecord): Effect.Effect<void, Ba
     : Effect.void
 }
 
-function getDefaultTitle(thread: Pick<ThreadRecord, 'type' | 'threadType'>): string {
+function getDefaultTitle(agentConfig: ResolvedAgentConfig, thread: Pick<ThreadRecord, 'type' | 'threadType'>): string {
   if (thread.type === 'thread' && typeof thread.threadType === 'string') {
-    return getCoreThreadProfile(thread.threadType).config.title
+    return agentConfig.getCoreThreadProfile(thread.threadType).config.title
   }
 
   return THREAD.DEFAULT_TITLE
@@ -62,12 +70,15 @@ type ChatRunRegistry = Context.Service.Shape<typeof ChatRunRegistryTag>
 type CompactionCoordination = Context.Service.Shape<typeof CompactionCoordinationTag>
 
 interface ThreadServiceDeps {
+  agentConfig: ResolvedAgentConfig
+  threadBootstrapConfig: ResolvedThreadBootstrapConfig
   db: SurrealDBService
   redis: RedisConnectionManager
   chatRunRegistry: ChatRunRegistry
   threadMessageService: ReturnType<typeof makeThreadMessageService>
   contextCompactionService: ReturnType<typeof makeContextCompactionService>
   compactionCoordination: CompactionCoordination
+  background: Context.Service.Shape<typeof BackgroundWorkService>
 }
 
 export function makeThreadService(deps: ThreadServiceDeps) {
@@ -115,7 +126,7 @@ export function makeThreadService(deps: ThreadServiceDeps) {
         normalizeRecordIdStringEffect(thread.userId, TABLES.USER),
         normalizeRecordIdStringEffect(thread.organizationId, TABLES.ORGANIZATION),
       ])
-      return NormalizedThreadSchema.parse({
+      const candidate = {
         id,
         userId,
         organizationId,
@@ -124,13 +135,17 @@ export function makeThreadService(deps: ThreadServiceDeps) {
         nameGenerated: thread.nameGenerated,
         isRunning,
         isCompacting: thread.isCompacting === true,
-        ...(isAgentName(thread.agentId) ? { agentId: thread.agentId } : {}),
-        title: thread.title ?? getDefaultTitle(thread),
+        ...(isAgentName(deps.agentConfig, thread.agentId) ? { agentId: thread.agentId } : {}),
+        title: thread.title ?? getDefaultTitle(deps.agentConfig, thread),
         status: thread.status,
         memoryBlock: formatMemoryBlockForPrompt(thread),
         members: thread.members,
         createdAt: toIsoDateTimeString(thread.createdAt),
         updatedAt: toIsoDateTimeString(thread.updatedAt),
+      }
+      return yield* Effect.try({
+        try: () => NormalizedThreadSchema.parse(candidate),
+        catch: (cause) => new ServiceError({ message: 'Failed to parse normalized thread.', cause }),
       })
     })
   }
@@ -143,6 +158,8 @@ export function makeThreadService(deps: ThreadServiceDeps) {
   }
 
   const bootstrap = createThreadBootstrapHelpers({
+    agentConfig: deps.agentConfig,
+    threadBootstrapConfig: deps.threadBootstrapConfig,
     threadStore,
     threadMessageService: deps.threadMessageService,
     redis: deps.redis,
@@ -154,6 +171,7 @@ export function makeThreadService(deps: ThreadServiceDeps) {
   const memory = createThreadMemoryBlockHelpers({
     threadStore,
     contextCompactionService: { compactMemoryBlock: deps.contextCompactionService.compactMemoryBlock },
+    background: deps.background,
   })
 
   function getById(threadId: RecordIdRef) {
@@ -311,25 +329,31 @@ export function makeThreadService(deps: ThreadServiceDeps) {
 }
 
 export class ThreadServiceTag extends Context.Service<ThreadServiceTag, ReturnType<typeof makeThreadService>>()(
-  'ThreadService',
+  '@lota-sdk/core/ThreadService',
 ) {}
 
 export const ThreadServiceLive = Layer.effect(
   ThreadServiceTag,
   Effect.gen(function* () {
+    const agentConfig = yield* AgentConfigServiceTag
+    const threadBootstrapConfig = yield* ThreadConfigServiceTag
     const db = yield* DatabaseServiceTag
     const redis = yield* RedisServiceTag
     const chatRunRegistry = yield* ChatRunRegistryTag
     const threadMessageService = yield* ThreadMessageServiceTag
     const contextCompactionService = yield* ContextCompactionServiceTag
     const compactionCoordination = yield* CompactionCoordinationTag
+    const background = yield* BackgroundWorkService
     return makeThreadService({
+      agentConfig,
+      threadBootstrapConfig,
       db,
       redis,
       chatRunRegistry,
       threadMessageService,
       contextCompactionService,
       compactionCoordination,
+      background,
     })
   }),
 )

package/src/services/user.service.ts

@@ -94,7 +94,7 @@ export function makeUserService(db: SurrealDBService) {
 }
 
 export class UserServiceTag extends Context.Service<UserServiceTag, ReturnType<typeof makeUserService>>()(
-  'UserService',
+  '@lota-sdk/core/UserService',
 ) {}
 
 export const UserServiceLive = Layer.effect(

package/src/services/write-intent-validator.service.ts

@@ -85,7 +85,7 @@ export function makeWriteIntentValidatorService() {
 export class WriteIntentValidatorServiceTag extends Context.Service<
   WriteIntentValidatorServiceTag,
   ReturnType<typeof makeWriteIntentValidatorService>
->()('WriteIntentValidatorService') {}
+>()('@lota-sdk/core/WriteIntentValidatorService') {}
 
 export const WriteIntentValidatorServiceLive = Layer.succeed(
   WriteIntentValidatorServiceTag,

package/src/storage/attachment-storage.service.ts

@@ -107,11 +107,14 @@ export function makeAttachmentStorageService(config: ResolvedLotaRuntimeConfig)
     storageKey: string
     orgId: string
     userId: string
-  }): void {
+  }): Effect.Effect<void, ForbiddenError> {
     const storagePrefix = buildUploadStoragePrefix({ orgId, userId })
     if (!storageKey.startsWith(storagePrefix)) {
-      throw new ForbiddenError({ message: 'Upload does not belong to the current organization/user scope.' })
+      return Effect.fail(
+        new ForbiddenError({ message: 'Upload does not belong to the current organization/user scope.' }),
+      )
     }
+    return Effect.void
   }
 
   function writeOrganizationDocumentEffect({
@@ -284,7 +287,7 @@ export function makeAttachmentStorageService(config: ResolvedLotaRuntimeConfig)
     pagesPerPart?: number
   }) {
     return Effect.gen(function* () {
-      assertUploadOwnership({ storageKey: upload.storageKey, orgId, userId })
+      yield* assertUploadOwnership({ storageKey: upload.storageKey, orgId, userId })
 
       const parsed = yield* extractStoredAttachmentPagesEffect({
         storageKey: upload.storageKey,
@@ -437,7 +440,7 @@ export function makeAttachmentStorageService(config: ResolvedLotaRuntimeConfig)
 export class AttachmentStorageServiceTag extends Context.Service<
   AttachmentStorageServiceTag,
   ReturnType<typeof makeAttachmentStorageService>
->()('AttachmentStorageService') {}
+>()('@lota-sdk/core/AttachmentStorageService') {}
 
 export const AttachmentStorageServiceLive = Layer.effect(
   AttachmentStorageServiceTag,

package/src/storage/generated-document-storage.service.ts

@@ -86,7 +86,7 @@ export function makeGeneratedDocumentStorageService(config: ResolvedLotaRuntimeC
 export class GeneratedDocumentStorageServiceTag extends Context.Service<
   GeneratedDocumentStorageServiceTag,
   ReturnType<typeof makeGeneratedDocumentStorageService>
->()('GeneratedDocumentStorageService') {}
+>()('@lota-sdk/core/GeneratedDocumentStorageService') {}
 
 export const GeneratedDocumentStorageServiceLive = Layer.effect(
   GeneratedDocumentStorageServiceTag,

package/src/system-agents/context-compaction.agent.ts

@@ -1,3 +1,4 @@
+import type { CreateHelperToolLoopAgentOptions } from '@lota-sdk/shared'
 import { ToolLoopAgent } from 'ai'
 
 import { aiGatewayChatModel } from '../ai-gateway/ai-gateway'
@@ -6,7 +7,6 @@ import {
   OPENROUTER_STRUCTURED_HELPER_MODEL_ID,
   OPENROUTER_HIGH_REASONING_PROVIDER_OPTIONS,
 } from '../config/model-constants'
-import type { CreateHelperToolLoopAgentOptions } from '../runtime/agent-types'
 import { resolveHelperAgentOptions } from './helper-agent-options'
 
 const CONTEXT_COMPACTION_PROMPT = `<agent-instructions>

package/src/system-agents/helper-agent-options.ts

@@ -1,4 +1,4 @@
-import type { CreateHelperToolLoopAgentOptions } from '../runtime/agent-types'
+import type { CreateHelperToolLoopAgentOptions } from '@lota-sdk/shared'
 
 interface HelperAgentOptionOverrides {
   instructions?: string

package/src/system-agents/memory-reranker.agent.ts

@@ -1,3 +1,4 @@
+import type { CreateHelperToolLoopAgentOptions } from '@lota-sdk/shared'
 import { ToolLoopAgent } from 'ai'
 
 import { aiGatewayChatModel } from '../ai-gateway/ai-gateway'
@@ -6,7 +7,6 @@ import {
   OPENROUTER_LOW_REASONING_PROVIDER_OPTIONS,
   OPENROUTER_STRUCTURED_HELPER_MODEL_ID,
 } from '../config/model-constants'
-import type { CreateHelperToolLoopAgentOptions } from '../runtime/agent-types'
 import { resolveHelperAgentOptions } from './helper-agent-options'
 
 export const MEMORY_RERANKER_PROMPT = `<agent-instructions>

package/src/system-agents/memory.agent.ts

@@ -1,3 +1,4 @@
+import type { CreateHelperToolLoopAgentOptions } from '@lota-sdk/shared'
 import { ToolLoopAgent } from 'ai'
 
 import { aiGatewayChatModel } from '../ai-gateway/ai-gateway'
@@ -6,7 +7,6 @@ import {
   OPENROUTER_STRUCTURED_HELPER_MODEL_ID,
   OPENROUTER_HIGH_REASONING_PROVIDER_OPTIONS,
 } from '../config/model-constants'
-import type { CreateHelperToolLoopAgentOptions } from '../runtime/agent-types'
 import { resolveHelperAgentOptions } from './helper-agent-options'
 
 export const ORG_MEMORY_PROMPT = `<agent-instructions>

package/src/system-agents/recent-activity-title-refiner.agent.ts

@@ -1,19 +1,19 @@
+import type { CreateHelperToolLoopAgentOptions } from '@lota-sdk/shared'
 import { ToolLoopAgent } from 'ai'
 
 import { aiGatewayChatModel } from '../ai-gateway/ai-gateway'
 import { buildAiGatewayDirectCacheHeaders } from '../ai-gateway/cache-headers'
-import { getLeadAgentDisplayName } from '../config/agent-defaults'
+import type { ResolvedAgentConfig } from '../config/agent-defaults'
 import {
   OPENROUTER_STRUCTURED_HELPER_MODEL_ID,
   OPENROUTER_HIGH_REASONING_PROVIDER_OPTIONS,
 } from '../config/model-constants'
-import type { CreateHelperToolLoopAgentOptions } from '../runtime/agent-types'
 import { resolveHelperAgentOptions } from './helper-agent-options'
 
 const RECENT_ACTIVITY_TITLE_MAX_TOKENS = 256
 
-export function buildRecentActivityTitleRefinerPrompt(): string {
-  const leadAgentDisplayName = getLeadAgentDisplayName() || 'the lead agent'
+export function buildRecentActivityTitleRefinerPrompt(agentConfig: ResolvedAgentConfig): string {
+  const leadAgentDisplayName = agentConfig.displayNames[agentConfig.leadAgentId] || 'the lead agent'
 
   return `<agent-instructions>
 You are ${leadAgentDisplayName} writing the visible title for a recent activity item.
@@ -76,14 +76,17 @@ Return only the title text. No quotes, labels, JSON, markdown, or explanation.
 </output>
 </agent-instructions>`
 
-export function createRecentActivityTitleRefinerAgent(options: CreateHelperToolLoopAgentOptions) {
+export function createRecentActivityTitleRefinerAgent(
+  agentConfig: ResolvedAgentConfig,
+  options: CreateHelperToolLoopAgentOptions,
+) {
   return new ToolLoopAgent({
     id: 'recent-activity-title-refiner',
     model: aiGatewayChatModel(OPENROUTER_STRUCTURED_HELPER_MODEL_ID),
     headers: buildAiGatewayDirectCacheHeaders('lota-sdk'),
     providerOptions: OPENROUTER_HIGH_REASONING_PROVIDER_OPTIONS,
     ...resolveHelperAgentOptions(options, {
-      instructions: buildRecentActivityTitleRefinerPrompt(),
+      instructions: buildRecentActivityTitleRefinerPrompt(agentConfig),
       maxOutputTokens: RECENT_ACTIVITY_TITLE_MAX_TOKENS,
     }),
   })

package/src/system-agents/regular-chat-memory-digest.agent.ts

@@ -1,3 +1,4 @@
+import type { CreateHelperToolLoopAgentOptions } from '@lota-sdk/shared'
 import { ToolLoopAgent } from 'ai'
 
 import { aiGatewayChatModel } from '../ai-gateway/ai-gateway'
@@ -6,7 +7,6 @@ import {
   OPENROUTER_STRUCTURED_HELPER_MODEL_ID,
   OPENROUTER_HIGH_REASONING_PROVIDER_OPTIONS,
 } from '../config/model-constants'
-import type { CreateHelperToolLoopAgentOptions } from '../runtime/agent-types'
 import { resolveHelperAgentOptions } from './helper-agent-options'
 
 const REGULAR_CHAT_MEMORY_DIGEST_MAX_TOKENS = 8_192

package/src/system-agents/skill-extractor.agent.ts

@@ -1,3 +1,4 @@
+import type { CreateHelperToolLoopAgentOptions } from '@lota-sdk/shared'
 import { ToolLoopAgent } from 'ai'
 import { z } from 'zod'
 
@@ -7,7 +8,6 @@ import {
   OPENROUTER_STRUCTURED_HELPER_MODEL_ID,
   OPENROUTER_HIGH_REASONING_PROVIDER_OPTIONS,
 } from '../config/model-constants'
-import type { CreateHelperToolLoopAgentOptions } from '../runtime/agent-types'
 import { resolveHelperAgentOptions } from './helper-agent-options'
 
 const SKILL_EXTRACTOR_MAX_TOKENS = 8_192

package/src/system-agents/skill-manager.agent.ts

@@ -1,3 +1,4 @@
+import type { CreateHelperToolLoopAgentOptions } from '@lota-sdk/shared'
 import { ToolLoopAgent } from 'ai'
 import { z } from 'zod'
 
@@ -7,7 +8,6 @@ import {
   OPENROUTER_STRUCTURED_HELPER_MODEL_ID,
   OPENROUTER_HIGH_REASONING_PROVIDER_OPTIONS,
 } from '../config/model-constants'
-import type { CreateHelperToolLoopAgentOptions } from '../runtime/agent-types'
 import { resolveHelperAgentOptions } from './helper-agent-options'
 
 const SKILL_MANAGER_MAX_TOKENS = 4_096

package/src/system-agents/thread-router.agent.ts

@@ -4,12 +4,7 @@ import { z } from 'zod'
 
 import { aiGatewayChatModel } from '../ai-gateway/ai-gateway'
 import { buildAiGatewayDirectCacheHeaders } from '../ai-gateway/cache-headers'
-import {
-  getAgentDescriptions,
-  getAgentDisplayNames,
-  getAgentShortDisplayNames,
-  getRouterModelId,
-} from '../config/agent-defaults'
+import type { ResolvedAgentConfig } from '../config/agent-defaults'
 import { chatLogger } from '../config/logger'
 import type { ValidationError } from '../effect/errors'
 import { AiGenerationError } from '../effect/errors'
@@ -28,6 +23,7 @@ export type RouterTriageResult = z.infer<typeof TriageResultSchema>
 export type RouterCheckResult = { done: true } | RouterCheckContinueResult
 
 interface RouterDisplayOptions {
+  agentConfig: ResolvedAgentConfig
   displayNamesById?: Partial<Record<string, string>>
   shortDisplayNamesById?: Partial<Record<string, string>>
   routingAliasesByAgentId?: Partial<Record<string, string[]>>
@@ -44,26 +40,26 @@ function readStringArrayOverride(
   return record && Object.hasOwn(record, key) ? record[key] : undefined
 }
 
-function readDisplayName(agentId: string, options?: RouterDisplayOptions): string {
-  const override = readStringOverride(options?.displayNamesById, agentId)
+function readDisplayName(agentId: string, options: RouterDisplayOptions): string {
+  const override = readStringOverride(options.displayNamesById, agentId)
   if (override !== undefined) {
     return override
   }
 
-  return getAgentDisplayNames()[agentId] ?? agentId
+  return options.agentConfig.displayNames[agentId] ?? agentId
 }
 
-function readShortDisplayName(agentId: string, options?: RouterDisplayOptions): string {
-  const override = readStringOverride(options?.shortDisplayNamesById, agentId)
+function readShortDisplayName(agentId: string, options: RouterDisplayOptions): string {
+  const override = readStringOverride(options.shortDisplayNamesById, agentId)
   if (override !== undefined) {
     return override
   }
 
-  return getAgentShortDisplayNames()[agentId] ?? readDisplayName(agentId, options)
+  return options.agentConfig.shortDisplayNames[agentId] ?? readDisplayName(agentId, options)
 }
 
-function buildMembersDescription(members: readonly string[], options?: RouterDisplayOptions): string {
-  const agentDescriptions = getAgentDescriptions()
+function buildMembersDescription(members: readonly string[], options: RouterDisplayOptions): string {
+  const agentDescriptions = options.agentConfig.descriptions
   return members
     .map((id) => {
       const display = readDisplayName(id, options)
@@ -77,7 +73,7 @@ function escapeRegex(value: string): string {
   return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
 }
 
-function buildExplicitAgentRoutingContext(agentId: string, options?: RouterDisplayOptions): string {
+function buildExplicitAgentRoutingContext(agentId: string, options: RouterDisplayOptions): string {
   const displayName = readDisplayName(agentId, options)
   return `Respond directly to the part of the user's request explicitly addressed to ${displayName}.`
 }
@@ -85,16 +81,16 @@ function buildExplicitAgentRoutingContext(agentId: string, options?: RouterDispl
 function extractExplicitAgentTargets(
   messageText: string,
   members: readonly string[],
-  options?: RouterDisplayOptions,
+  options: RouterDisplayOptions,
 ): string[] {
   const normalizedMessage = messageText.trim()
   if (!normalizedMessage) return []
 
   const memberSet = new Set(members)
   const aliases = new Map<string, string>()
-  const defaultDisplayNames = options?.displayNamesById === undefined ? getAgentDisplayNames() : undefined
+  const defaultDisplayNames = options.displayNamesById === undefined ? options.agentConfig.displayNames : undefined
   const defaultShortDisplayNames =
-    options?.shortDisplayNamesById === undefined ? getAgentShortDisplayNames() : undefined
+    options.shortDisplayNamesById === undefined ? options.agentConfig.shortDisplayNames : undefined
 
   for (const member of members) {
     for (const rawAlias of [
@@ -103,7 +99,7 @@ function extractExplicitAgentTargets(
       defaultShortDisplayNames?.[member],
       readDisplayName(member, options),
       readShortDisplayName(member, options),
-      ...(readStringArrayOverride(options?.routingAliasesByAgentId, member) ?? []),
+      ...(readStringArrayOverride(options.routingAliasesByAgentId, member) ?? []),
     ]) {
       if (typeof rawAlias !== 'string') continue
       const alias = rawAlias.trim().toLowerCase()
@@ -173,12 +169,13 @@ function toRouterGenerationError(label: 'triage' | 'check', error: unknown): AiG
 }
 
 function generateRouterObjectEffect<TSchema extends z.ZodTypeAny>(params: {
+  agentConfig: ResolvedAgentConfig
   schema: TSchema
   system: string
   prompt: string
   label: 'triage' | 'check'
 }): Effect.Effect<z.infer<TSchema> | null, never> {
-  const modelId = getRouterModelId() ?? 'openrouter/openai/gpt-5.4-nano'
+  const modelId = params.agentConfig.routerModelId ?? 'openrouter/openai/gpt-5.4-nano'
 
   return Effect.tryPromise({
     try: () =>
@@ -219,6 +216,7 @@ function generateRouterObjectEffect<TSchema extends z.ZodTypeAny>(params: {
 }
 
 export function triageThreadMessage(params: {
+  agentConfig: ResolvedAgentConfig
   threadTitle: string
   members: readonly string[]
   messageText: string
@@ -230,6 +228,7 @@ export function triageThreadMessage(params: {
   return Effect.runPromise(
     Effect.gen(function* () {
       const displayOptions: RouterDisplayOptions = {
+        agentConfig: params.agentConfig,
         displayNamesById: params.displayNamesById,
         shortDisplayNamesById: params.shortDisplayNamesById,
         routingAliasesByAgentId: params.routingAliasesByAgentId,
@@ -254,6 +253,7 @@ export function triageThreadMessage(params: {
         .join('\n\n')
 
       const parsed = yield* generateRouterObjectEffect({
+        agentConfig: params.agentConfig,
         schema: TriageResultSchema,
         system: TRIAGE_SYSTEM_PROMPT,
         prompt,
@@ -279,6 +279,7 @@ export function triageThreadMessage(params: {
 }
 
 export function checkForNextAgent(params: {
+  agentConfig: ResolvedAgentConfig
   threadTitle: string
   members: readonly string[]
   messageText: string
@@ -291,6 +292,7 @@ export function checkForNextAgent(params: {
   return Effect.runPromise(
     Effect.gen(function* () {
       const displayOptions: RouterDisplayOptions = {
+        agentConfig: params.agentConfig,
         displayNamesById: params.displayNamesById,
         shortDisplayNamesById: params.shortDisplayNamesById,
         routingAliasesByAgentId: params.routingAliasesByAgentId,
@@ -320,6 +322,7 @@ export function checkForNextAgent(params: {
       ].join('\n\n')
 
       const parsed = yield* generateRouterObjectEffect({
+        agentConfig: params.agentConfig,
         schema: CheckResultObjectSchema,
         system: CHECK_SYSTEM_PROMPT,
         prompt,

package/src/system-agents/title-generator.agent.ts

@@ -1,3 +1,4 @@
+import type { CreateHelperToolLoopAgentOptions } from '@lota-sdk/shared'
 import { ToolLoopAgent } from 'ai'
 
 import { aiGatewayChatModel } from '../ai-gateway/ai-gateway'
@@ -6,7 +7,6 @@ import {
   OPENROUTER_FAST_REASONING_MODEL_ID,
   OPENROUTER_MINIMAL_REASONING_PROVIDER_OPTIONS,
 } from '../config/model-constants'
-import type { CreateHelperToolLoopAgentOptions } from '../runtime/agent-types'
 import { resolveHelperAgentOptions } from './helper-agent-options'
 
 const THREAD_TITLE_MAX_TOKENS = 512