@lota-sdk/core 0.4.8 → 0.4.9

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

@@ -0,0 +1,343 @@
+import type { ChatMessage } from '@lota-sdk/shared'
+import { createUIMessageStream } from 'ai'
+import { Context, Schema, Effect, Layer } from 'effect'
+
+import { ensureRecordId, recordIdToString } from '../../db/record-id'
+import { TABLES } from '../../db/tables'
+import { BadRequestError } from '../../effect/errors'
+import { runPromise } from '../../effect/runtime'
+import { getCurrentRuntime } from '../../effect/runtime-ref'
+import { hasApprovalRespondedParts, isApprovalContinuationRequest } from '../../runtime/approval-continuation'
+import { shouldPlanNodeUseVisibleTurn } from '../../runtime/execution-plan-visibility'
+import { wrapResponseWithKeepalive } from '../../utils/sse-keepalive'
+import type { makePlanExecutorService } from '../plan/plan-executor.service'
+import { PlanExecutorServiceTag } from '../plan/plan-executor.service'
+import type { makePlanRunService } from '../plan/plan-run.service'
+import { PlanRunServiceTag } from '../plan/plan-run.service'
+import type { makeUserService } from '../user.service'
+import { UserServiceTag } from '../user.service'
+import type {
+  PreparedThreadTurnResult,
+  ThreadApprovalContinuationParams,
+  ThreadPlanTurnParams,
+  ThreadTurnParams,
+  makeThreadTurnPreparationService,
+} from './thread-turn-preparation.service'
+import { ThreadTurnPreparationServiceTag } from './thread-turn-preparation.service'
+import { buildThreadTurnSpanAttributes, compactSpanAttributes } from './thread-turn-tracing'
+import type { makeThreadService } from './thread.service'
+import { ThreadServiceTag } from './thread.service'
+
+export { hasApprovalRespondedParts, isApprovalContinuationRequest }
+export { wrapResponseWithKeepalive }
+export type { PreparedThreadTurnResult }
+export type { ThreadPlanTurnParams }
+
+class ThreadTurnServiceError extends Schema.TaggedErrorClass<ThreadTurnServiceError>()('ThreadTurnServiceError', {
+  message: Schema.String,
+  cause: Schema.optional(Schema.Defect),
+}) {}
+
+interface ThreadTurnDeps {
+  planExecutor: ReturnType<typeof makePlanExecutorService>
+  planRun: ReturnType<typeof makePlanRunService>
+  thread: ReturnType<typeof makeThreadService>
+  threadTurnPreparation: ReturnType<typeof makeThreadTurnPreparationService>
+  user: ReturnType<typeof makeUserService>
+}
+
+const createThreadApprovalContinuationStreamEffect = Effect.fn('ThreadTurn.createApprovalContinuationStream')(
+  function* (deps: ThreadTurnDeps, params: ThreadApprovalContinuationParams) {
+    const currentContext = yield* Effect.context()
+    const runPromiseWithCurrentContext = Effect.runPromiseWith(currentContext)
+    const prepared = yield* deps.threadTurnPreparation.prepareThreadRunCoreEffect({
+      ...params,
+      kind: 'approvalContinuation',
+    })
+    return createUIMessageStream<ChatMessage>({
+      originalMessages: prepared.originalMessages,
+      onError: (error) => (error instanceof Error ? error.message : 'Approval continuation stream failed.'),
+      execute: ({ writer }) =>
+        runPromiseWithCurrentContext(
+          prepared.run(writer).pipe(Effect.withSpan('ThreadTurn.executeApprovalContinuationStream'), Effect.asVoid),
+        ),
+    })
+  },
+)
+
+function createThreadApprovalContinuationStreamWith(deps: ThreadTurnDeps, params: ThreadApprovalContinuationParams) {
+  return createThreadApprovalContinuationStreamEffect(deps, params).pipe(
+    Effect.annotateSpans(
+      buildThreadTurnSpanAttributes({
+        threadRef: params.threadRef,
+        orgRef: params.orgRef,
+        userRef: params.userRef,
+        kind: 'approvalContinuation',
+        streamId: params.streamId,
+        threadType: params.thread.type,
+      }),
+    ),
+  )
+}
+
+const createThreadNativeToolApprovalStreamEffect = Effect.fn('ThreadTurn.createNativeToolApprovalStream')(function* (
+  deps: ThreadTurnDeps,
+  params: ThreadApprovalContinuationParams,
+) {
+  const currentContext = yield* Effect.context()
+  const runPromiseWithCurrentContext = Effect.runPromiseWith(currentContext)
+  const prepared = yield* deps.threadTurnPreparation.prepareThreadRunCoreEffect({
+    ...params,
+    kind: 'nativeToolApprovalTurn',
+  })
+  return createUIMessageStream<ChatMessage>({
+    originalMessages: prepared.originalMessages,
+    onError: (error) => (error instanceof Error ? error.message : 'Native tool approval stream failed.'),
+    execute: ({ writer }) =>
+      runPromiseWithCurrentContext(
+        prepared.run(writer).pipe(Effect.withSpan('ThreadTurn.executeNativeToolApprovalStream'), Effect.asVoid),
+      ),
+  })
+})
+
+function createThreadNativeToolApprovalStreamWith(deps: ThreadTurnDeps, params: ThreadApprovalContinuationParams) {
+  return createThreadNativeToolApprovalStreamEffect(deps, params).pipe(
+    Effect.annotateSpans(
+      buildThreadTurnSpanAttributes({
+        threadRef: params.threadRef,
+        orgRef: params.orgRef,
+        userRef: params.userRef,
+        kind: 'nativeToolApprovalTurn',
+        streamId: params.streamId,
+        threadType: params.thread.type,
+      }),
+    ),
+  )
+}
+
+const createThreadTurnStreamEffect = Effect.fn('ThreadTurn.createThreadTurnStream')(function* (
+  deps: ThreadTurnDeps,
+  params: ThreadTurnParams,
+) {
+  const currentContext = yield* Effect.context()
+  const runPromiseWithCurrentContext = Effect.runPromiseWith(currentContext)
+  const prepared = yield* deps.threadTurnPreparation.prepareThreadRunCoreEffect({ ...params, kind: 'userTurn' })
+  return createUIMessageStream<ChatMessage>({
+    originalMessages: prepared.originalMessages,
+    onError: (error) => (error instanceof Error ? error.message : 'Chat stream failed.'),
+    execute: ({ writer }) =>
+      runPromiseWithCurrentContext(
+        prepared.run(writer).pipe(Effect.withSpan('ThreadTurn.executeThreadTurnStream'), Effect.asVoid),
+      ),
+  })
+})
+
+function createThreadTurnStreamWith(deps: ThreadTurnDeps, params: ThreadTurnParams) {
+  return createThreadTurnStreamEffect(deps, params).pipe(
+    Effect.annotateSpans(
+      buildThreadTurnSpanAttributes({
+        threadRef: params.threadRef,
+        orgRef: params.orgRef,
+        userRef: params.userRef,
+        kind: 'userTurn',
+        streamId: params.streamId,
+        threadType: params.thread.type,
+      }),
+    ),
+  )
+}
+
+const runThreadTurnInBackgroundEffect = Effect.fn('ThreadTurn.runThreadTurnInBackground')(function* (
+  deps: ThreadTurnDeps,
+  params: ThreadTurnParams,
+) {
+  const prepared = yield* deps.threadTurnPreparation.prepareThreadRunCoreEffect({ ...params, kind: 'userTurn' })
+  return yield* prepared.run().pipe(Effect.withSpan('ThreadTurn.executeBackgroundTurn'))
+})
+
+function runThreadTurnInBackgroundWith(deps: ThreadTurnDeps, params: ThreadTurnParams) {
+  return runThreadTurnInBackgroundEffect(deps, params).pipe(
+    Effect.annotateSpans(
+      buildThreadTurnSpanAttributes({
+        threadRef: params.threadRef,
+        orgRef: params.orgRef,
+        userRef: params.userRef,
+        kind: 'background',
+        streamId: params.streamId,
+        threadType: params.thread.type,
+        agentId: params.agentIdOverride,
+      }),
+    ),
+  )
+}
+
+const triggerPlanNodeTurnEffect = Effect.fn('ThreadTurn.triggerPlanNodeTurn')(function* (
+  deps: ThreadTurnDeps,
+  params: { runId: string; nodeId: string; abortSignal?: AbortSignal; streamId?: string },
+) {
+  const run = yield* deps.planRun.getRunById(params.runId)
+  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') {
+    return yield* new BadRequestError({
+      message: `Plan node "${params.nodeId}" is not eligible for a visible plan turn.`,
+    })
+  }
+
+  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 }),
+    })
+    activeRun = yield* deps.planRun.getRunById(params.runId)
+    nodeRun = yield* deps.planRun.getNodeRunByNodeId(run.id, params.nodeId)
+  }
+
+  if (nodeRun.status !== 'running') {
+    return { assistantMessages: [], inputMessageId: undefined }
+  }
+
+  const thread = yield* deps.thread.getThread(activeRun.threadId)
+  const userRef = ensureRecordId(thread.userId, TABLES.USER)
+  const [artifacts, nodeRuns, nodeSpecs, userName] = yield* Effect.all([
+    deps.planRun.listArtifacts(activeRun.id),
+    deps.planRun.listNodeRuns(activeRun.id),
+    deps.planRun.listNodeSpecs(spec.id),
+    deps.user.getUser(recordIdToString(userRef, TABLES.USER)).pipe(
+      Effect.map((user) => user.name),
+      Effect.catch(() => Effect.succeed(undefined as string | undefined)),
+    ),
+  ]).pipe(Effect.withSpan('ThreadTurn.loadPlanTurnContext'))
+
+  const inputArtifacts = artifacts
+    .filter((artifact) => nodeSpec.upstreamNodeIds.includes(artifact.nodeId))
+    .map((artifact) => ({
+      name: artifact.name,
+      kind: artifact.kind,
+      ...(artifact.description ? { description: artifact.description } : {}),
+      ...(artifact.content !== undefined ? { content: artifact.content } : {}),
+      ...(artifact.payload !== undefined ? { payload: artifact.payload } : {}),
+      ...(artifact.publishedArtifactId
+        ? { publishedArtifactId: recordIdToString(artifact.publishedArtifactId, TABLES.ARTIFACT) }
+        : {}),
+    }))
+  const upstreamNodeSpecs = new Map(nodeSpecs.map((upstreamNodeSpec) => [upstreamNodeSpec.nodeId, upstreamNodeSpec]))
+  const upstreamHandoffs = nodeRuns
+    .filter((candidate) => nodeSpec.upstreamNodeIds.includes(candidate.nodeId) && candidate.latestNotes)
+    .map((candidate) => ({
+      nodeId: candidate.nodeId,
+      label: upstreamNodeSpecs.get(candidate.nodeId)?.label ?? candidate.nodeId,
+      ownerRef: upstreamNodeSpecs.get(candidate.nodeId)?.owner.ref ?? 'system',
+      ownerType: upstreamNodeSpecs.get(candidate.nodeId)?.owner.executorType ?? 'system',
+      summary: candidate.latestNotes ?? undefined,
+    }))
+
+  const threadRef = ensureRecordId(activeRun.threadId, TABLES.THREAD)
+  const orgRef = ensureRecordId(activeRun.organizationId, TABLES.ORGANIZATION)
+  const prepared = yield* deps.threadTurnPreparation.prepareThreadRunCoreEffect({
+    kind: 'planTurn',
+    thread,
+    threadRef,
+    orgRef,
+    userRef,
+    userName,
+    abortSignal: params.abortSignal,
+    streamId: params.streamId,
+    planTurn: {
+      runId: params.runId,
+      nodeId: params.nodeId,
+      planTitle: spec.title,
+      nodeSpec,
+      nodeRun,
+      resolvedInput: nodeRun.resolvedInput ?? {},
+      inputArtifacts,
+      upstreamHandoffs,
+    },
+  })
+  return yield* prepared.run().pipe(Effect.withSpan('ThreadTurn.executePlanTurn'))
+})
+
+function triggerPlanNodeTurnWith(
+  deps: ThreadTurnDeps,
+  params: { runId: string; nodeId: string; abortSignal?: AbortSignal; streamId?: string },
+) {
+  return triggerPlanNodeTurnEffect(deps, params).pipe(
+    Effect.annotateSpans(
+      compactSpanAttributes({
+        turnKind: 'planTurn',
+        streamId: params.streamId,
+        planRunId: params.runId,
+        planNodeId: params.nodeId,
+      }),
+    ),
+  )
+}
+
+export function makeThreadTurnService(deps: ThreadTurnDeps) {
+  return {
+    createThreadApprovalContinuationStream(params: ThreadApprovalContinuationParams) {
+      return createThreadApprovalContinuationStreamWith(deps, params)
+    },
+    createThreadNativeToolApprovalStream(params: ThreadApprovalContinuationParams) {
+      return createThreadNativeToolApprovalStreamWith(deps, params)
+    },
+    createThreadTurnStream(params: ThreadTurnParams) {
+      return createThreadTurnStreamWith(deps, params)
+    },
+    runThreadTurnInBackground(params: ThreadTurnParams) {
+      return runThreadTurnInBackgroundWith(deps, params)
+    },
+    triggerPlanNodeTurn(params: { runId: string; nodeId: string; abortSignal?: AbortSignal; streamId?: string }) {
+      return triggerPlanNodeTurnWith(deps, params)
+    },
+  } as const
+}
+
+export class ThreadTurnServiceTag extends Context.Service<
+  ThreadTurnServiceTag,
+  ReturnType<typeof makeThreadTurnService>
+>()('ThreadTurnService') {}
+
+export const ThreadTurnServiceLive = Layer.effect(
+  ThreadTurnServiceTag,
+  Effect.gen(function* () {
+    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 })
+  }),
+)
+
+function getThreadTurnService() {
+  return getCurrentRuntime().runSync(Effect.service(ThreadTurnServiceTag))
+}
+
+export function createThreadApprovalContinuationStream(params: ThreadApprovalContinuationParams) {
+  return runPromise(getThreadTurnService().createThreadApprovalContinuationStream(params))
+}
+
+export function createThreadNativeToolApprovalStream(params: ThreadApprovalContinuationParams) {
+  return runPromise(getThreadTurnService().createThreadNativeToolApprovalStream(params))
+}
+
+export function createThreadTurnStream(params: ThreadTurnParams) {
+  return runPromise(getThreadTurnService().createThreadTurnStream(params))
+}
+
+export function runThreadTurnInBackground(params: ThreadTurnParams): Promise<PreparedThreadTurnResult> {
+  return runPromise(getThreadTurnService().runThreadTurnInBackground(params))
+}
+
+export function triggerPlanNodeTurn(params: {
+  runId: string
+  nodeId: string
+  abortSignal?: AbortSignal
+  streamId?: string
+}): Promise<PreparedThreadTurnResult> {
+  return runPromise(getThreadTurnService().triggerPlanNodeTurn(params))
+}

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

@@ -0,0 +1,335 @@
+import { THREAD, sdkThreadStatusSchema } from '@lota-sdk/shared'
+import { Context, Effect, Layer } from 'effect'
+import { surql } from 'surrealdb'
+
+import { getCoreThreadProfile, isAgentName } from '../../config/agent-defaults'
+import { ensureRecordId, isRecordIdInput, recordIdToString } from '../../db/record-id'
+import type { RecordIdRef } from '../../db/record-id'
+import type { SurrealDBService } from '../../db/service'
+import { TABLES } from '../../db/tables'
+import { BadRequestError, ServiceError } from '../../effect/errors'
+import { makeEffectTryPromiseWithMessage } from '../../effect/helpers'
+import { DatabaseServiceTag, RedisServiceTag } from '../../effect/services'
+import type { RedisConnectionManager } from '../../redis/connection'
+import { CompactionCoordinationTag } from '../../runtime/chat-run-orchestration'
+import { toIsoDateTimeString } from '../../utils/date-time'
+import { ChatRunRegistryTag } from '../chat-run-registry.service'
+import { ContextCompactionServiceTag } from '../context-compaction.service'
+import type { makeContextCompactionService } from '../context-compaction.service'
+import { createThreadActiveRunHelpers } from './thread-active-run'
+import { createThreadBootstrapHelpers } from './thread-bootstrap'
+import { createThreadListingHelpers } from './thread-listing'
+import { createThreadMemoryBlockHelpers, formatMemoryBlockForPrompt } from './thread-memory-block'
+import { ThreadMessageServiceTag } from './thread-message.service'
+import type { makeThreadMessageService } from './thread-message.service'
+import { createThreadRecordStore } from './thread-record-store'
+import { NormalizedThreadSchema, PublicThreadSchema } from './thread.types'
+import type { NormalizedThread, PublicThread, ThreadRecord } from './thread.types'
+
+export { ActiveThreadRunConflictError } from '../../effect/errors'
+
+function assertMutableThreadEffect(thread: ThreadRecord): Effect.Effect<void, BadRequestError> {
+  return thread.type === 'default'
+    ? Effect.fail(new BadRequestError({ message: 'Default threads cannot be modified.' }))
+    : Effect.void
+}
+
+function getDefaultTitle(thread: Pick<ThreadRecord, 'type' | 'threadType'>): string {
+  if (thread.type === 'thread' && typeof thread.threadType === 'string') {
+    return getCoreThreadProfile(thread.threadType).config.title
+  }
+
+  return THREAD.DEFAULT_TITLE
+}
+
+function normalizeRecordIdStringEffect(id: unknown, table: string): Effect.Effect<string, BadRequestError> {
+  return isRecordIdInput(id)
+    ? Effect.succeed(recordIdToString(ensureRecordId(id, table), table))
+    : Effect.fail(new BadRequestError({ message: `Invalid record id for table ${table}.` }))
+}
+
+function toPublicThread(thread: NormalizedThread): PublicThread {
+  const { organizationId: _organizationId, userId: _userId, memoryBlock: _memoryBlock, ...publicThread } = thread
+  return PublicThreadSchema.parse(publicThread)
+}
+
+type ThreadServiceError = ServiceError | BadRequestError
+
+const effectTryPromise = makeEffectTryPromiseWithMessage((message, cause) => new ServiceError({ message, cause }))
+
+type ChatRunRegistry = Context.Service.Shape<typeof ChatRunRegistryTag>
+
+type CompactionCoordination = Context.Service.Shape<typeof CompactionCoordinationTag>
+
+interface ThreadServiceDeps {
+  db: SurrealDBService
+  redis: RedisConnectionManager
+  chatRunRegistry: ChatRunRegistry
+  threadMessageService: ReturnType<typeof makeThreadMessageService>
+  contextCompactionService: ReturnType<typeof makeContextCompactionService>
+  compactionCoordination: CompactionCoordination
+}
+
+export function makeThreadService(deps: ThreadServiceDeps) {
+  const threadStore = createThreadRecordStore({ db: deps.db })
+  const activeRun = createThreadActiveRunHelpers({
+    db: deps.db,
+    threadStore,
+    redis: deps.redis,
+    chatRunRegistry: deps.chatRunRegistry,
+  })
+
+  function computeIsRunning(
+    thread: Pick<ThreadRecord, 'id' | 'activeRunId'>,
+    options: { checkLease: boolean },
+  ): Effect.Effect<boolean, ThreadServiceError> {
+    const activeRunId =
+      typeof thread.activeRunId === 'string' && thread.activeRunId.trim().length > 0 ? thread.activeRunId : null
+
+    if (activeRunId === null) {
+      return Effect.succeed(false)
+    }
+
+    if (deps.chatRunRegistry.has(activeRunId)) {
+      return Effect.succeed(true)
+    }
+
+    if (!options.checkLease) {
+      return Effect.succeed(true)
+    }
+
+    return effectTryPromise(
+      () => activeRun.hasActiveRunLease(ensureRecordId(thread.id, TABLES.THREAD)),
+      'Failed to check active thread run lease.',
+    )
+  }
+
+  function toNormalizedThread(
+    thread: ThreadRecord,
+    options: { checkLease?: boolean } = {},
+  ): Effect.Effect<NormalizedThread, ThreadServiceError> {
+    return Effect.gen(function* () {
+      const isRunning = yield* computeIsRunning(thread, { checkLease: options.checkLease ?? true })
+      const [id, userId, organizationId] = yield* Effect.all([
+        normalizeRecordIdStringEffect(thread.id, TABLES.THREAD),
+        normalizeRecordIdStringEffect(thread.userId, TABLES.USER),
+        normalizeRecordIdStringEffect(thread.organizationId, TABLES.ORGANIZATION),
+      ])
+      return NormalizedThreadSchema.parse({
+        id,
+        userId,
+        organizationId,
+        type: thread.type,
+        ...(thread.type === 'thread' && typeof thread.threadType === 'string' ? { threadType: thread.threadType } : {}),
+        nameGenerated: thread.nameGenerated,
+        isRunning,
+        isCompacting: thread.isCompacting === true,
+        ...(isAgentName(thread.agentId) ? { agentId: thread.agentId } : {}),
+        title: thread.title ?? getDefaultTitle(thread),
+        status: thread.status,
+        memoryBlock: formatMemoryBlockForPrompt(thread),
+        members: thread.members,
+        createdAt: toIsoDateTimeString(thread.createdAt),
+        updatedAt: toIsoDateTimeString(thread.updatedAt),
+      })
+    })
+  }
+
+  function toNormalizedThreads(
+    threads: ThreadRecord[],
+    options: { checkLease?: boolean } = {},
+  ): Effect.Effect<NormalizedThread[], ThreadServiceError> {
+    return Effect.forEach(threads, (thread) => toNormalizedThread(thread, options))
+  }
+
+  const bootstrap = createThreadBootstrapHelpers({
+    threadStore,
+    threadMessageService: deps.threadMessageService,
+    redis: deps.redis,
+    normalizeThread: toNormalizedThread,
+  })
+
+  const listing = createThreadListingHelpers({ db: deps.db, normalizeThreads: toNormalizedThreads })
+
+  const memory = createThreadMemoryBlockHelpers({
+    threadStore,
+    contextCompactionService: { compactMemoryBlock: deps.contextCompactionService.compactMemoryBlock },
+  })
+
+  function getById(threadId: RecordIdRef) {
+    return effectTryPromise(() => threadStore.getById(threadId), 'Failed to load thread.')
+  }
+
+  function getThread(threadId: RecordIdRef) {
+    return Effect.gen(function* () {
+      const thread = yield* getById(threadId)
+      return yield* toNormalizedThread(thread)
+    })
+  }
+
+  function updateTitle(threadId: RecordIdRef, title: string) {
+    return Effect.gen(function* () {
+      const existing = yield* getById(threadId)
+      yield* assertMutableThreadEffect(existing)
+      const thread = yield* effectTryPromise(
+        () => threadStore.update(threadId, { title, nameGenerated: true }),
+        'Failed to update thread title.',
+      )
+      return yield* toNormalizedThread(thread)
+    })
+  }
+
+  function updateStatus(threadId: RecordIdRef, status: string) {
+    return Effect.gen(function* () {
+      const parsedStatus = sdkThreadStatusSchema.safeParse(status)
+      if (!parsedStatus.success) {
+        return yield* new BadRequestError({ message: `Invalid thread status: ${status}` })
+      }
+      const existing = yield* getById(threadId)
+      yield* assertMutableThreadEffect(existing)
+      const thread = yield* effectTryPromise(
+        () => threadStore.update(threadId, { status: parsedStatus.data }),
+        'Failed to update thread status.',
+      )
+      return yield* toNormalizedThread(thread)
+    })
+  }
+
+  function setCompacting(threadId: RecordIdRef, value: boolean) {
+    const threadRef = ensureRecordId(threadId, TABLES.THREAD)
+    const threadIdString = recordIdToString(threadRef, TABLES.THREAD)
+    return Effect.asVoid(
+      effectTryPromise(
+        () => deps.db.query<unknown>(surql`UPDATE ONLY ${threadRef} SET isCompacting = ${value}`),
+        'Failed to update thread compaction flag.',
+      ).pipe(Effect.tap(() => deps.compactionCoordination.signal(threadIdString, value))),
+    )
+  }
+
+  function clearThread(threadId: RecordIdRef) {
+    return Effect.gen(function* () {
+      const existing = yield* getById(threadId)
+      yield* assertMutableThreadEffect(existing)
+      const threadRef = ensureRecordId(threadId, TABLES.THREAD)
+      yield* effectTryPromise(
+        () => deps.db.deleteWhere(TABLES.THREAD_MESSAGE, { threadId: threadRef }),
+        'Failed to delete thread messages.',
+      )
+      yield* effectTryPromise(
+        () =>
+          deps.db.query<unknown>(surql`
+          UPDATE ONLY ${threadRef}
+          SET turnCount = 0,
+              compactionSummary = NONE,
+              lastCompactedMessageId = NONE,
+              activeRunId = NONE,
+              activeStreamId = NONE,
+              isCompacting = false
+        `),
+        'Failed to reset thread state.',
+      )
+    })
+  }
+
+  function deleteThread(threadId: RecordIdRef) {
+    return Effect.gen(function* () {
+      const existing = yield* getById(threadId)
+      yield* assertMutableThreadEffect(existing)
+      yield* effectTryPromise(() => threadStore.deleteById(threadId), 'Failed to delete thread.')
+    })
+  }
+
+  function incrementTurnCount(threadId: RecordIdRef) {
+    const threadRef = ensureRecordId(threadId, TABLES.THREAD)
+    return Effect.gen(function* () {
+      const result = yield* effectTryPromise(
+        () =>
+          deps.db.query<{ turnCount: number }>(
+            surql`
+        UPDATE ONLY ${threadRef}
+        SET turnCount += 1
+        RETURN turnCount
+      `,
+          ),
+        'Failed to increment thread turn count.',
+      )
+      return result[0].turnCount
+    })
+  }
+
+  return {
+    findById: (...args: Parameters<typeof threadStore.findById>) =>
+      effectTryPromise(() => threadStore.findById(...args), 'Failed to find thread.'),
+    getById,
+    findAll: (...args: Parameters<typeof threadStore.findAll>) =>
+      effectTryPromise(() => threadStore.findAll(...args), 'Failed to find all threads.'),
+    create: (...args: Parameters<typeof threadStore.create>) =>
+      effectTryPromise(() => threadStore.create(...args), 'Failed to create thread.'),
+    update: (...args: Parameters<typeof threadStore.update>) =>
+      effectTryPromise(() => threadStore.update(...args), 'Failed to update thread.'),
+    delete: (...args: Parameters<typeof threadStore.deleteById>) =>
+      effectTryPromise(() => threadStore.deleteById(...args), 'Failed to delete thread.'),
+    getOrCreateDefault: (...args: Parameters<typeof bootstrap.getOrCreateDefault>) =>
+      effectTryPromise(() => bootstrap.getOrCreateDefault(...args), 'Failed to get or create default thread.'),
+    getOrCreateThread: (...args: Parameters<typeof bootstrap.getOrCreateThread>) =>
+      effectTryPromise(() => bootstrap.getOrCreateThread(...args), 'Failed to get or create thread.'),
+    createThread: (...args: Parameters<typeof bootstrap.createThread>) =>
+      effectTryPromise(() => bootstrap.createThread(...args), 'Failed to create thread.'),
+    ensureBootstrapThreads: (...args: Parameters<typeof bootstrap.ensureBootstrapThreads>) =>
+      effectTryPromise(() => bootstrap.ensureBootstrapThreads(...args), 'Failed to ensure bootstrap threads.'),
+    listThreads: (...args: Parameters<typeof listing.listThreads>) =>
+      effectTryPromise(() => listing.listThreads(...args), 'Failed to list threads.'),
+    listOrganizationThreads: (...args: Parameters<typeof listing.listOrganizationThreads>) =>
+      effectTryPromise(() => listing.listOrganizationThreads(...args), 'Failed to list organization threads.'),
+    getThread,
+    updateTitle,
+    updateStatus,
+    setActiveTurn: activeRun.setActiveTurn,
+    getActiveTurn: (...args: Parameters<typeof activeRun.getActiveTurn>) =>
+      effectTryPromise(() => activeRun.getActiveTurn(...args), 'Failed to get active turn.'),
+    getActiveRunId: activeRun.getActiveRunId,
+    hasActiveRunLease: activeRun.hasActiveRunLease,
+    withActiveRunLease: activeRun.withActiveRunLease,
+    getActiveStreamId: activeRun.getActiveStreamId,
+    clearActiveTurn: activeRun.clearActiveTurn,
+    clearStaleActiveRunIfMissingFromRegistry: activeRun.clearStaleActiveRunIfMissingFromRegistry,
+    stopActiveRun: (...args: Parameters<typeof activeRun.stopActiveRun>) =>
+      effectTryPromise(() => activeRun.stopActiveRun(...args), 'Failed to stop active run.'),
+    setCompacting,
+    appendMemoryBlock: (...args: Parameters<typeof memory.appendMemoryBlock>) =>
+      effectTryPromise(() => memory.appendMemoryBlock(...args), 'Failed to append memory block.'),
+    compactMemoryBlock: (...args: Parameters<typeof memory.compactMemoryBlock>) =>
+      effectTryPromise(() => memory.compactMemoryBlock(...args), 'Failed to compact memory block.'),
+    clearThread,
+    deleteThread,
+    listRecentThreads: (...args: Parameters<typeof listing.listRecentThreads>) =>
+      effectTryPromise(() => listing.listRecentThreads(...args), 'Failed to list recent threads.'),
+    formatMemoryBlockForPrompt,
+    toPublicThread,
+    incrementTurnCount,
+  }
+}
+
+export class ThreadServiceTag extends Context.Service<ThreadServiceTag, ReturnType<typeof makeThreadService>>()(
+  'ThreadService',
+) {}
+
+export const ThreadServiceLive = Layer.effect(
+  ThreadServiceTag,
+  Effect.gen(function* () {
+    const db = yield* DatabaseServiceTag
+    const redis = yield* RedisServiceTag
+    const chatRunRegistry = yield* ChatRunRegistryTag
+    const threadMessageService = yield* ThreadMessageServiceTag
+    const contextCompactionService = yield* ContextCompactionServiceTag
+    const compactionCoordination = yield* CompactionCoordinationTag
+    return makeThreadService({
+      db,
+      redis,
+      chatRunRegistry,
+      threadMessageService,
+      contextCompactionService,
+      compactionCoordination,
+    })
+  }),
+)