@lota-sdk/core 0.4.10 → 0.4.11

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

@@ -3,10 +3,10 @@ import { SUBMIT_PLAN_TURN_RESULT_TOOL_NAME, toTimestamp, withMessageCreatedAt }
 import type { ToolSet, UIMessageStreamWriter } from 'ai'
 import { Schema, Effect } from 'effect'
 
+import type { ResolvedAgentConfig } from '../../config/agent-defaults'
 import { aiLogger } from '../../config/logger'
 import type { RecordIdRef } from '../../db/record-id'
 import { effectTryMaybeAsync, effectTryPromise as effectTryPromiseShared } from '../../effect/helpers'
-import { runPromise } from '../../effect/runtime'
 import type { readRuntimeAgentIdentityOverrides } from '../../runtime/agent-identity-overrides'
 import { resolveRuntimeAgentDisplayName } from '../../runtime/agent-identity-overrides'
 import { OWNERSHIP_DISPATCH_BLOCKED_TOOL_NAMES } from '../../runtime/agent-runtime-policy'
@@ -67,6 +67,7 @@ interface VisibleAgentRunParams {
 }
 
 interface VisibleAgentRunnerDeps<TBuildTurnToolParams> {
+  agentConfig: ResolvedAgentConfig
   agentFactoryConfig: { buildAgentTools: (params: TBuildTurnToolParams) => Promise<ToolSet> | ToolSet }
   buildTurnToolParams: (params: {
     agentId: string
@@ -100,10 +101,10 @@ export function createThreadTurnVisibleAgentRunner<TBuildTurnToolParams>(
     { message: Schema.String, cause: Schema.optional(Schema.Defect) },
   ) {}
 
-  const effectTryPromise = <A>(
-    evaluate: () => PromiseLike<A> | Effect.Effect<A, unknown>,
+  const effectTryPromise = <A, R = never>(
+    evaluate: () => PromiseLike<A> | Effect.Effect<A, unknown, R>,
     message: string,
-  ): Effect.Effect<A, ThreadTurnExecutionError> =>
+  ): Effect.Effect<A, ThreadTurnExecutionError, R> =>
     effectTryPromiseShared(evaluate, (error) => new ThreadTurnExecutionError({ message, cause: error }))
 
   function effectFromMaybePromise<A>(
@@ -130,14 +131,13 @@ export function createThreadTurnVisibleAgentRunner<TBuildTurnToolParams>(
       )
 
   const createObserver = (agentId: string) => ({
-    run: <T>(fn: () => T | Promise<T>) =>
-      runPromise(
-        effectTryMaybeAsync(
-          fn,
-          (error) =>
-            new ThreadTurnExecutionError({ message: `Agent observer run failed (agent=${agentId}).`, cause: error }),
-        ),
-      ),
+    run: async <T>(fn: () => T | Promise<T>): Promise<T> => {
+      try {
+        return await fn()
+      } catch (error) {
+        throw new ThreadTurnExecutionError({ message: `Agent observer run failed (agent=${agentId}).`, cause: error })
+      }
+    },
     recordError: (error: unknown) => {
       aiLogger.error`Agent run failed (agent=${agentId}): ${error}`
     },
@@ -151,54 +151,53 @@ export function createThreadTurnVisibleAgentRunner<TBuildTurnToolParams>(
     agentId: string,
     agentName: string,
     metadataPatch?: NonNullable<MessageMetadata>,
-  ): Promise<ChatMessage> =>
-    runPromise(
-      Effect.gen(function* () {
-        yield* failIfRunAborted()
-
-        const toCommittedAssistantMessage = (
-          message: ChatMessage,
-          resolvedAgentId: string,
-          resolvedAgentName: string,
-          patch?: NonNullable<MessageMetadata>,
-        ) =>
-          withMessageCreatedAt(
-            {
-              ...message,
-              metadata: {
-                ...message.metadata,
-                ...buildAgentMetadataPatch(resolvedAgentId, resolvedAgentName),
-                ...patch,
-              },
-            },
-            toTimestamp(message.metadata?.createdAt) ?? nowEpochMillis(),
-          )
-
-        const committedConsultMessages = collectCompletedConsultTeamMessages({ responseMessage: response }).flatMap(
-          (consultMessage) => {
-            const consultAgentId = readOptionalString(consultMessage.metadata?.agentId)
-            const consultAgentName = readOptionalString(consultMessage.metadata?.agentName)
-            if (!consultAgentId || !consultAgentName) {
-              return []
-            }
-
-            return [toCommittedAssistantMessage(consultMessage, consultAgentId, consultAgentName)]
+  ) =>
+    Effect.gen(function* () {
+      // Persist the response even if the run is being interrupted (e.g., lease
+      // refresh was rejected between the final stream chunk and this commit).
+      // The LLM tokens have already been consumed; the message must reach the
+      // thread history so callers and post-turn side effects observe the
+      // completed turn. `Effect.uninterruptible` shields the persist from the
+      // surrounding interrupt without blocking later steps from handling it.
+      const toCommittedAssistantMessage = (
+        message: ChatMessage,
+        resolvedAgentId: string,
+        resolvedAgentName: string,
+        patch?: NonNullable<MessageMetadata>,
+      ) =>
+        withMessageCreatedAt(
+          {
+            ...message,
+            metadata: { ...message.metadata, ...buildAgentMetadataPatch(resolvedAgentId, resolvedAgentName), ...patch },
           },
+          toTimestamp(message.metadata?.createdAt) ?? nowEpochMillis(),
         )
 
-        const committed = toCommittedAssistantMessage(response, agentId, agentName, metadataPatch)
-        const messagesToPersist = [...committedConsultMessages, committed]
-        yield* deps.threadMessageService.upsertMessagesEffect({ threadId: deps.threadRef, messages: messagesToPersist })
+      const committedConsultMessages = collectCompletedConsultTeamMessages({ responseMessage: response }).flatMap(
+        (consultMessage) => {
+          const consultAgentId = readOptionalString(consultMessage.metadata?.agentId)
+          const consultAgentName = readOptionalString(consultMessage.metadata?.agentName)
+          if (!consultAgentId || !consultAgentName) {
+            return []
+          }
 
-        for (const persistedMessage of messagesToPersist) {
-          deps.threadTurnMessageContext.appendMessages([persistedMessage])
-          deps.onPersistedMessage(persistedMessage)
-        }
-        yield* failIfRunAborted()
+          return [toCommittedAssistantMessage(consultMessage, consultAgentId, consultAgentName)]
+        },
+      )
 
-        return committed
-      }),
-    )
+      const committed = toCommittedAssistantMessage(response, agentId, agentName, metadataPatch)
+      const messagesToPersist = [...committedConsultMessages, committed]
+      yield* Effect.uninterruptible(
+        deps.threadMessageService.upsertMessagesEffect({ threadId: deps.threadRef, messages: messagesToPersist }),
+      )
+
+      for (const persistedMessage of messagesToPersist) {
+        deps.threadTurnMessageContext.appendMessages([persistedMessage])
+        deps.onPersistedMessage(persistedMessage)
+      }
+
+      return committed
+    })
 
   const runVisibleAgentEffect = Effect.fn('ThreadTurnExecution.runVisibleAgent')(function* (
     runParams: VisibleAgentRunParams,
@@ -243,36 +242,41 @@ export function createThreadTurnVisibleAgentRunner<TBuildTurnToolParams>(
     ).pipe(Effect.withSpan('ThreadTurnExecution.streamVisibleAgent'))
     deps.setMemoryBlock(runMemoryBlock)
 
-    return yield* effectTryPromise(
-      () =>
-        commitAssistantResponse(
-          responseMessage,
-          runParams.agentId,
-          resolveRuntimeAgentDisplayName(deps.agentIdentityOverrides, runParams.agentId),
-          runParams.metadataPatch,
-        ),
-      `Failed to commit assistant response for ${runParams.agentId}.`,
-    ).pipe(Effect.withSpan('ThreadTurnExecution.commitAssistantResponse'))
+    // Commit the response under `uninterruptible` so a late lease-lost or
+    // stop signal arriving after the stream completed still writes the
+    // already-generated assistant message into the thread history. Without
+    // this, a race between stream completion and lease refresh rejection
+    // swallows the response without any error trace.
+    return yield* Effect.uninterruptible(
+      effectTryPromise(
+        () =>
+          commitAssistantResponse(
+            responseMessage,
+            runParams.agentId,
+            resolveRuntimeAgentDisplayName(deps.agentConfig, deps.agentIdentityOverrides, runParams.agentId),
+            runParams.metadataPatch,
+          ),
+        `Failed to commit assistant response for ${runParams.agentId}.`,
+      ).pipe(Effect.withSpan('ThreadTurnExecution.commitAssistantResponse')),
+    )
   })
 
-  const runVisibleAgent = (runParams: VisibleAgentRunParams): Promise<ChatMessage> =>
-    runPromise(
-      runVisibleAgentEffect(runParams).pipe(
-        Effect.annotateSpans(
-          compactSpanAttributes({
-            ...buildThreadTurnSpanAttributes({
-              threadRef: deps.threadRef,
-              orgRef: deps.streamCtx.orgRef,
-              userRef: deps.streamCtx.userRef,
-              agentId: runParams.agentId,
-              threadType: deps.streamCtx.thread.type,
-              mode: runParams.mode,
-            }),
-            includeExecutionPlanTools: runParams.includeExecutionPlanTools ?? runParams.mode !== 'fixedThreadMode',
-            extraMessageCount: runParams.extraMessages?.length ?? 0,
-            extraToolCount: runParams.extraTools ? Object.keys(runParams.extraTools).length : 0,
+  const runVisibleAgent = (runParams: VisibleAgentRunParams) =>
+    runVisibleAgentEffect(runParams).pipe(
+      Effect.annotateSpans(
+        compactSpanAttributes({
+          ...buildThreadTurnSpanAttributes({
+            threadRef: deps.threadRef,
+            orgRef: deps.streamCtx.orgRef,
+            userRef: deps.streamCtx.userRef,
+            agentId: runParams.agentId,
+            threadType: deps.streamCtx.thread.type,
+            mode: runParams.mode,
           }),
-        ),
+          includeExecutionPlanTools: runParams.includeExecutionPlanTools ?? runParams.mode !== 'fixedThreadMode',
+          extraMessageCount: runParams.extraMessages?.length ?? 0,
+          extraToolCount: runParams.extraTools ? Object.keys(runParams.extraTools).length : 0,
+        }),
       ),
     )
 

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

@@ -13,12 +13,6 @@ import type { UIMessageStreamWriter } from 'ai'
 import { Clock, Context, Schema, Effect, Layer } from 'effect'
 
 import type { CoreThreadProfile } from '../../config/agent-defaults'
-import {
-  getAgentRoster,
-  getLeadAgentId,
-  getCoreThreadProfile,
-  getResolvedAgentFactoryConfig,
-} from '../../config/agent-defaults'
 import { aiLogger } from '../../config/logger'
 import type { RecordIdRef } from '../../db/record-id'
 import { recordIdToString } from '../../db/record-id'
@@ -26,8 +20,15 @@ import { TABLES } from '../../db/tables'
 import type { DatabaseError, ServiceError } from '../../effect/errors'
 import { ThreadTurnError } from '../../effect/errors'
 import { makeEffectTryPromiseWithMessage } from '../../effect/helpers'
-import { enqueueContextCompaction } from '../../queues/context-compaction.queue'
-import { enqueueThreadTitleGeneration } from '../../queues/title-generation.queue'
+import {
+  AgentConfigServiceTag,
+  AgentFactoryServiceTag,
+  RuntimeAdaptersServiceTag,
+  TurnHooksServiceTag,
+} from '../../effect/services'
+import type { ContextCompactionQueueRuntime } from '../../queues/context-compaction.queue'
+import { LotaQueuesServiceTag } from '../../queues/queues.service'
+import type { TitleGenerationQueueRuntime } from '../../queues/title-generation.queue'
 import {
   readRuntimeAgentIdentityOverrides,
   resolveRuntimeAgentDisplayName,
@@ -42,7 +43,6 @@ import { createExecutionPlanInstructionSectionCache, toExecutionPlanCacheError }
 import type { HelperModelRuntime } from '../../runtime/helper-model'
 import { HelperModelTag } from '../../runtime/helper-model'
 import { runPostTurnSideEffects } from '../../runtime/post-turn-side-effects'
-import { getRuntimeAdapters, getTurnHooks } from '../../runtime/runtime-extensions'
 import { extractMessageText, toOptionalTrimmedString } from '../../runtime/thread-chat-helpers'
 import {
   buildPlanTurnInstructionSections,
@@ -93,6 +93,8 @@ interface ThreadTurnPreparationServiceContext {
   threadMessageService: ReturnType<typeof makeThreadMessageService>
   threadService: ReturnType<typeof makeThreadService>
   contextCompactionRuntime: ReturnType<typeof createWiredContextCompactionRuntime>
+  contextCompactionQueue: ContextCompactionQueueRuntime
+  titleGenerationQueue: TitleGenerationQueueRuntime
 }
 
 type ThreadTurnPreparationRuntimeDeps = ThreadTurnPreparationServiceContext
@@ -365,8 +367,10 @@ const prepareThreadRunCoreEffect = Effect.fn('ThreadTurnPreparation.prepareThrea
   deps: ThreadTurnPreparationRuntimeDeps,
   params: ThreadRunCoreParams,
 ) {
-  const runtimeAdapters = getRuntimeAdapters()
-  const turnHooks = getTurnHooks()
+  const runtimeAdapters = yield* RuntimeAdaptersServiceTag
+  const turnHooks = yield* TurnHooksServiceTag
+  const agentConfig = yield* AgentConfigServiceTag
+  const agentFactoryConfig = yield* AgentFactoryServiceTag
   const workspaceProvider = runtimeAdapters.workspaceProvider
   const workspacePromise =
     params.kind !== 'approvalContinuation' && workspaceProvider
@@ -488,17 +492,19 @@ const prepareThreadRunCoreEffect = Effect.fn('ThreadTurnPreparation.prepareThrea
     threadRecord.title === THREAD.DEFAULT_TITLE &&
     messageText.length > 0
   ) {
-    void safeEnqueue(() => enqueueThreadTitleGeneration({ threadId: threadIdString, sourceText: messageText }), {
-      operationName: 'thread-title-generation',
-    })
+    void safeEnqueue(
+      () =>
+        deps.titleGenerationQueue.enqueueThreadTitleGeneration({ threadId: threadIdString, sourceText: messageText }),
+      { operationName: 'thread-title-generation' },
+    )
   }
 
   if (thread.type === 'thread' && !thread.threadType) {
     return yield* new ThreadTurnError({ message: 'Core threads require a thread type.', reason: 'bad-request' })
   }
   const coreThreadProfile: CoreThreadProfile | null =
-    thread.type === 'thread' && thread.threadType ? getCoreThreadProfile(thread.threadType) : null
-  const defaultLeadAgentId = getLeadAgentId()
+    thread.type === 'thread' && thread.threadType ? agentConfig.getCoreThreadProfile(thread.threadType) : null
+  const defaultLeadAgentId = agentConfig.leadAgentId
   const visibleThreadAgentId =
     params.agentIdOverride ??
     (thread.type === 'default' ? thread.agentId : (coreThreadProfile?.config.agentId ?? defaultLeadAgentId))
@@ -517,6 +523,8 @@ const prepareThreadRunCoreEffect = Effect.fn('ThreadTurnPreparation.prepareThrea
         workspacePromise,
         workspaceProvider,
         turnHooks,
+        runtimeAdapters,
+        pluginRuntime: agentFactoryConfig.pluginRuntime,
       }),
     'Failed to assemble thread turn context.',
   ).pipe(Effect.withSpan('ThreadTurnPreparation.assembleThreadTurnContext'))
@@ -674,7 +682,11 @@ const prepareThreadRunCoreEffect = Effect.fn('ThreadTurnPreparation.prepareThrea
     serverRunId: string
     runAbort: ReturnType<typeof createServerRunAbortController>
     writer?: UIMessageStreamWriter<ChatMessage>
-  }): Effect.Effect<PreparedThreadTurnResult | void, DatabaseError | ThreadTurnError | ThreadTurnPreparationError> =>
+  }): Effect.Effect<
+    PreparedThreadTurnResult | void,
+    DatabaseError | ThreadTurnError | ThreadTurnPreparationError,
+    unknown
+  > =>
     Effect.ensuring(
       Effect.gen(function* () {
         const currentRunAbort = runParams.runAbort
@@ -693,8 +705,6 @@ const prepareThreadRunCoreEffect = Effect.fn('ThreadTurnPreparation.prepareThrea
             .pipe(Effect.withSpan('ThreadTurnPreparation.setActiveTurn'))
         }
 
-        const agentFactoryConfig = getResolvedAgentFactoryConfig()
-
         const streamCtx: StreamAgentResponseContext = {
           turnHooks,
           thread,
@@ -717,6 +727,7 @@ const prepareThreadRunCoreEffect = Effect.fn('ThreadTurnPreparation.prepareThrea
         }
 
         const { runVisibleAgent } = createThreadTurnVisibleAgentRunner({
+          agentConfig,
           agentFactoryConfig: { buildAgentTools: agentFactoryConfig.buildAgentTools },
           buildTurnToolParams,
           threadTurnMessageContext,
@@ -778,7 +789,7 @@ const prepareThreadRunCoreEffect = Effect.fn('ThreadTurnPreparation.prepareThrea
           ).pipe(Effect.withSpan('ThreadTurnPreparation.executeDirectThread'))
         } else {
           const wsMembers = (thread as { members?: string[] }).members ?? []
-          const members = wsMembers.length > 0 ? wsMembers : [...getAgentRoster()]
+          const members = wsMembers.length > 0 ? wsMembers : [...agentConfig.roster]
           const fallbackAgentId = coreThreadProfile?.config.agentId ?? defaultLeadAgentId
           yield* failIfRunAborted()
           writeMultiAgentEvent(runParams.writer, { phase: 'routing', note: 'Routing this turn to the right agent.' })
@@ -791,6 +802,7 @@ const prepareThreadRunCoreEffect = Effect.fn('ThreadTurnPreparation.prepareThrea
           const triageResult = yield* effectTryPromise(
             () =>
               triageThreadMessage({
+                agentConfig,
                 threadTitle: thread.title,
                 members,
                 messageText,
@@ -841,6 +853,7 @@ const prepareThreadRunCoreEffect = Effect.fn('ThreadTurnPreparation.prepareThrea
               const checkResult = yield* effectTryPromise(
                 () =>
                   checkForNextAgent({
+                    agentConfig,
                     threadTitle: thread.title,
                     members,
                     messageText,
@@ -859,7 +872,7 @@ const prepareThreadRunCoreEffect = Effect.fn('ThreadTurnPreparation.prepareThrea
               writeMultiAgentEvent(runParams.writer, {
                 phase: 'waiting-for-agent',
                 agentId: checkResult.agentId,
-                agentName: resolveRuntimeAgentDisplayName(agentIdentityOverrides, checkResult.agentId),
+                agentName: resolveRuntimeAgentDisplayName(agentConfig, agentIdentityOverrides, checkResult.agentId),
                 note: checkResult.routingContext ?? undefined,
               })
 
@@ -890,7 +903,7 @@ const prepareThreadRunCoreEffect = Effect.fn('ThreadTurnPreparation.prepareThrea
               writeMultiAgentEvent(runParams.writer, {
                 phase: 'agent-message-persisted',
                 agentId: checkResult.agentId,
-                agentName: resolveRuntimeAgentDisplayName(agentIdentityOverrides, checkResult.agentId),
+                agentName: resolveRuntimeAgentDisplayName(agentConfig, agentIdentityOverrides, checkResult.agentId),
                 messageId: lastResponse.id,
               })
             }
@@ -919,7 +932,7 @@ const prepareThreadRunCoreEffect = Effect.fn('ThreadTurnPreparation.prepareThrea
               contextSize: CONTEXT_WINDOW_TOKENS,
             }),
           enqueueCompaction: () =>
-            enqueueContextCompaction({
+            deps.contextCompactionQueue.enqueueContextCompaction({
               domain: 'thread',
               entityId: threadIdString,
               contextSize: CONTEXT_WINDOW_TOKENS,
@@ -1049,7 +1062,10 @@ const prepareThreadRunCoreEffect = Effect.fn('ThreadTurnPreparation.prepareThrea
             }),
           )
 
-    return runEffect.pipe(Effect.withSpan('ThreadTurnPreparation.executeRun'), Effect.provide(currentContext))
+    return runEffect.pipe(
+      Effect.withSpan('ThreadTurnPreparation.executeRun'),
+      Effect.provide(currentContext),
+    ) as Effect.Effect<PreparedThreadTurnResult, DatabaseError | ThreadTurnError | ThreadTurnPreparationError, never>
   }
 
   return { originalMessages, run }
@@ -1066,6 +1082,8 @@ interface ThreadTurnPreparationDeps {
   threadMessage: ReturnType<typeof makeThreadMessageService>
   thread: ReturnType<typeof makeThreadService>
   helperModelRuntime: HelperModelRuntime
+  contextCompactionQueue: ContextCompactionQueueRuntime
+  titleGenerationQueue: TitleGenerationQueueRuntime
 }
 
 export function makeThreadTurnPreparationService(deps: ThreadTurnPreparationDeps) {
@@ -1084,6 +1102,8 @@ export function makeThreadTurnPreparationService(deps: ThreadTurnPreparationDeps
       now: nowEpochMillis,
       randomId: () => Bun.randomUUIDv7(),
     }),
+    contextCompactionQueue: deps.contextCompactionQueue,
+    titleGenerationQueue: deps.titleGenerationQueue,
   }
   const annotateTurnSpans = <A, E, R>(params: ThreadRunCoreParams, effect: Effect.Effect<A, E, R>) =>
     effect.pipe(
@@ -1132,6 +1152,7 @@ export const ThreadTurnPreparationServiceLive = Layer.effect(
     const planRun = yield* PlanRunServiceTag
     const threadMessage = yield* ThreadMessageServiceTag
     const thread = yield* ThreadServiceTag
+    const queues = yield* LotaQueuesServiceTag
     return makeThreadTurnPreparationService({
       attachment,
       chatRunRegistry,
@@ -1143,6 +1164,8 @@ export const ThreadTurnPreparationServiceLive = Layer.effect(
       threadMessage,
       thread,
       helperModelRuntime: yield* HelperModelTag,
+      contextCompactionQueue: queues.contextCompaction,
+      titleGenerationQueue: queues.titleGeneration,
     })
   }),
 )

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

@@ -4,18 +4,17 @@ 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 type { LotaRuntimeTurnHooks } from '../../runtime/runtime-extensions'
 import {
   asRecord,
   collectToolOutputErrors,
@@ -122,7 +121,7 @@ function buildFallbackResponseMessage(
 }
 
 export interface StreamAgentResponseContext {
-  turnHooks: ReturnType<typeof getTurnHooks>
+  turnHooks: LotaRuntimeTurnHooks
   thread: NormalizedThread
   threadRef: RecordIdRef
   orgRef: RecordIdRef
@@ -226,8 +225,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,
@@ -322,7 +322,7 @@ const streamAgentResponseEffect = Effect.fn('ThreadTurnStreaming.streamAgentResp
     sendSources: true,
     messageMetadata: createAgentMessageMetadata({
       agentId: resolvedAgentId,
-      agentName: resolveRuntimeAgentDisplayName(agentIdentityOverrides, resolvedAgentId),
+      agentName: resolveRuntimeAgentDisplayName(agentConfig, agentIdentityOverrides, resolvedAgentId),
     }),
     onFinish: ({ responseMessage: finishedResponseMessage }: { responseMessage: ChatMessage }) => {
       resolveFinishedStream(withMessageCreatedAt(finishedResponseMessage, nowEpochMillis()))
@@ -379,25 +379,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,10 +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 { AgentConfigServiceTag } from '../../effect/services'
 import { hasApprovalRespondedParts, isApprovalContinuationRequest } from '../../runtime/approval-continuation'
 import { shouldPlanNodeUseVisibleTurn } from '../../runtime/execution-plan-visibility'
 import { wrapResponseWithKeepalive } from '../../utils/sse-keepalive'
@@ -38,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>
@@ -178,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.`,
     })
@@ -187,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)
   }
@@ -303,44 +308,45 @@ export class ThreadTurnServiceTag extends Context.Service<
 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 })
   }),
 )
 
-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 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 +355,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))
-}