@lota-sdk/core 0.4.9 → 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,19 +131,18 @@ 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}`
     },
     recordAbort: (error: unknown) => {
-      aiLogger.info`Agent run aborted (agent=${agentId}): ${error instanceof Error ? error.message : String(error)}`
+      aiLogger.debug`Agent run aborted (agent=${agentId}): ${error instanceof Error ? error.message : String(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'))
@@ -570,20 +578,22 @@ const prepareThreadRunCoreEffect = Effect.fn('ThreadTurnPreparation.prepareThrea
       return Effect.succeed(preSeededMemoriesByAgent.get(agentId))
     }
 
-    return Effect.gen(function* () {
-      const preSeededMemories = yield* memoryService.getTopMemories({
-        orgId: orgIdString,
-        agentName: agentId,
-        limit: PRESEEDED_MEMORY_LOOKUP_LIMIT,
-      })
-      preSeededMemoriesByAgent.set(agentId, preSeededMemories)
-      return preSeededMemories
-    }).pipe(
-      Effect.mapError(
-        (error) =>
-          new ThreadTurnStreamingError({ message: `Failed to load pre-seeded memories for ${agentId}.`, cause: error }),
-      ),
-    )
+    return memoryService
+      .getTopMemories({ orgId: orgIdString, agentName: agentId, limit: PRESEEDED_MEMORY_LOOKUP_LIMIT })
+      .pipe(
+        Effect.tap((preSeededMemories) =>
+          Effect.sync(() => {
+            preSeededMemoriesByAgent.set(agentId, preSeededMemories)
+          }),
+        ),
+        Effect.mapError(
+          (error) =>
+            new ThreadTurnStreamingError({
+              message: `Failed to load pre-seeded memories for ${agentId}.`,
+              cause: error,
+            }),
+        ),
+      )
   }
 
   const learnedSkillsByAgent = new Map<string, string | undefined>()
@@ -672,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
@@ -691,8 +705,6 @@ const prepareThreadRunCoreEffect = Effect.fn('ThreadTurnPreparation.prepareThrea
             .pipe(Effect.withSpan('ThreadTurnPreparation.setActiveTurn'))
         }
 
-        const agentFactoryConfig = getResolvedAgentFactoryConfig()
-
         const streamCtx: StreamAgentResponseContext = {
           turnHooks,
           thread,
@@ -715,6 +727,7 @@ const prepareThreadRunCoreEffect = Effect.fn('ThreadTurnPreparation.prepareThrea
         }
 
         const { runVisibleAgent } = createThreadTurnVisibleAgentRunner({
+          agentConfig,
           agentFactoryConfig: { buildAgentTools: agentFactoryConfig.buildAgentTools },
           buildTurnToolParams,
           threadTurnMessageContext,
@@ -776,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.' })
@@ -789,6 +802,7 @@ const prepareThreadRunCoreEffect = Effect.fn('ThreadTurnPreparation.prepareThrea
           const triageResult = yield* effectTryPromise(
             () =>
               triageThreadMessage({
+                agentConfig,
                 threadTitle: thread.title,
                 members,
                 messageText,
@@ -839,6 +853,7 @@ const prepareThreadRunCoreEffect = Effect.fn('ThreadTurnPreparation.prepareThrea
               const checkResult = yield* effectTryPromise(
                 () =>
                   checkForNextAgent({
+                    agentConfig,
                     threadTitle: thread.title,
                     members,
                     messageText,
@@ -857,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,
               })
 
@@ -888,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,
               })
             }
@@ -917,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,
@@ -1047,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 }
@@ -1064,6 +1082,8 @@ interface ThreadTurnPreparationDeps {
   threadMessage: ReturnType<typeof makeThreadMessageService>
   thread: ReturnType<typeof makeThreadService>
   helperModelRuntime: HelperModelRuntime
+  contextCompactionQueue: ContextCompactionQueueRuntime
+  titleGenerationQueue: TitleGenerationQueueRuntime
 }
 
 export function makeThreadTurnPreparationService(deps: ThreadTurnPreparationDeps) {
@@ -1082,8 +1102,10 @@ export function makeThreadTurnPreparationService(deps: ThreadTurnPreparationDeps
       now: nowEpochMillis,
       randomId: () => Bun.randomUUIDv7(),
     }),
+    contextCompactionQueue: deps.contextCompactionQueue,
+    titleGenerationQueue: deps.titleGenerationQueue,
   }
-  const annotateTurnSpans = <A, E>(params: ThreadRunCoreParams, effect: Effect.Effect<A, E>) =>
+  const annotateTurnSpans = <A, E, R>(params: ThreadRunCoreParams, effect: Effect.Effect<A, E, R>) =>
     effect.pipe(
       Effect.annotateSpans(
         compactSpanAttributes({
@@ -1116,7 +1138,7 @@ export function makeThreadTurnPreparationService(deps: ThreadTurnPreparationDeps
 export class ThreadTurnPreparationServiceTag extends Context.Service<
   ThreadTurnPreparationServiceTag,
   ReturnType<typeof makeThreadTurnPreparationService>
->()('ThreadTurnPreparationService') {}
+>()('@lota-sdk/core/ThreadTurnPreparationService') {}
 
 export const ThreadTurnPreparationServiceLive = Layer.effect(
   ThreadTurnPreparationServiceTag,
@@ -1130,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,
@@ -1141,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, effectTryPromise as effectTryPromiseShared } from '../../effect/helpers'
-import { runPromise } from '../../effect/runtime'
+import { effectTryMaybeAsync, makeEffectTryPromiseWithMessage } from '../../effect/helpers'
+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,
@@ -44,12 +43,9 @@ export class ThreadTurnStreamingError extends Schema.TaggedErrorClass<ThreadTurn
   { message: Schema.String, cause: Schema.optional(Schema.Defect) },
 ) {}
 
-function effectTryPromise<A>(
-  evaluate: () => PromiseLike<A>,
-  message: string,
-): Effect.Effect<A, ThreadTurnStreamingError> {
-  return effectTryPromiseShared(evaluate, (error) => new ThreadTurnStreamingError({ message, cause: error }))
-}
+const effectTryPromise = makeEffectTryPromiseWithMessage(
+  (message, cause) => new ThreadTurnStreamingError({ message, cause }),
+)
 
 function effectFromMaybeEffect<A>(
   evaluate: () => A | PromiseLike<A> | Effect.Effect<A, ThreadTurnStreamingError>,
@@ -93,7 +89,9 @@ function isTextTokenChunkType(chunkType: string | undefined): boolean {
   return chunkType === 'text-delta'
 }
 
-function buildFallbackResponseMessage(result: ToolLoopGenerateResult): ChatMessage {
+function buildFallbackResponseMessage(
+  result: ToolLoopGenerateResult,
+): Effect.Effect<ChatMessage, ThreadTurnStreamingError> {
   const parts: ChatMessage['parts'] = []
 
   for (const step of result.steps ?? []) {
@@ -114,14 +112,16 @@ function buildFallbackResponseMessage(result: ToolLoopGenerateResult): ChatMessa
   }
 
   if (parts.length === 0) {
-    throw new Error('Agent generate fallback did not produce any response parts.')
+    return Effect.fail(
+      new ThreadTurnStreamingError({ message: 'Agent generate fallback did not produce any response parts.' }),
+    )
   }
 
-  return { id: Bun.randomUUIDv7(), role: 'assistant', parts }
+  return Effect.succeed({ id: Bun.randomUUIDv7(), role: 'assistant', parts })
 }
 
 export interface StreamAgentResponseContext {
-  turnHooks: ReturnType<typeof getTurnHooks>
+  turnHooks: LotaRuntimeTurnHooks
   thread: NormalizedThread
   threadRef: RecordIdRef
   orgRef: RecordIdRef
@@ -225,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,
@@ -287,7 +288,7 @@ const streamAgentResponseEffect = Effect.fn('ThreadTurnStreaming.streamAgentResp
           aiLogger.warn`Agent stream failed for ${resolvedAgentId}; falling back to generate: ${cause.message}`
         }),
       ),
-      Effect.map((result) => buildFallbackResponseMessage(result as ToolLoopGenerateResult)),
+      Effect.flatMap((result) => buildFallbackResponseMessage(result as ToolLoopGenerateResult)),
     )
 
   const result = yield* effectTryPromise(
@@ -321,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()))
@@ -378,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,
+      }),
     ),
   )
 }