@lota-sdk/core 0.4.10 → 0.4.12

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,
@@ -980,27 +993,9 @@ const prepareThreadRunCoreEffect = Effect.fn('ThreadTurnPreparation.prepareThrea
           ).pipe(Effect.withSpan('ThreadTurnPreparation.runPostTurnSideEffects'))
         }
 
-        if (allAssistantMessages.length > 0 && params.kind !== 'planTurn') {
-          const afterTurn = turnHooks.afterTurn
-          if (afterTurn) {
-            yield* effectTryPromise(
-              () =>
-                afterTurn({
-                  thread,
-                  threadRef,
-                  orgRef,
-                  userRef,
-                  userName,
-                  onboardingActive,
-                  referenceUserMessage,
-                  assistantMessages: allAssistantMessages,
-                  latestThreadRecord,
-                  context: buildContextResult,
-                }),
-              'Failed to run afterTurn hook.',
-            ).pipe(Effect.withSpan('ThreadTurnPreparation.afterTurnHook'))
-          }
-        }
+        yield* Effect.sync(() => {
+          launchAfterTurnHook(latestThreadRecord)
+        })
       }).pipe(
         Effect.catch((postRunError) =>
           Effect.sync(() => {
@@ -1021,6 +1016,48 @@ const prepareThreadRunCoreEffect = Effect.fn('ThreadTurnPreparation.prepareThrea
     assistantMessages: [...allAssistantMessages],
   })
 
+  const launchAfterTurnHook = (latestThreadRecord: typeof threadRecord) => {
+    if (allAssistantMessages.length === 0 || params.kind === 'planTurn') {
+      return
+    }
+
+    const afterTurn = turnHooks.afterTurn
+    if (!afterTurn) {
+      return
+    }
+
+    // `afterTurn` is host-owned follow-up work. Launch it detached so the
+    // streamed turn closes after persistence/finalization instead of waiting on
+    // onboarding/map side effects in the request path.
+    void runPromiseWithCurrentContext(
+      effectTryPromise(
+        () =>
+          afterTurn({
+            thread,
+            threadRef,
+            orgRef,
+            userRef,
+            userName,
+            onboardingActive,
+            referenceUserMessage,
+            assistantMessages: allAssistantMessages,
+            latestThreadRecord,
+            context: buildContextResult,
+          }),
+        'Failed to run afterTurn hook.',
+      ).pipe(
+        Effect.withSpan('ThreadTurnPreparation.afterTurnHook'),
+        Effect.catch((error) =>
+          Effect.sync(() => {
+            aiLogger.error`Thread afterTurn hook failed: ${error}`
+          }),
+        ),
+      ),
+    ).catch((error) => {
+      aiLogger.error`Thread afterTurn hook scheduling failed: ${error}`
+    })
+  }
+
   const run = (writer?: UIMessageStreamWriter<ChatMessage>) => {
     const serverRunId = Bun.randomUUIDv7()
 
@@ -1049,7 +1086,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 +1106,8 @@ interface ThreadTurnPreparationDeps {
   threadMessage: ReturnType<typeof makeThreadMessageService>
   thread: ReturnType<typeof makeThreadService>
   helperModelRuntime: HelperModelRuntime
+  contextCompactionQueue: ContextCompactionQueueRuntime
+  titleGenerationQueue: TitleGenerationQueueRuntime
 }
 
 export function makeThreadTurnPreparationService(deps: ThreadTurnPreparationDeps) {
@@ -1084,6 +1126,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 +1176,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 +1188,8 @@ export const ThreadTurnPreparationServiceLive = Layer.effect(
       threadMessage,
       thread,
       helperModelRuntime: yield* HelperModelTag,
+      contextCompactionQueue: queues.contextCompaction,
+      titleGenerationQueue: queues.titleGeneration,
     })
   }),
 )