@lota-sdk/core 0.4.13 → 0.4.14

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

@@ -12,14 +12,15 @@ import { tool as createTool, validateUIMessages } from 'ai'
 import type { UIMessageStreamWriter } from 'ai'
 import { Clock, Context, Schema, Effect, Layer } from 'effect'
 
-import type { CoreThreadProfile } from '../../config/agent-defaults'
+import { AiGatewayModelsTag, RuntimeBridgeTag } from '../../ai-gateway/ai-gateway'
+import type { AiGatewayModels } from '../../ai-gateway/ai-gateway'
+import type { CoreThreadProfile, ResolvedAgentConfig } from '../../config/agent-defaults'
 import { aiLogger } from '../../config/logger'
 import type { RecordIdRef } from '../../db/record-id'
 import { recordIdToString } from '../../db/record-id'
 import { TABLES } from '../../db/tables'
 import type { DatabaseError, ServiceError } from '../../effect/errors'
-import { ThreadTurnError } from '../../effect/errors'
-import { makeEffectTryPromiseWithMessage } from '../../effect/helpers'
+import { ERROR_TAGS, ThreadTurnError } from '../../effect/errors'
 import {
   AgentConfigServiceTag,
   AgentFactoryServiceTag,
@@ -35,7 +36,7 @@ import {
 } from '../../runtime/agent-identity-overrides'
 import { createServerRunAbortController } from '../../runtime/agent-stream-helpers'
 import { hasApprovalRespondedParts } from '../../runtime/approval-continuation'
-import { hasMessageContent } from '../../runtime/chat-message'
+import { hasMessageContent, sanitizePersistedMessages } from '../../runtime/chat-message'
 import { CompactionCoordinationTag } from '../../runtime/chat-run-orchestration'
 import { CONTEXT_WINDOW_TOKENS } from '../../runtime/context-compaction/context-compaction-constants'
 import { createWiredContextCompactionRuntime } from '../../runtime/context-compaction/context-compaction-runtime'
@@ -58,6 +59,7 @@ import { nowEpochMillis } from '../../utils/date-time'
 import { getErrorMessage } from '../../utils/errors'
 import type { makeAttachmentService } from '../attachment.service'
 import { AttachmentServiceTag } from '../attachment.service'
+import { BackgroundWorkServiceTag } from '../background-work.service'
 import { ChatRunRegistryTag } from '../chat-run-registry.service'
 import type { makeExecutionPlanService } from '../execution-plan/execution-plan.service'
 import { ExecutionPlanServiceTag } from '../execution-plan/execution-plan.service'
@@ -67,6 +69,7 @@ import type { createMemoryService } from '../memory/memory.service'
 import { MemoryServiceTag } from '../memory/memory.service'
 import type { makePlanRunService } from '../plan/plan-run.service'
 import { PlanRunServiceTag } from '../plan/plan-run.service'
+import { RecentActivityServiceTag } from '../recent-activity.service'
 import type { makeThreadMessageService } from './thread-message.service'
 import { ThreadMessageServiceTag } from './thread-message.service'
 import {
@@ -84,20 +87,65 @@ import type { NormalizedThread } from './thread.types'
 
 interface ThreadTurnPreparationServiceContext {
   attachmentService: ReturnType<typeof makeAttachmentService>
+  agentConfig: ResolvedAgentConfig
+  agentFactoryConfig: Context.Service.Shape<typeof AgentFactoryServiceTag>
+  runtimeAdapters: Context.Service.Shape<typeof RuntimeAdaptersServiceTag>
+  turnHooks: Context.Service.Shape<typeof TurnHooksServiceTag>
+  backgroundWork: Context.Service.Shape<typeof BackgroundWorkServiceTag>
   chatRunRegistry: Context.Service.Shape<typeof ChatRunRegistryTag>
   compactionCoordination: Context.Service.Shape<typeof CompactionCoordinationTag>
   executionPlanService: ReturnType<typeof makeExecutionPlanService>
   learnedSkillService: ReturnType<typeof makeLearnedSkillService>
   memoryService: ReturnType<typeof createMemoryService>
   planRunService: ReturnType<typeof makePlanRunService>
+  recentActivityService: Context.Service.Shape<typeof RecentActivityServiceTag>
   threadMessageService: ReturnType<typeof makeThreadMessageService>
   threadService: ReturnType<typeof makeThreadService>
   contextCompactionRuntime: ReturnType<typeof createWiredContextCompactionRuntime>
+  queues: Context.Service.Shape<typeof LotaQueuesServiceTag>
   contextCompactionQueue: ContextCompactionQueueRuntime
   titleGenerationQueue: TitleGenerationQueueRuntime
+  aiGatewayModels: AiGatewayModels
+  runPromise: <A, E>(effect: Effect.Effect<A, E>) => Promise<A>
 }
 
 type ThreadTurnPreparationRuntimeDeps = ThreadTurnPreparationServiceContext
+type ThreadTurnPreparationSurfaceError = DatabaseError | ThreadTurnError | ThreadTurnPreparationError
+type ThreadTurnPreparationTaggedError =
+  | ThreadTurnPreparationSurfaceError
+  | ServiceError
+  | { readonly _tag: string; readonly message?: string; readonly cause?: unknown }
+
+type ThreadTurnRunEffect = Effect.Effect<PreparedThreadTurnResult, ThreadTurnPreparationSurfaceError, never>
+
+type ExecuteThreadTurnRunEffect = Effect.Effect<
+  PreparedThreadTurnResult | void,
+  ThreadTurnPreparationSurfaceError,
+  never
+>
+
+function isThreadTurnPreparationSurfaceError(
+  error: ThreadTurnPreparationTaggedError,
+): error is ThreadTurnPreparationSurfaceError {
+  return (
+    error._tag === ERROR_TAGS.DatabaseError ||
+    error._tag === ERROR_TAGS.ThreadTurnError ||
+    error._tag === ERROR_TAGS.ThreadTurnPreparationError
+  )
+}
+
+function normalizeThreadTurnPreparationError(
+  error: ThreadTurnPreparationTaggedError,
+): ThreadTurnPreparationSurfaceError {
+  if (isThreadTurnPreparationSurfaceError(error)) {
+    return error
+  }
+
+  return new ThreadTurnPreparationError({
+    message: getErrorMessage(error),
+    cause: 'cause' in error ? error.cause : error,
+  })
+}
 
 const PRESEEDED_MEMORY_LOOKUP_LIMIT = 3
 
@@ -111,13 +159,13 @@ function waitForThreadCompactionIfNeeded(deps: ThreadTurnPreparationRuntimeDeps,
 }
 
 export class ThreadTurnPreparationError extends Schema.TaggedErrorClass<ThreadTurnPreparationError>()(
-  'ThreadTurnPreparationError',
+  '@lota-sdk/core/ThreadTurnPreparationError',
   { message: Schema.String, cause: Schema.optional(Schema.Defect) },
 ) {}
 
-const effectTryPromise = makeEffectTryPromiseWithMessage(
-  (message, cause) => new ThreadTurnPreparationError({ message, cause }),
-)
+function toThreadTurnPreparationError(message: string, cause: unknown): ThreadTurnPreparationError {
+  return new ThreadTurnPreparationError({ message, cause })
+}
 
 export interface ThreadTurnParams {
   thread: NormalizedThread
@@ -201,16 +249,21 @@ function validateAndHydrateThreadMessagesEffect(params: {
   errorMessage: string
 }): Effect.Effect<ChatMessage[], ThreadTurnPreparationError> {
   const { attachmentService, orgRef, userRef, messages, errorMessage } = params
+  const sanitizedMessages = sanitizePersistedMessages(messages)
 
-  return effectTryPromise(
-    () =>
+  if (sanitizedMessages.length === 0) {
+    return Effect.succeed([])
+  }
+
+  return Effect.tryPromise({
+    try: () =>
       validateUIMessages<ChatMessage>({
-        messages,
+        messages: sanitizedMessages,
         metadataSchema: messageMetadataSchema,
         dataSchemas: dataPartsSchemas,
       }),
-    errorMessage,
-  ).pipe(
+    catch: (cause) => toThreadTurnPreparationError(errorMessage, cause),
+  }).pipe(
     Effect.map((validated) =>
       validated.map((message) => hydrateThreadMessageFileUrls(attachmentService, orgRef, userRef, message)),
     ),
@@ -367,10 +420,10 @@ const prepareThreadRunCoreEffect = Effect.fn('ThreadTurnPreparation.prepareThrea
   deps: ThreadTurnPreparationRuntimeDeps,
   params: ThreadRunCoreParams,
 ) {
-  const runtimeAdapters = yield* RuntimeAdaptersServiceTag
-  const turnHooks = yield* TurnHooksServiceTag
-  const agentConfig = yield* AgentConfigServiceTag
-  const agentFactoryConfig = yield* AgentFactoryServiceTag
+  const runtimeAdapters = deps.runtimeAdapters
+  const turnHooks = deps.turnHooks
+  const agentConfig = deps.agentConfig
+  const agentFactoryConfig = deps.agentFactoryConfig
   const workspaceProvider = runtimeAdapters.workspaceProvider
   const workspacePromise =
     params.kind !== 'approvalContinuation' && workspaceProvider
@@ -381,6 +434,7 @@ const prepareThreadRunCoreEffect = Effect.fn('ThreadTurnPreparation.prepareThrea
   const learnedSkillService = deps.learnedSkillService
   const memoryService = deps.memoryService
   const planRunService = deps.planRunService
+  const recentActivityService = deps.recentActivityService
   const threadMessageService = deps.threadMessageService
   const threadService = deps.threadService
   const contextCompactionRuntime = deps.contextCompactionRuntime
@@ -509,25 +563,24 @@ const prepareThreadRunCoreEffect = Effect.fn('ThreadTurnPreparation.prepareThrea
     params.agentIdOverride ??
     (thread.type === 'default' ? thread.agentId : (coreThreadProfile?.config.agentId ?? defaultLeadAgentId))
   const coreInstructionSections = coreThreadProfile ? [coreThreadProfile.instructions] : undefined
-  const assembledContext = yield* effectTryPromise(
-    () =>
-      assembleThreadTurnContext({
-        thread,
-        threadRef,
-        orgRef,
-        userRef,
-        userName,
-        orgIdString,
-        userIdString,
-        messageText,
-        workspacePromise,
-        workspaceProvider,
-        turnHooks,
-        runtimeAdapters,
-        pluginRuntime: agentFactoryConfig.pluginRuntime,
-      }),
-    'Failed to assemble thread turn context.',
-  ).pipe(Effect.withSpan('ThreadTurnPreparation.assembleThreadTurnContext'))
+  const assembledContext = yield* assembleThreadTurnContext({
+    thread,
+    threadRef,
+    orgRef,
+    userRef,
+    userName,
+    orgIdString,
+    userIdString,
+    messageText,
+    workspacePromise,
+    workspaceProvider,
+    turnHooks,
+    runtimeAdapters,
+    pluginRuntime: agentFactoryConfig.pluginRuntime,
+  }).pipe(
+    Effect.mapError((cause) => toThreadTurnPreparationError('Failed to assemble thread turn context.', cause)),
+    Effect.withSpan('ThreadTurnPreparation.assembleThreadTurnContext'),
+  )
   const {
     workspace,
     onboardingActive,
@@ -548,6 +601,7 @@ const prepareThreadRunCoreEffect = Effect.fn('ThreadTurnPreparation.prepareThrea
         const runs = yield* planRunService.getActiveRunRecords(threadRef)
         return yield* Effect.forEach(runs, (run) => planRunService.toSerializablePlan(run, { slim: true }))
       }).pipe(Effect.mapError(toExecutionPlanCacheError)),
+    runPromise: deps.runPromise,
   })
   const getExecutionPlanInstructionSections = (): Effect.Effect<string[] | undefined, ThreadTurnStreamingError> =>
     executionPlanInstructionSectionCache
@@ -682,11 +736,7 @@ const prepareThreadRunCoreEffect = Effect.fn('ThreadTurnPreparation.prepareThrea
     serverRunId: string
     runAbort: ReturnType<typeof createServerRunAbortController>
     writer?: UIMessageStreamWriter<ChatMessage>
-  }): Effect.Effect<
-    PreparedThreadTurnResult | void,
-    DatabaseError | ThreadTurnError | ThreadTurnPreparationError,
-    unknown
-  > =>
+  }): ExecuteThreadTurnRunEffect =>
     Effect.ensuring(
       Effect.gen(function* () {
         const currentRunAbort = runParams.runAbort
@@ -761,20 +811,21 @@ const prepareThreadRunCoreEffect = Effect.fn('ThreadTurnPreparation.prepareThrea
               }),
           })
 
-          yield* effectTryPromise(
-            () =>
-              runVisibleAgent({
-                agentId: planTurn.nodeSpec.owner.ref,
-                mode: thread.type === 'default' ? 'direct' : 'threadMode',
-                additionalInstructionSections: buildPlanTurnInstructionSections(planTurn),
-                extraMessages: [buildPlanTurnPromptMessage(planTurn)],
-                includeExecutionPlanTools: false,
-                extraTools: { [SUBMIT_PLAN_TURN_RESULT_TOOL_NAME]: submitPlanTurnNodeResultTool },
-                filterTools: (tools) => applyPlanTurnToolPolicy(tools, planTurn.nodeSpec),
-                metadataPatch: { trigger: 'plan-turn', planRunId: planTurn.runId, planNodeId: planTurn.nodeId },
-              }),
-            'Failed to execute plan-turn visible agent.',
-          ).pipe(Effect.withSpan('ThreadTurnPreparation.executePlanTurn'))
+          yield* runVisibleAgent({
+            agentId: planTurn.nodeSpec.owner.ref,
+            mode: thread.type === 'default' ? 'direct' : 'threadMode',
+            additionalInstructionSections: buildPlanTurnInstructionSections(planTurn),
+            extraMessages: [buildPlanTurnPromptMessage(planTurn)],
+            includeExecutionPlanTools: false,
+            extraTools: { [SUBMIT_PLAN_TURN_RESULT_TOOL_NAME]: submitPlanTurnNodeResultTool },
+            filterTools: (tools) => applyPlanTurnToolPolicy(tools, planTurn.nodeSpec),
+            metadataPatch: { trigger: 'plan-turn', planRunId: planTurn.runId, planNodeId: planTurn.nodeId },
+          }).pipe(
+            Effect.mapError((cause) =>
+              toThreadTurnPreparationError('Failed to execute plan-turn visible agent.', cause),
+            ),
+            Effect.withSpan('ThreadTurnPreparation.executePlanTurn'),
+          )
         } else if (thread.type === 'default') {
           if (!thread.agentId) {
             return yield* new ThreadTurnError({
@@ -783,10 +834,10 @@ const prepareThreadRunCoreEffect = Effect.fn('ThreadTurnPreparation.prepareThrea
             })
           }
           const directAgentId = thread.agentId
-          yield* effectTryPromise(
-            () => runVisibleAgent({ agentId: directAgentId, mode: 'direct' }),
-            'Failed to execute direct thread agent.',
-          ).pipe(Effect.withSpan('ThreadTurnPreparation.executeDirectThread'))
+          yield* runVisibleAgent({ agentId: directAgentId, mode: 'direct' }).pipe(
+            Effect.mapError((cause) => toThreadTurnPreparationError('Failed to execute direct thread agent.', cause)),
+            Effect.withSpan('ThreadTurnPreparation.executeDirectThread'),
+          )
         } else {
           const wsMembers = (thread as { members?: string[] }).members ?? []
           const members = wsMembers.length > 0 ? wsMembers : [...agentConfig.roster]
@@ -799,10 +850,11 @@ const prepareThreadRunCoreEffect = Effect.fn('ThreadTurnPreparation.prepareThrea
             .map((m) => `${m.role}: ${extractMessageText(m).slice(0, 200)}`)
             .join('\n')
 
-          const triageResult = yield* effectTryPromise(
-            () =>
+          const triageResult = yield* Effect.tryPromise({
+            try: () =>
               triageThreadMessage({
                 agentConfig,
+                aiGatewayModels: deps.aiGatewayModels,
                 threadTitle: thread.title,
                 members,
                 messageText,
@@ -811,8 +863,8 @@ const prepareThreadRunCoreEffect = Effect.fn('ThreadTurnPreparation.prepareThrea
                 shortDisplayNamesById: agentIdentityOverrides.shortDisplayNamesById,
                 routingAliasesByAgentId: agentIdentityOverrides.routingAliasesByAgentId,
               }),
-            'Failed to triage group thread message.',
-          ).pipe(Effect.withSpan('ThreadTurnPreparation.routeGroupThread'))
+            catch: (cause) => toThreadTurnPreparationError('Failed to triage group thread message.', cause),
+          }).pipe(Effect.withSpan('ThreadTurnPreparation.routeGroupThread'))
           yield* failIfRunAborted()
 
           const runGroupAgent = (agentId: string, options?: { routingContext?: string }) => {
@@ -833,27 +885,32 @@ const prepareThreadRunCoreEffect = Effect.fn('ThreadTurnPreparation.prepareThrea
           }
 
           if (!triageResult) {
-            yield* effectTryPromise(
-              () => runGroupAgent(fallbackAgentId),
-              'Failed to execute fallback group agent.',
-            ).pipe(Effect.withSpan('ThreadTurnPreparation.executeFallbackGroupAgent'))
+            yield* runGroupAgent(fallbackAgentId).pipe(
+              Effect.mapError((cause) =>
+                toThreadTurnPreparationError('Failed to execute fallback group agent.', cause),
+              ),
+              Effect.withSpan('ThreadTurnPreparation.executeFallbackGroupAgent'),
+            )
             yield* failIfRunAborted()
             writeMultiAgentEvent(runParams.writer, { phase: 'complete' })
           } else {
             const respondedAgents: string[] = []
-            let lastResponse = yield* effectTryPromise(
-              () => runGroupAgent(triageResult.agentId, { routingContext: triageResult.routingContext }),
-              'Failed to execute routed group agent.',
-            ).pipe(Effect.withSpan('ThreadTurnPreparation.executeRoutedGroupAgent'))
+            let lastResponse = yield* runGroupAgent(triageResult.agentId, {
+              routingContext: triageResult.routingContext,
+            }).pipe(
+              Effect.mapError((cause) => toThreadTurnPreparationError('Failed to execute routed group agent.', cause)),
+              Effect.withSpan('ThreadTurnPreparation.executeRoutedGroupAgent'),
+            )
             respondedAgents.push(triageResult.agentId)
             yield* failIfRunAborted()
 
             while (respondedAgents.length < 3) {
               const lastResponseText = extractMessageText(lastResponse).slice(0, 500)
-              const checkResult = yield* effectTryPromise(
-                () =>
+              const checkResult = yield* Effect.tryPromise({
+                try: () =>
                   checkForNextAgent({
                     agentConfig,
+                    aiGatewayModels: deps.aiGatewayModels,
                     threadTitle: thread.title,
                     members,
                     messageText,
@@ -863,8 +920,8 @@ const prepareThreadRunCoreEffect = Effect.fn('ThreadTurnPreparation.prepareThrea
                     shortDisplayNamesById: agentIdentityOverrides.shortDisplayNamesById,
                     routingAliasesByAgentId: agentIdentityOverrides.routingAliasesByAgentId,
                   }),
-                'Failed to select the next group agent.',
-              ).pipe(Effect.withSpan('ThreadTurnPreparation.selectNextGroupAgent'))
+                catch: (cause) => toThreadTurnPreparationError('Failed to select the next group agent.', cause),
+              }).pipe(Effect.withSpan('ThreadTurnPreparation.selectNextGroupAgent'))
               yield* failIfRunAborted()
 
               if (checkResult.done || !checkResult.agentId) break
@@ -894,10 +951,14 @@ const prepareThreadRunCoreEffect = Effect.fn('ThreadTurnPreparation.prepareThrea
               threadTurnMessageContext.appendMessages([bridgeMessage])
               yield* failIfRunAborted()
 
-              lastResponse = yield* effectTryPromise(
-                () => runGroupAgent(checkResult.agentId, { routingContext: checkResult.routingContext ?? undefined }),
-                'Failed to execute follow-up group agent.',
-              ).pipe(Effect.withSpan('ThreadTurnPreparation.executeFollowUpGroupAgent'))
+              lastResponse = yield* runGroupAgent(checkResult.agentId, {
+                routingContext: checkResult.routingContext ?? undefined,
+              }).pipe(
+                Effect.mapError((cause) =>
+                  toThreadTurnPreparationError('Failed to execute follow-up group agent.', cause),
+                ),
+                Effect.withSpan('ThreadTurnPreparation.executeFollowUpGroupAgent'),
+              )
               respondedAgents.push(checkResult.agentId)
               yield* failIfRunAborted()
               writeMultiAgentEvent(runParams.writer, {
@@ -932,10 +993,14 @@ const prepareThreadRunCoreEffect = Effect.fn('ThreadTurnPreparation.prepareThrea
               contextSize: CONTEXT_WINDOW_TOKENS,
             }),
           enqueueCompaction: () =>
-            deps.contextCompactionQueue.enqueueContextCompaction({
-              domain: 'thread',
-              entityId: threadIdString,
-              contextSize: CONTEXT_WINDOW_TOKENS,
+            Effect.tryPromise({
+              try: () =>
+                deps.contextCompactionQueue.enqueueContextCompaction({
+                  domain: 'thread',
+                  entityId: threadIdString,
+                  contextSize: CONTEXT_WINDOW_TOKENS,
+                }),
+              catch: (cause) => new TurnLifecycleError({ message: getErrorMessage(cause), cause }),
             }),
           unregisterRun: () => undefined,
           clearActiveRunId: (runId) =>
@@ -965,32 +1030,36 @@ const prepareThreadRunCoreEffect = Effect.fn('ThreadTurnPreparation.prepareThrea
         )
 
         if (allAssistantMessages.length > 0 && shouldProcessPostRunSideEffects) {
-          yield* effectTryPromise(
-            () =>
-              runPostTurnSideEffects({
-                thread,
-                threadRef,
-                orgRef,
-                userRef,
-                userName,
-                orgIdString,
-                threadIdString,
-                onboardingActive,
-                workspace,
-                allAssistantMessages,
-                referenceUserMessage,
-                referenceUserMessageId: referenceUserMessage?.id ?? '',
-                loadRecentHistory,
-                listReadableUploads: () => threadTurnMessageContext.listReadableUploads(),
-                memoryBlock,
-                visibleThreadAgentId,
-                defaultLeadAgentId,
-                latestThreadRecord,
-                isUserTurn: params.kind === 'userTurn',
-                agentDisplayNamesById: agentIdentityOverrides.displayNamesById,
-              }),
-            'Failed to run post-turn side effects.',
-          ).pipe(Effect.withSpan('ThreadTurnPreparation.runPostTurnSideEffects'))
+          yield* runPostTurnSideEffects({
+            thread,
+            threadRef,
+            orgRef,
+            userRef,
+            userName,
+            orgIdString,
+            threadIdString,
+            onboardingActive,
+            workspace,
+            allAssistantMessages,
+            referenceUserMessage,
+            referenceUserMessageId: referenceUserMessage?.id ?? '',
+            loadRecentHistory,
+            listReadableUploads: () => threadTurnMessageContext.listReadableUploads(),
+            memoryBlock,
+            visibleThreadAgentId,
+            defaultLeadAgentId,
+            latestThreadRecord,
+            isUserTurn: params.kind === 'userTurn',
+            agentDisplayNamesById: agentIdentityOverrides.displayNamesById,
+          }).pipe(
+            Effect.provideService(RecentActivityServiceTag, recentActivityService),
+            Effect.provideService(ThreadServiceTag, threadService),
+            Effect.provideService(AgentConfigServiceTag, agentConfig),
+            Effect.provideService(RuntimeAdaptersServiceTag, runtimeAdapters),
+            Effect.provideService(LotaQueuesServiceTag, deps.queues),
+            Effect.mapError((cause) => toThreadTurnPreparationError('Failed to run post-turn side effects.', cause)),
+            Effect.withSpan('ThreadTurnPreparation.runPostTurnSideEffects'),
+          )
         }
 
         yield* Effect.sync(() => {
@@ -1004,8 +1073,11 @@ const prepareThreadRunCoreEffect = Effect.fn('ThreadTurnPreparation.prepareThrea
         ),
       ),
     ).pipe(
+      Effect.provideService(BackgroundWorkServiceTag, deps.backgroundWork),
+      Effect.provideService(AgentFactoryServiceTag, agentFactoryConfig),
+      Effect.provideService(AgentConfigServiceTag, agentConfig),
       Effect.mapError((error) =>
-        error._tag === 'ServiceError'
+        error._tag === ERROR_TAGS.ServiceError
           ? new ThreadTurnPreparationError({ message: error.message, cause: error.cause })
           : error,
       ),
@@ -1030,8 +1102,8 @@ const prepareThreadRunCoreEffect = Effect.fn('ThreadTurnPreparation.prepareThrea
     // streamed turn closes after persistence/finalization instead of waiting on
     // onboarding/map side effects in the request path.
     void runPromiseWithCurrentContext(
-      effectTryPromise(
-        () =>
+      Effect.tryPromise({
+        try: () =>
           afterTurn({
             thread,
             threadRef,
@@ -1044,8 +1116,8 @@ const prepareThreadRunCoreEffect = Effect.fn('ThreadTurnPreparation.prepareThrea
             latestThreadRecord,
             context: buildContextResult,
           }),
-        'Failed to run afterTurn hook.',
-      ).pipe(
+        catch: (cause) => toThreadTurnPreparationError('Failed to run afterTurn hook.', cause),
+      }).pipe(
         Effect.withSpan('ThreadTurnPreparation.afterTurnHook'),
         Effect.catch((error) =>
           Effect.sync(() => {
@@ -1061,7 +1133,7 @@ const prepareThreadRunCoreEffect = Effect.fn('ThreadTurnPreparation.prepareThrea
   const run = (writer?: UIMessageStreamWriter<ChatMessage>) => {
     const serverRunId = Bun.randomUUIDv7()
 
-    const runEffect =
+    const runEffect: ThreadTurnRunEffect =
       params.kind === 'planTurn'
         ? Effect.gen(function* () {
             const runAbort = createServerRunAbortController(
@@ -1071,25 +1143,30 @@ const prepareThreadRunCoreEffect = Effect.fn('ThreadTurnPreparation.prepareThrea
             const runResult = yield* executeRun({ serverRunId, runAbort, writer })
             return runResult ?? toPreparedThreadTurnResult()
           })
-        : threadService.withActiveRunLease(threadRef, (leaseAbortSignal) =>
-            Effect.gen(function* () {
-              const runAbort = createServerRunAbortController(
-                [params.abortSignal, leaseAbortSignal].filter((signal): signal is AbortSignal => Boolean(signal)),
-              )
-              yield* Effect.annotateCurrentSpan('serverRunId', serverRunId)
-              const runResult = yield* chatRunRegistry.trackRunEffect(
-                serverRunId,
-                runAbort.controller,
-                executeRun({ serverRunId, runAbort, writer }),
-              )
-              return runResult ?? toPreparedThreadTurnResult()
-            }),
-          )
+        : threadService
+            .withActiveRunLease(threadRef, (leaseAbortSignal) =>
+              Effect.gen(function* () {
+                const runAbort = createServerRunAbortController(
+                  [params.abortSignal, leaseAbortSignal].filter((signal): signal is AbortSignal => Boolean(signal)),
+                )
+                yield* Effect.annotateCurrentSpan('serverRunId', serverRunId)
+                const runResult = yield* chatRunRegistry.trackRunEffect(
+                  serverRunId,
+                  runAbort.controller,
+                  executeRun({ serverRunId, runAbort, writer }),
+                )
+                return runResult ?? toPreparedThreadTurnResult()
+              }),
+            )
+            .pipe(
+              Effect.mapError((error) =>
+                error._tag === ERROR_TAGS.ActiveThreadRunConflictError
+                  ? new ThreadTurnError({ message: error.message, reason: 'conflict' })
+                  : new ThreadTurnPreparationError({ message: 'Failed to acquire thread run lease.', cause: error }),
+              ),
+            )
 
-    return runEffect.pipe(
-      Effect.withSpan('ThreadTurnPreparation.executeRun'),
-      Effect.provide(currentContext),
-    ) as Effect.Effect<PreparedThreadTurnResult, DatabaseError | ThreadTurnError | ThreadTurnPreparationError, never>
+    return runEffect.pipe(Effect.withSpan('ThreadTurnPreparation.executeRun'), Effect.provide(currentContext))
   }
 
   return { originalMessages, run }
@@ -1097,38 +1174,62 @@ const prepareThreadRunCoreEffect = Effect.fn('ThreadTurnPreparation.prepareThrea
 
 interface ThreadTurnPreparationDeps {
   attachment: ReturnType<typeof makeAttachmentService>
+  agentConfig: ResolvedAgentConfig
+  agentFactoryConfig: Context.Service.Shape<typeof AgentFactoryServiceTag>
+  runtimeAdapters: Context.Service.Shape<typeof RuntimeAdaptersServiceTag>
+  turnHooks: Context.Service.Shape<typeof TurnHooksServiceTag>
+  backgroundWork: Context.Service.Shape<typeof BackgroundWorkServiceTag>
   chatRunRegistry: Context.Service.Shape<typeof ChatRunRegistryTag>
   compactionCoordination: Context.Service.Shape<typeof CompactionCoordinationTag>
   executionPlan: ReturnType<typeof makeExecutionPlanService>
   learnedSkill: ReturnType<typeof makeLearnedSkillService>
   memory: ReturnType<typeof createMemoryService>
   planRun: ReturnType<typeof makePlanRunService>
+  recentActivity: Context.Service.Shape<typeof RecentActivityServiceTag>
   threadMessage: ReturnType<typeof makeThreadMessageService>
   thread: ReturnType<typeof makeThreadService>
+  queues: Context.Service.Shape<typeof LotaQueuesServiceTag>
   helperModelRuntime: HelperModelRuntime
+  aiGatewayModels: AiGatewayModels
   contextCompactionQueue: ContextCompactionQueueRuntime
   titleGenerationQueue: TitleGenerationQueueRuntime
+  runPromise: <A, E>(effect: Effect.Effect<A, E>) => Promise<A>
+  provideCurrentContext: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, never>
 }
 
 export function makeThreadTurnPreparationService(deps: ThreadTurnPreparationDeps) {
   const runtimeDeps: ThreadTurnPreparationRuntimeDeps = {
     attachmentService: deps.attachment,
+    agentConfig: deps.agentConfig,
+    agentFactoryConfig: deps.agentFactoryConfig,
+    runtimeAdapters: deps.runtimeAdapters,
+    turnHooks: deps.turnHooks,
+    backgroundWork: deps.backgroundWork,
     chatRunRegistry: deps.chatRunRegistry,
     compactionCoordination: deps.compactionCoordination,
     executionPlanService: deps.executionPlan,
     learnedSkillService: deps.learnedSkill,
     memoryService: deps.memory,
     planRunService: deps.planRun,
+    recentActivityService: deps.recentActivity,
     threadMessageService: deps.threadMessage,
     threadService: deps.thread,
     contextCompactionRuntime: createWiredContextCompactionRuntime({
       helperModelRuntime: deps.helperModelRuntime,
+      aiGatewayModels: deps.aiGatewayModels,
       now: nowEpochMillis,
       randomId: () => Bun.randomUUIDv7(),
     }),
+    queues: deps.queues,
     contextCompactionQueue: deps.contextCompactionQueue,
     titleGenerationQueue: deps.titleGenerationQueue,
+    aiGatewayModels: deps.aiGatewayModels,
+    runPromise: deps.runPromise,
   }
+  const closeContext = <A, E extends ThreadTurnPreparationTaggedError, R>(
+    effect: Effect.Effect<A, E, R>,
+  ): Effect.Effect<A, ThreadTurnPreparationSurfaceError, never> =>
+    deps.provideCurrentContext(effect).pipe(Effect.mapError(normalizeThreadTurnPreparationError))
   const annotateTurnSpans = <A, E, R>(params: ThreadRunCoreParams, effect: Effect.Effect<A, E, R>) =>
     effect.pipe(
       Effect.annotateSpans(
@@ -1151,10 +1252,10 @@ export function makeThreadTurnPreparationService(deps: ThreadTurnPreparationDeps
 
   return {
     prepareThreadRunCoreEffect(params: ThreadRunCoreParams) {
-      return annotateTurnSpans(params, prepareThreadRunCoreEffect(runtimeDeps, params))
+      return closeContext(annotateTurnSpans(params, prepareThreadRunCoreEffect(runtimeDeps, params)))
     },
     prepareThreadRunCore(params: ThreadRunCoreParams) {
-      return annotateTurnSpans(params, prepareThreadRunCoreEffect(runtimeDeps, params))
+      return closeContext(annotateTurnSpans(params, prepareThreadRunCoreEffect(runtimeDeps, params)))
     },
   } as const
 }
@@ -1167,29 +1268,50 @@ export class ThreadTurnPreparationServiceTag extends Context.Service<
 export const ThreadTurnPreparationServiceLive = Layer.effect(
   ThreadTurnPreparationServiceTag,
   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 attachment = yield* AttachmentServiceTag
+    const agentConfig = yield* AgentConfigServiceTag
+    const agentFactoryConfig = yield* AgentFactoryServiceTag
+    const runtimeAdapters = yield* RuntimeAdaptersServiceTag
+    const turnHooks = yield* TurnHooksServiceTag
+    const backgroundWork = yield* BackgroundWorkServiceTag
     const chatRunRegistry = yield* ChatRunRegistryTag
     const compactionCoordination = yield* CompactionCoordinationTag
     const executionPlan = yield* ExecutionPlanServiceTag
     const learnedSkill = yield* LearnedSkillServiceTag
     const memory = yield* MemoryServiceTag
     const planRun = yield* PlanRunServiceTag
+    const recentActivity = yield* RecentActivityServiceTag
     const threadMessage = yield* ThreadMessageServiceTag
     const thread = yield* ThreadServiceTag
     const queues = yield* LotaQueuesServiceTag
+    const aiGatewayModels = yield* AiGatewayModelsTag
+    const bridge = yield* RuntimeBridgeTag
     return makeThreadTurnPreparationService({
       attachment,
+      agentConfig,
+      agentFactoryConfig,
+      runtimeAdapters,
+      turnHooks,
+      backgroundWork,
       chatRunRegistry,
       compactionCoordination,
       executionPlan,
       learnedSkill,
       memory,
       planRun,
+      recentActivity,
       threadMessage,
       thread,
+      queues,
       helperModelRuntime: yield* HelperModelTag,
+      aiGatewayModels,
       contextCompactionQueue: queues.contextCompaction,
       titleGenerationQueue: queues.titleGeneration,
+      runPromise: bridge.runPromise,
+      provideCurrentContext,
     })
   }),
 )