@lota-sdk/core 0.4.10 → 0.4.12

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

@@ -4,18 +4,18 @@ import { convertToModelMessages, stepCountIs } from 'ai'
 import type { PrepareStepFunction, StopCondition, ToolSet, UIMessageStreamWriter } from 'ai'
 import { Effect, Ref, Schema, Stream } from 'effect'
 
-import { getAgentRuntimeConfig, getResolvedAgentFactoryConfig } from '../../config/agent-defaults'
 import { aiLogger } from '../../config/logger'
 import type { RecordIdRef } from '../../db/record-id'
 import { effectTryMaybeAsync, makeEffectTryPromiseWithMessage } from '../../effect/helpers'
-import { runPromise } from '../../effect/runtime'
+import { AgentConfigServiceTag, AgentFactoryServiceTag } from '../../effect/services'
 import {
   readRuntimeAgentIdentityOverrides,
   resolveRuntimeAgentDisplayName,
 } from '../../runtime/agent-identity-overrides'
 import { createAgentMessageMetadata } from '../../runtime/agent-stream-helpers'
 import { mergeInstructionSections } from '../../runtime/instruction-sections'
-import type { getTurnHooks } from '../../runtime/runtime-extensions'
+import { createLiveTurnTraceStreamObserver } from '../../runtime/live-turn-trace'
+import type { LotaRuntimeTurnHooks } from '../../runtime/runtime-extensions'
 import {
   asRecord,
   collectToolOutputErrors,
@@ -122,7 +122,7 @@ function buildFallbackResponseMessage(
 }
 
 export interface StreamAgentResponseContext {
-  turnHooks: ReturnType<typeof getTurnHooks>
+  turnHooks: LotaRuntimeTurnHooks
   thread: NormalizedThread
   threadRef: RecordIdRef
   orgRef: RecordIdRef
@@ -226,8 +226,9 @@ const streamAgentResponseEffect = Effect.fn('ThreadTurnStreaming.streamAgentResp
     (streamParams.skills ?? []).some((skill) => skill.startsWith('cpo-') || skill.startsWith('mentor-')) ||
     resolvedAgentId === 'cpo' ||
     resolvedAgentId === 'mentor'
-  const agentFactoryConfig = getResolvedAgentFactoryConfig()
-  const config = getAgentRuntimeConfig({
+  const agentFactoryConfig = yield* AgentFactoryServiceTag
+  const agentConfig = yield* AgentConfigServiceTag
+  const config = agentFactoryConfig.getAgentRuntimeConfig({
     agentId: resolvedAgentId,
     threadType: ctx.thread.type,
     mode: streamParams.mode,
@@ -277,6 +278,7 @@ const streamAgentResponseEffect = Effect.fn('ThreadTurnStreaming.streamAgentResp
     prepareStep: (agentResolution?.prepareStep as PrepareStepFunction<ToolSet> | undefined) ?? streamParams.prepareStep,
   })
   const agentAbortSignal = streamParams.abortSignal ?? ctx.runAbortSignal
+  const resolvedAgentName = resolveRuntimeAgentDisplayName(agentConfig, agentIdentityOverrides, resolvedAgentId)
 
   const generateFallback = (cause: ThreadTurnStreamingError) =>
     effectTryPromise(
@@ -291,6 +293,34 @@ const streamAgentResponseEffect = Effect.fn('ThreadTurnStreaming.streamAgentResp
       Effect.flatMap((result) => buildFallbackResponseMessage(result as ToolLoopGenerateResult)),
     )
 
+  const generateWithoutUiStream = effectTryPromise(
+    () => streamParams.observer.run(() => agent.generate({ messages: modelMessages, abortSignal: agentAbortSignal })),
+    `Agent generate failed for ${resolvedAgentId}.`,
+  ).pipe(
+    Effect.tapError((error) =>
+      Effect.sync(() => {
+        if (agentAbortSignal.aborted) {
+          streamParams.observer.recordAbort(error)
+          return
+        }
+
+        streamParams.observer.recordError(error)
+      }),
+    ),
+    Effect.withSpan('ThreadTurnStreaming.startAgentGenerate'),
+    Effect.flatMap((result) => buildFallbackResponseMessage(result as ToolLoopGenerateResult)),
+  )
+
+  if (!streamParams.writer) {
+    const generatedResponse = yield* generateWithoutUiStream
+
+    for (const toolError of collectToolOutputErrors({ responseMessage: generatedResponse })) {
+      aiLogger.error`Tool execution failed (agent=${resolvedAgentId}, tool=${toolError.toolName}, toolCallId=${toolError.toolCallId}): ${toolError.errorText}`
+    }
+
+    return generatedResponse
+  }
+
   const result = yield* effectTryPromise(
     () => streamParams.observer.run(() => agent.stream({ messages: modelMessages, abortSignal: agentAbortSignal })),
     `Agent stream failed for ${resolvedAgentId}.`,
@@ -320,14 +350,19 @@ const streamAgentResponseEffect = Effect.fn('ThreadTurnStreaming.streamAgentResp
     originalMessages: streamParams.messages,
     sendReasoning: true,
     sendSources: true,
-    messageMetadata: createAgentMessageMetadata({
-      agentId: resolvedAgentId,
-      agentName: resolveRuntimeAgentDisplayName(agentIdentityOverrides, resolvedAgentId),
-    }),
+    messageMetadata: createAgentMessageMetadata({ agentId: resolvedAgentId, agentName: resolvedAgentName }),
     onFinish: ({ responseMessage: finishedResponseMessage }: { responseMessage: ChatMessage }) => {
       resolveFinishedStream(withMessageCreatedAt(finishedResponseMessage, nowEpochMillis()))
     },
   }) as ReadableStream<ChatStreamChunk>
+  const liveTurnTrace = streamParams.writer
+    ? createLiveTurnTraceStreamObserver({
+        traceId: `trace:${Bun.randomUUIDv7()}`,
+        writer: streamParams.writer,
+        agentId: resolvedAgentId,
+        agentName: resolvedAgentName,
+      })
+    : null
   const streamStartedAt = performance.now()
   const firstVisibleOutputRecorded = yield* Ref.make(false)
   const firstTextTokenRecorded = yield* Ref.make(false)
@@ -361,6 +396,7 @@ const streamAgentResponseEffect = Effect.fn('ThreadTurnStreaming.streamAgentResp
         if (streamParams.writer) {
           yield* Effect.sync(() => {
             streamParams.writer?.write(value)
+            liveTurnTrace?.observeChunk(value)
           })
         }
       }),
@@ -371,6 +407,7 @@ const streamAgentResponseEffect = Effect.fn('ThreadTurnStreaming.streamAgentResp
     ),
     Effect.catchTag('ThreadTurnStreamingError', generateFallback),
   )
+  liveTurnTrace?.finish()
 
   for (const toolError of collectToolOutputErrors({ responseMessage: streamedResponse })) {
     aiLogger.error`Tool execution failed (agent=${resolvedAgentId}, tool=${toolError.toolName}, toolCallId=${toolError.toolCallId}): ${toolError.errorText}`
@@ -379,25 +416,20 @@ const streamAgentResponseEffect = Effect.fn('ThreadTurnStreaming.streamAgentResp
   return streamedResponse
 })
 
-export function streamAgentResponse(
-  ctx: StreamAgentResponseContext,
-  streamParams: StreamAgentResponseParams,
-): Promise<ChatMessage> {
-  return runPromise(
-    streamAgentResponseEffect(ctx, streamParams).pipe(
-      Effect.annotateSpans(
-        compactSpanAttributes({
-          ...buildThreadTurnSpanAttributes({
-            threadRef: ctx.threadRef,
-            orgRef: ctx.orgRef,
-            userRef: ctx.userRef,
-            agentId: streamParams.agentId,
-            threadType: ctx.thread.type,
-            mode: streamParams.mode,
-          }),
-          includeExecutionPlanTools: streamParams.includeExecutionPlanTools ?? true,
+export function streamAgentResponse(ctx: StreamAgentResponseContext, streamParams: StreamAgentResponseParams) {
+  return streamAgentResponseEffect(ctx, streamParams).pipe(
+    Effect.annotateSpans(
+      compactSpanAttributes({
+        ...buildThreadTurnSpanAttributes({
+          threadRef: ctx.threadRef,
+          orgRef: ctx.orgRef,
+          userRef: ctx.userRef,
+          agentId: streamParams.agentId,
+          threadType: ctx.thread.type,
+          mode: streamParams.mode,
         }),
-      ),
+        includeExecutionPlanTools: streamParams.includeExecutionPlanTools ?? true,
+      }),
     ),
   )
 }

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

@@ -2,45 +2,84 @@ 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 { BadRequestError, ForbiddenError } from '../../effect/errors'
+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'
+import { BackgroundWorkService } from '../background-work.service'
 import type { makePlanExecutorService } from '../plan/plan-executor.service'
 import { PlanExecutorServiceTag } from '../plan/plan-executor.service'
 import type { makePlanRunService } from '../plan/plan-run.service'
 import { PlanRunServiceTag } from '../plan/plan-run.service'
 import type { makeUserService } from '../user.service'
 import { UserServiceTag } from '../user.service'
+import type { makeThreadMessageService } from './thread-message.service'
+import { ThreadMessageServiceTag } from './thread-message.service'
 import type {
   PreparedThreadTurnResult,
   ThreadApprovalContinuationParams,
-  ThreadPlanTurnParams,
   ThreadTurnParams,
+  ThreadPlanTurnParams,
   makeThreadTurnPreparationService,
 } from './thread-turn-preparation.service'
 import { ThreadTurnPreparationServiceTag } from './thread-turn-preparation.service'
 import { buildThreadTurnSpanAttributes, compactSpanAttributes } from './thread-turn-tracing'
 import type { makeThreadService } from './thread.service'
 import { ThreadServiceTag } from './thread.service'
+import type { NormalizedThread } from './thread.types'
 
 export { hasApprovalRespondedParts, isApprovalContinuationRequest }
 export { wrapResponseWithKeepalive }
 export type { PreparedThreadTurnResult }
 export type { ThreadPlanTurnParams }
 
+export interface BackgroundThreadLaunchMessage {
+  parts: ChatMessage['parts']
+  metadata?: ChatMessage['metadata']
+}
+
+export interface LaunchBackgroundThreadWorkParams {
+  sourceThreadId: Parameters<typeof ensureRecordId>[0]
+  orgRef: Parameters<typeof ensureRecordId>[0]
+  userRef: Parameters<typeof ensureRecordId>[0]
+  userName?: string | null
+  targetThreadId?: Parameters<typeof ensureRecordId>[0]
+  projectTitle?: string
+  targetAgentId?: string
+  handoff: BackgroundThreadLaunchMessage
+  input: BackgroundThreadLaunchMessage
+  abortSignal?: AbortSignal
+  streamId?: string
+}
+
+export interface LaunchBackgroundThreadWorkResult {
+  launched: boolean
+  threadId: string
+  threadTitle: string
+  sourceThreadId: string
+  targetAgentId?: string
+  handoffMessageId: string
+  createdThread: boolean
+  message: string
+}
+
 class ThreadTurnServiceError extends Schema.TaggedErrorClass<ThreadTurnServiceError>()('ThreadTurnServiceError', {
   message: Schema.String,
   cause: Schema.optional(Schema.Defect),
 }) {}
 
 interface ThreadTurnDeps {
+  agentConfig: ResolvedAgentConfig
+  background: Context.Service.Shape<typeof BackgroundWorkService>
   planExecutor: ReturnType<typeof makePlanExecutorService>
   planRun: ReturnType<typeof makePlanRunService>
+  provideCurrentContext: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, never>
   thread: ReturnType<typeof makeThreadService>
+  threadMessage: ReturnType<typeof makeThreadMessageService>
   threadTurnPreparation: ReturnType<typeof makeThreadTurnPreparationService>
   user: ReturnType<typeof makeUserService>
 }
@@ -170,6 +209,129 @@ function runThreadTurnInBackgroundWith(deps: ThreadTurnDeps, params: ThreadTurnP
   )
 }
 
+function buildBackgroundLaunchMessage(params: { createdThread: boolean; threadTitle: string }) {
+  return params.createdThread
+    ? `Background work launched in "${params.threadTitle}".`
+    : `Background work launched in existing thread "${params.threadTitle}".`
+}
+
+const launchBackgroundThreadWorkEffect = Effect.fn('ThreadTurn.launchBackgroundThreadWork')(function* (
+  deps: ThreadTurnDeps,
+  params: LaunchBackgroundThreadWorkParams,
+) {
+  const orgIdString = recordIdToString(params.orgRef, TABLES.ORGANIZATION)
+  const userIdString = recordIdToString(params.userRef, TABLES.USER)
+  const sourceThreadId = recordIdToString(params.sourceThreadId, TABLES.THREAD)
+
+  const resolveTargetThread = (): Effect.Effect<
+    { thread: NormalizedThread; createdThread: boolean },
+    BadRequestError | ForbiddenError | ThreadTurnServiceError
+  > =>
+    Effect.gen(function* () {
+      if (params.targetThreadId) {
+        const existingThread = yield* deps.thread
+          .getThread(params.targetThreadId)
+          .pipe(
+            Effect.mapError((cause) => new ThreadTurnServiceError({ message: 'Failed to load target thread.', cause })),
+          )
+        if (existingThread.organizationId !== orgIdString) {
+          return yield* new ForbiddenError({ message: 'Target thread belongs to a different organization.' })
+        }
+        if (existingThread.userId !== userIdString) {
+          return yield* new ForbiddenError({ message: 'Target thread belongs to a different user.' })
+        }
+        if (existingThread.status !== 'active') {
+          return yield* new BadRequestError({ message: 'Target thread must be active.' })
+        }
+        return { thread: existingThread, createdThread: false }
+      }
+
+      const projectTitle = params.projectTitle?.trim()
+      if (!projectTitle) {
+        return yield* new BadRequestError({
+          message: 'projectTitle is required when launching background work without targetThreadId.',
+        })
+      }
+
+      const createdThread = yield* deps.thread
+        .createThread({ userId: params.userRef, organizationId: params.orgRef, title: projectTitle, type: 'group' })
+        .pipe(
+          Effect.mapError((cause) => new ThreadTurnServiceError({ message: 'Failed to create target thread.', cause })),
+        )
+      return { thread: createdThread, createdThread: true }
+    })
+
+  let createdThreadId: string | null = null
+  const cleanupCreatedThread = () =>
+    createdThreadId ? deps.thread.deleteThread(createdThreadId).pipe(Effect.catch(() => Effect.void)) : Effect.void
+
+  return yield* Effect.gen(function* () {
+    const { thread: targetThread, createdThread } = yield* resolveTargetThread()
+    if (createdThread) {
+      createdThreadId = targetThread.id
+    }
+
+    const handoffMessage = yield* deps.threadMessage.addAgentMessage({
+      messageId: { tb: TABLES.THREAD_MESSAGE, id: Bun.randomUUIDv7() },
+      threadId: ensureRecordId(targetThread.id, TABLES.THREAD),
+      parts: params.handoff.parts,
+      metadata: params.handoff.metadata,
+    })
+
+    yield* deps.background.run(
+      deps.provideCurrentContext(
+        runThreadTurnInBackgroundWith(deps, {
+          thread: targetThread,
+          threadRef: ensureRecordId(targetThread.id, TABLES.THREAD),
+          orgRef: params.orgRef,
+          userRef: params.userRef,
+          userName: params.userName,
+          agentIdOverride: params.targetAgentId,
+          inputMessage: {
+            id: Bun.randomUUIDv7(),
+            role: 'user',
+            parts: params.input.parts,
+            metadata: params.input.metadata,
+          },
+          skipInputMessagePersistence: true,
+          abortSignal: params.abortSignal,
+          streamId: params.streamId,
+        }),
+      ),
+      'thread.launchBackgroundThreadWork',
+    )
+
+    return {
+      launched: true,
+      threadId: targetThread.id,
+      threadTitle: targetThread.title,
+      sourceThreadId,
+      ...(params.targetAgentId ? { targetAgentId: params.targetAgentId } : {}),
+      handoffMessageId: handoffMessage.id,
+      createdThread,
+      message: buildBackgroundLaunchMessage({ createdThread, threadTitle: targetThread.title }),
+    } satisfies LaunchBackgroundThreadWorkResult
+  }).pipe(Effect.catch((error) => cleanupCreatedThread().pipe(Effect.andThen(Effect.fail(error)))))
+})
+
+function launchBackgroundThreadWorkWith(deps: ThreadTurnDeps, params: LaunchBackgroundThreadWorkParams) {
+  return launchBackgroundThreadWorkEffect(deps, params).pipe(
+    Effect.annotateSpans(
+      compactSpanAttributes({
+        ...buildThreadTurnSpanAttributes({
+          threadRef: params.sourceThreadId,
+          orgRef: params.orgRef,
+          userRef: params.userRef,
+          kind: 'background-launch',
+          streamId: params.streamId,
+          agentId: params.targetAgentId,
+        }),
+        targetThreadId: params.targetThreadId ? recordIdToString(params.targetThreadId, TABLES.THREAD) : undefined,
+      }),
+    ),
+  )
+}
+
 const triggerPlanNodeTurnEffect = Effect.fn('ThreadTurn.triggerPlanNodeTurn')(function* (
   deps: ThreadTurnDeps,
   params: { runId: string; nodeId: string; abortSignal?: AbortSignal; streamId?: string },
@@ -178,7 +340,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.`,
     })
@@ -187,10 +349,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)
   }
@@ -286,6 +451,9 @@ export function makeThreadTurnService(deps: ThreadTurnDeps) {
     createThreadTurnStream(params: ThreadTurnParams) {
       return createThreadTurnStreamWith(deps, params)
     },
+    launchBackgroundThreadWork(params: LaunchBackgroundThreadWorkParams) {
+      return launchBackgroundThreadWorkWith(deps, params)
+    },
     runThreadTurnInBackground(params: ThreadTurnParams) {
       return runThreadTurnInBackgroundWith(deps, params)
     },
@@ -303,44 +471,67 @@ export class ThreadTurnServiceTag extends Context.Service<
 export const ThreadTurnServiceLive = Layer.effect(
   ThreadTurnServiceTag,
   Effect.gen(function* () {
+    const currentContext = yield* Effect.context()
+    const provideCurrentContext = <A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, never> =>
+      effect.pipe(Effect.provide(currentContext)) as Effect.Effect<A, E, never>
+    const agentConfig = yield* AgentConfigServiceTag
+    const background = yield* BackgroundWorkService
     const planExecutor = yield* PlanExecutorServiceTag
     const planRun = yield* PlanRunServiceTag
     const thread = yield* ThreadServiceTag
+    const threadMessage = yield* ThreadMessageServiceTag
     const threadTurnPreparation = yield* ThreadTurnPreparationServiceTag
     const user = yield* UserServiceTag
-    return makeThreadTurnService({ planExecutor, planRun, thread, threadTurnPreparation, user })
+    return makeThreadTurnService({
+      agentConfig,
+      background,
+      planExecutor,
+      planRun,
+      provideCurrentContext,
+      thread,
+      threadMessage,
+      threadTurnPreparation,
+      user,
+    })
   }),
 )
 
-const createThreadApprovalContinuationStreamWithRuntime = Effect.fn(
-  'ThreadTurn.createApprovalContinuationStreamWithRuntime',
-)(function* (params: ThreadApprovalContinuationParams) {
-  const threadTurnService = yield* ThreadTurnServiceTag
-  return yield* threadTurnService.createThreadApprovalContinuationStream(params)
-})
+export const createThreadApprovalContinuationStream = Effect.fn('ThreadTurn.createApprovalContinuationStream')(
+  function* (params: ThreadApprovalContinuationParams) {
+    const threadTurnService = yield* ThreadTurnServiceTag
+    return yield* threadTurnService.createThreadApprovalContinuationStream(params)
+  },
+)
 
-const createThreadNativeToolApprovalStreamWithRuntime = Effect.fn(
-  'ThreadTurn.createNativeToolApprovalStreamWithRuntime',
-)(function* (params: ThreadApprovalContinuationParams) {
+export const createThreadNativeToolApprovalStream = Effect.fn('ThreadTurn.createNativeToolApprovalStream')(function* (
+  params: ThreadApprovalContinuationParams,
+) {
   const threadTurnService = yield* ThreadTurnServiceTag
   return yield* threadTurnService.createThreadNativeToolApprovalStream(params)
 })
 
-const createThreadTurnStreamWithRuntime = Effect.fn('ThreadTurn.createThreadTurnStreamWithRuntime')(function* (
+export const createThreadTurnStream = Effect.fn('ThreadTurn.createThreadTurnStream')(function* (
   params: ThreadTurnParams,
 ) {
   const threadTurnService = yield* ThreadTurnServiceTag
   return yield* threadTurnService.createThreadTurnStream(params)
 })
 
-const runThreadTurnInBackgroundWithRuntime = Effect.fn('ThreadTurn.runThreadTurnInBackgroundWithRuntime')(function* (
+export const launchBackgroundThreadWork = Effect.fn('ThreadTurn.launchBackgroundThreadWork')(function* (
+  params: LaunchBackgroundThreadWorkParams,
+) {
+  const threadTurnService = yield* ThreadTurnServiceTag
+  return yield* threadTurnService.launchBackgroundThreadWork(params)
+})
+
+export const runThreadTurnInBackground = Effect.fn('ThreadTurn.runThreadTurnInBackground')(function* (
   params: ThreadTurnParams,
 ) {
   const threadTurnService = yield* ThreadTurnServiceTag
   return yield* threadTurnService.runThreadTurnInBackground(params)
 })
 
-const triggerPlanNodeTurnWithRuntime = Effect.fn('ThreadTurn.triggerPlanNodeTurnWithRuntime')(function* (params: {
+export const triggerPlanNodeTurn = Effect.fn('ThreadTurn.triggerPlanNodeTurn')(function* (params: {
   runId: string
   nodeId: string
   abortSignal?: AbortSignal
@@ -349,28 +540,3 @@ const triggerPlanNodeTurnWithRuntime = Effect.fn('ThreadTurn.triggerPlanNodeTurn
   const threadTurnService = yield* ThreadTurnServiceTag
   return yield* threadTurnService.triggerPlanNodeTurn(params)
 })
-
-export function createThreadApprovalContinuationStream(params: ThreadApprovalContinuationParams) {
-  return runPromise(createThreadApprovalContinuationStreamWithRuntime(params))
-}
-
-export function createThreadNativeToolApprovalStream(params: ThreadApprovalContinuationParams) {
-  return runPromise(createThreadNativeToolApprovalStreamWithRuntime(params))
-}
-
-export function createThreadTurnStream(params: ThreadTurnParams) {
-  return runPromise(createThreadTurnStreamWithRuntime(params))
-}
-
-export function runThreadTurnInBackground(params: ThreadTurnParams): Promise<PreparedThreadTurnResult> {
-  return runPromise(runThreadTurnInBackgroundWithRuntime(params))
-}
-
-export function triggerPlanNodeTurn(params: {
-  runId: string
-  nodeId: string
-  abortSignal?: AbortSignal
-  streamId?: string
-}): Promise<PreparedThreadTurnResult> {
-  return runPromise(triggerPlanNodeTurnWithRuntime(params))
-}

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

@@ -2,14 +2,21 @@ 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'
@@ -35,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
@@ -63,6 +70,8 @@ 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
@@ -126,8 +135,8 @@ 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,
@@ -149,6 +158,8 @@ export function makeThreadService(deps: ThreadServiceDeps) {
   }
 
   const bootstrap = createThreadBootstrapHelpers({
+    agentConfig: deps.agentConfig,
+    threadBootstrapConfig: deps.threadBootstrapConfig,
     threadStore,
     threadMessageService: deps.threadMessageService,
     redis: deps.redis,
@@ -324,6 +335,8 @@ export class ThreadServiceTag extends Context.Service<ThreadServiceTag, ReturnTy
 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
@@ -332,6 +345,8 @@ export const ThreadServiceLive = Layer.effect(
     const compactionCoordination = yield* CompactionCoordinationTag
     const background = yield* BackgroundWorkService
     return makeThreadService({
+      agentConfig,
+      threadBootstrapConfig,
       db,
       redis,
       chatRunRegistry,

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

@@ -3,7 +3,7 @@ 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,
@@ -12,8 +12,8 @@ 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,
     }),
   })