@lota-sdk/core 0.4.12 → 0.4.14

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

@@ -6,7 +6,7 @@ import { Effect, Ref, Schema, Stream } from 'effect'
 
 import { aiLogger } from '../../config/logger'
 import type { RecordIdRef } from '../../db/record-id'
-import { effectTryMaybeAsync, makeEffectTryPromiseWithMessage } from '../../effect/helpers'
+import { ERROR_TAGS } from '../../effect/errors'
 import { AgentConfigServiceTag, AgentFactoryServiceTag } from '../../effect/services'
 import {
   readRuntimeAgentIdentityOverrides,
@@ -40,28 +40,12 @@ interface ToolLoopGenerateResult {
 }
 
 export class ThreadTurnStreamingError extends Schema.TaggedErrorClass<ThreadTurnStreamingError>()(
-  'ThreadTurnStreamingError',
+  '@lota-sdk/core/ThreadTurnStreamingError',
   { message: Schema.String, cause: Schema.optional(Schema.Defect) },
 ) {}
 
-const effectTryPromise = makeEffectTryPromiseWithMessage(
-  (message, cause) => new ThreadTurnStreamingError({ message, cause }),
-)
-
-function effectFromMaybeEffect<A>(
-  evaluate: () => A | PromiseLike<A> | Effect.Effect<A, ThreadTurnStreamingError>,
-  message: string,
-): Effect.Effect<A, ThreadTurnStreamingError> {
-  return Effect.try({ try: evaluate, catch: (error) => new ThreadTurnStreamingError({ message, cause: error }) }).pipe(
-    Effect.flatMap((result) =>
-      Effect.isEffect(result)
-        ? result.pipe(Effect.mapError((error) => new ThreadTurnStreamingError({ message, cause: error })))
-        : effectTryMaybeAsync(
-            () => result,
-            (error) => new ThreadTurnStreamingError({ message, cause: error }),
-          ),
-    ),
-  )
+function toThreadTurnStreamingError(message: string, cause: unknown): ThreadTurnStreamingError {
+  return new ThreadTurnStreamingError({ message, cause })
 }
 
 function hasUIMessageStream(value: unknown): value is UIMessageStreamResult {
@@ -151,7 +135,7 @@ interface StreamAgentResponseParams {
   messages: ChatMessage[]
   tools: ToolSet
   observer: {
-    run: <T>(fn: () => T | Promise<T>) => Promise<T>
+    run: <T>(fn: () => Promise<T>) => Promise<T>
     recordError: (error: unknown) => void
     recordAbort: (error: unknown) => void
   }
@@ -172,45 +156,54 @@ const streamAgentResponseEffect = Effect.fn('ThreadTurnStreaming.streamAgentResp
   const executionPlanInstructionSections =
     streamParams.includeExecutionPlanTools === false
       ? undefined
-      : yield* effectFromMaybeEffect(
-          () => ctx.getExecutionPlanInstructionSections(),
-          'Failed to load execution plan instructions.',
-        ).pipe(Effect.withSpan('ThreadTurnStreaming.loadExecutionPlanInstructions'))
+      : yield* ctx.getExecutionPlanInstructionSections().pipe(
+          Effect.mapError((cause) => toThreadTurnStreamingError('Failed to load execution plan instructions.', cause)),
+          Effect.withSpan('ThreadTurnStreaming.loadExecutionPlanInstructions'),
+        )
 
+  const resolveAgent = ctx.turnHooks.resolveAgent
   const agentResolution = asRecord(
-    yield* effectTryMaybeAsync(
-      () =>
-        ctx.turnHooks.resolveAgent?.({
-          agentId: streamParams.agentId,
-          mode: streamParams.mode,
-          thread: ctx.thread,
-          threadRef: ctx.threadRef,
-          orgRef: ctx.orgRef,
-          userRef: ctx.userRef,
-          userName: ctx.userName,
-          onboardingActive: ctx.onboardingActive,
-          linearInstalled: ctx.linearInstalled,
-          githubInstalled: ctx.githubInstalled,
-          skills: streamParams.skills,
-          additionalInstructionSections: streamParams.additionalInstructionSections,
-          context: ctx.buildContextResult,
-        }),
-      (error) => new ThreadTurnStreamingError({ message: 'Failed to resolve the runtime agent.', cause: error }),
-    ).pipe(Effect.withSpan('ThreadTurnStreaming.resolveAgent')),
+    resolveAgent
+      ? yield* Effect.tryPromise({
+          try: () =>
+            resolveAgent({
+              agentId: streamParams.agentId,
+              mode: streamParams.mode,
+              thread: ctx.thread,
+              threadRef: ctx.threadRef,
+              orgRef: ctx.orgRef,
+              userRef: ctx.userRef,
+              userName: ctx.userName,
+              onboardingActive: ctx.onboardingActive,
+              linearInstalled: ctx.linearInstalled,
+              githubInstalled: ctx.githubInstalled,
+              skills: streamParams.skills,
+              additionalInstructionSections: streamParams.additionalInstructionSections,
+              context: ctx.buildContextResult,
+            }),
+          catch: (cause) => toThreadTurnStreamingError('Failed to resolve the runtime agent.', cause),
+        }).pipe(Effect.withSpan('ThreadTurnStreaming.resolveAgent'))
+      : undefined,
   )
 
   const resolvedAgentId = readOptionalString(agentResolution?.agentId) ?? streamParams.agentId
   const latestUserMessage = [...streamParams.messages].reverse().find((message) => message.role === 'user')
   const latestUserMessageText = latestUserMessage ? extractMessageText(latestUserMessage).trim() : undefined
   const [preSeededMemoriesSection, learnedSkillsSection] = yield* Effect.all([
-    effectFromMaybeEffect(
-      () => ctx.getPreSeededMemoriesSection(resolvedAgentId),
-      `Failed to load pre-seeded memories for ${resolvedAgentId}.`,
-    ),
-    effectFromMaybeEffect(
-      () => ctx.getLearnedSkillsSection(resolvedAgentId, latestUserMessageText),
-      `Failed to load learned skills for ${resolvedAgentId}.`,
-    ),
+    ctx
+      .getPreSeededMemoriesSection(resolvedAgentId)
+      .pipe(
+        Effect.mapError((cause) =>
+          toThreadTurnStreamingError(`Failed to load pre-seeded memories for ${resolvedAgentId}.`, cause),
+        ),
+      ),
+    ctx
+      .getLearnedSkillsSection(resolvedAgentId, latestUserMessageText)
+      .pipe(
+        Effect.mapError((cause) =>
+          toThreadTurnStreamingError(`Failed to load learned skills for ${resolvedAgentId}.`, cause),
+        ),
+      ),
   ]).pipe(Effect.withSpan('ThreadTurnStreaming.loadMemoriesAndSkills'))
 
   const toolNames = new Set(Object.keys(streamParams.tools))
@@ -259,10 +252,10 @@ const streamAgentResponseEffect = Effect.fn('ThreadTurnStreaming.streamAgentResp
     hasRetrievalTools,
   })
 
-  const modelMessages = yield* effectTryPromise(
-    () => convertToModelMessages(streamParams.messages, { ignoreIncompleteToolCalls: true }),
-    'Failed to convert UI messages to model messages.',
-  ).pipe(Effect.withSpan('ThreadTurnStreaming.convertModelMessages'))
+  const modelMessages = yield* Effect.tryPromise({
+    try: () => convertToModelMessages(streamParams.messages, { ignoreIncompleteToolCalls: true }),
+    catch: (cause) => toThreadTurnStreamingError('Failed to convert UI messages to model messages.', cause),
+  }).pipe(Effect.withSpan('ThreadTurnStreaming.convertModelMessages'))
 
   const agentFactory = agentFactoryConfig.createAgent[config.id]
   if (!agentFactory) {
@@ -281,10 +274,11 @@ const streamAgentResponseEffect = Effect.fn('ThreadTurnStreaming.streamAgentResp
   const resolvedAgentName = resolveRuntimeAgentDisplayName(agentConfig, agentIdentityOverrides, resolvedAgentId)
 
   const generateFallback = (cause: ThreadTurnStreamingError) =>
-    effectTryPromise(
-      () => streamParams.observer.run(() => agent.generate({ messages: modelMessages, abortSignal: agentAbortSignal })),
-      `Agent generate fallback failed for ${resolvedAgentId}.`,
-    ).pipe(
+    Effect.tryPromise({
+      try: () =>
+        streamParams.observer.run(() => agent.generate({ messages: modelMessages, abortSignal: agentAbortSignal })),
+      catch: (error) => toThreadTurnStreamingError(`Agent generate fallback failed for ${resolvedAgentId}.`, error),
+    }).pipe(
       Effect.tap(() =>
         Effect.sync(() => {
           aiLogger.warn`Agent stream failed for ${resolvedAgentId}; falling back to generate: ${cause.message}`
@@ -293,10 +287,11 @@ const streamAgentResponseEffect = Effect.fn('ThreadTurnStreaming.streamAgentResp
       Effect.flatMap((result) => buildFallbackResponseMessage(result as ToolLoopGenerateResult)),
     )
 
-  const generateWithoutUiStream = effectTryPromise(
-    () => streamParams.observer.run(() => agent.generate({ messages: modelMessages, abortSignal: agentAbortSignal })),
-    `Agent generate failed for ${resolvedAgentId}.`,
-  ).pipe(
+  const generateWithoutUiStream = Effect.tryPromise({
+    try: () =>
+      streamParams.observer.run(() => agent.generate({ messages: modelMessages, abortSignal: agentAbortSignal })),
+    catch: (cause) => toThreadTurnStreamingError(`Agent generate failed for ${resolvedAgentId}.`, cause),
+  }).pipe(
     Effect.tapError((error) =>
       Effect.sync(() => {
         if (agentAbortSignal.aborted) {
@@ -321,10 +316,12 @@ const streamAgentResponseEffect = Effect.fn('ThreadTurnStreaming.streamAgentResp
     return generatedResponse
   }
 
-  const result = yield* effectTryPromise(
-    () => streamParams.observer.run(() => agent.stream({ messages: modelMessages, abortSignal: agentAbortSignal })),
-    `Agent stream failed for ${resolvedAgentId}.`,
-  ).pipe(
+  const writer = streamParams.writer
+  const result = yield* Effect.tryPromise({
+    try: () =>
+      streamParams.observer.run(() => agent.stream({ messages: modelMessages, abortSignal: agentAbortSignal })),
+    catch: (cause) => toThreadTurnStreamingError(`Agent stream failed for ${resolvedAgentId}.`, cause),
+  }).pipe(
     Effect.tapError((error) =>
       Effect.sync(() => {
         if (agentAbortSignal.aborted) {
@@ -355,14 +352,12 @@ const streamAgentResponseEffect = Effect.fn('ThreadTurnStreaming.streamAgentResp
       resolveFinishedStream(withMessageCreatedAt(finishedResponseMessage, nowEpochMillis()))
     },
   }) as ReadableStream<ChatStreamChunk>
-  const liveTurnTrace = streamParams.writer
-    ? createLiveTurnTraceStreamObserver({
-        traceId: `trace:${Bun.randomUUIDv7()}`,
-        writer: streamParams.writer,
-        agentId: resolvedAgentId,
-        agentName: resolvedAgentName,
-      })
-    : null
+  const liveTurnTrace = createLiveTurnTraceStreamObserver({
+    traceId: `trace:${Bun.randomUUIDv7()}`,
+    writer,
+    agentId: resolvedAgentId,
+    agentName: resolvedAgentName,
+  })
   const streamStartedAt = performance.now()
   const firstVisibleOutputRecorded = yield* Ref.make(false)
   const firstTextTokenRecorded = yield* Ref.make(false)
@@ -393,21 +388,23 @@ const streamAgentResponseEffect = Effect.fn('ThreadTurnStreaming.streamAgentResp
           yield* Effect.annotateCurrentSpan({ ttftMs: elapsedMs, ttftChunkType: chunkType })
         }
 
-        if (streamParams.writer) {
-          yield* Effect.sync(() => {
-            streamParams.writer?.write(value)
-            liveTurnTrace?.observeChunk(value)
-          })
-        }
+        yield* Effect.sync(() => {
+          writer.write(value)
+          liveTurnTrace.observeChunk(value)
+        })
       }),
     ),
     Effect.withSpan('ThreadTurnStreaming.consumeUiStream'),
     Effect.andThen(
-      effectTryPromise(() => finishedStream, `Agent run for ${resolvedAgentId} did not produce a response message.`),
+      Effect.tryPromise({
+        try: () => finishedStream,
+        catch: (cause) =>
+          toThreadTurnStreamingError(`Agent run for ${resolvedAgentId} did not produce a response message.`, cause),
+      }),
     ),
-    Effect.catchTag('ThreadTurnStreamingError', generateFallback),
+    Effect.catchTag(ERROR_TAGS.ThreadTurnStreamingError, generateFallback),
   )
-  liveTurnTrace?.finish()
+  liveTurnTrace.finish()
 
   for (const toolError of collectToolOutputErrors({ responseMessage: streamedResponse })) {
     aiLogger.error`Tool execution failed (agent=${resolvedAgentId}, tool=${toolError.toolName}, toolCallId=${toolError.toolCallId}): ${toolError.errorText}`

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

@@ -5,12 +5,12 @@ import { Context, Schema, Effect, Layer } from 'effect'
 import type { ResolvedAgentConfig } from '../../config/agent-defaults'
 import { ensureRecordId, recordIdToString } from '../../db/record-id'
 import { TABLES } from '../../db/tables'
-import { BadRequestError, ForbiddenError } from '../../effect/errors'
+import { ERROR_TAGS, BadRequestError, ForbiddenError } from '../../effect/errors'
 import { AgentConfigServiceTag } from '../../effect/services'
 import { hasApprovalRespondedParts, isApprovalContinuationRequest } from '../../runtime/approval-continuation'
 import { shouldPlanNodeUseVisibleTurn } from '../../runtime/execution-plan-visibility'
 import { wrapResponseWithKeepalive } from '../../utils/sse-keepalive'
-import { BackgroundWorkService } from '../background-work.service'
+import { BackgroundWorkServiceTag } from '../background-work.service'
 import type { makePlanExecutorService } from '../plan/plan-executor.service'
 import { PlanExecutorServiceTag } from '../plan/plan-executor.service'
 import type { makePlanRunService } from '../plan/plan-run.service'
@@ -67,14 +67,14 @@ export interface LaunchBackgroundThreadWorkResult {
   message: string
 }
 
-class ThreadTurnServiceError extends Schema.TaggedErrorClass<ThreadTurnServiceError>()('ThreadTurnServiceError', {
-  message: Schema.String,
-  cause: Schema.optional(Schema.Defect),
-}) {}
+class ThreadTurnServiceError extends Schema.TaggedErrorClass<ThreadTurnServiceError>()(
+  ERROR_TAGS.ThreadTurnServiceError,
+  { message: Schema.String, cause: Schema.optional(Schema.Defect) },
+) {}
 
 interface ThreadTurnDeps {
   agentConfig: ResolvedAgentConfig
-  background: Context.Service.Shape<typeof BackgroundWorkService>
+  background: Context.Service.Shape<typeof BackgroundWorkServiceTag>
   planExecutor: ReturnType<typeof makePlanExecutorService>
   planRun: ReturnType<typeof makePlanRunService>
   provideCurrentContext: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, never>
@@ -475,7 +475,7 @@ export const ThreadTurnServiceLive = Layer.effect(
     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 agentConfig = yield* AgentConfigServiceTag
-    const background = yield* BackgroundWorkService
+    const background = yield* BackgroundWorkServiceTag
     const planExecutor = yield* PlanExecutorServiceTag
     const planRun = yield* PlanRunServiceTag
     const thread = yield* ThreadServiceTag

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

@@ -10,7 +10,6 @@ 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 {
   AgentConfigServiceTag,
   DatabaseServiceTag,
@@ -20,7 +19,7 @@ import {
 import type { RedisConnectionManager } from '../../redis/connection'
 import { CompactionCoordinationTag } from '../../runtime/chat-run-orchestration'
 import { toIsoDateTimeString } from '../../utils/date-time'
-import { BackgroundWorkService } from '../background-work.service'
+import { BackgroundWorkServiceTag } from '../background-work.service'
 import { ChatRunRegistryTag } from '../chat-run-registry.service'
 import { ContextCompactionServiceTag } from '../context-compaction.service'
 import type { makeContextCompactionService } from '../context-compaction.service'
@@ -63,8 +62,6 @@ function toPublicThread(thread: NormalizedThread): 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>
@@ -78,7 +75,7 @@ interface ThreadServiceDeps {
   threadMessageService: ReturnType<typeof makeThreadMessageService>
   contextCompactionService: ReturnType<typeof makeContextCompactionService>
   compactionCoordination: CompactionCoordination
-  background: Context.Service.Shape<typeof BackgroundWorkService>
+  background: Context.Service.Shape<typeof BackgroundWorkServiceTag>
 }
 
 export function makeThreadService(deps: ThreadServiceDeps) {
@@ -109,10 +106,11 @@ export function makeThreadService(deps: ThreadServiceDeps) {
       return Effect.succeed(true)
     }
 
-    return effectTryPromise(
-      () => activeRun.hasActiveRunLease(ensureRecordId(thread.id, TABLES.THREAD)),
-      'Failed to check active thread run lease.',
-    )
+    return activeRun
+      .hasActiveRunLease(ensureRecordId(thread.id, TABLES.THREAD))
+      .pipe(
+        Effect.mapError((cause) => new ServiceError({ message: 'Failed to check active thread run lease.', cause })),
+      )
   }
 
   function toNormalizedThread(
@@ -174,68 +172,59 @@ export function makeThreadService(deps: ThreadServiceDeps) {
     background: deps.background,
   })
 
-  function getById(threadId: RecordIdRef) {
-    return effectTryPromise(() => threadStore.getById(threadId), 'Failed to load thread.')
-  }
+  const getById = Effect.fn('ThreadService.getById')(function* (threadId: RecordIdRef) {
+    return yield* threadStore
+      .getById(threadId)
+      .pipe(Effect.mapError((cause) => new ServiceError({ message: 'Failed to load thread.', cause })))
+  })
 
-  function getThread(threadId: RecordIdRef) {
-    return Effect.gen(function* () {
-      const thread = yield* getById(threadId)
-      return yield* toNormalizedThread(thread)
-    })
-  }
+  const getThread = Effect.fn('ThreadService.getThread')(function* (threadId: RecordIdRef) {
+    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)
-    })
-  }
+  const updateTitle = Effect.fn('ThreadService.updateTitle')(function* (threadId: RecordIdRef, title: string) {
+    const existing = yield* getById(threadId)
+    yield* assertMutableThreadEffect(existing)
+    const thread = yield* threadStore
+      .update(threadId, { title, nameGenerated: true })
+      .pipe(Effect.mapError((cause) => new ServiceError({ message: 'Failed to update thread title.', cause })))
+    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)
-    })
-  }
+  const updateStatus = Effect.fn('ThreadService.updateStatus')(function* (threadId: RecordIdRef, status: string) {
+    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* threadStore
+      .update(threadId, { status: parsedStatus.data })
+      .pipe(Effect.mapError((cause) => new ServiceError({ message: 'Failed to update thread status.', cause })))
+    return yield* toNormalizedThread(thread)
+  })
 
-  function setCompacting(threadId: RecordIdRef, value: boolean) {
+  const setCompacting = Effect.fn('ThreadService.setCompacting')(function* (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* deps.db
+      .query<unknown>(surql`UPDATE ONLY ${threadRef} SET isCompacting = ${value}`)
+      .pipe(
+        Effect.mapError((cause) => new ServiceError({ message: 'Failed to update thread compaction flag.', cause })),
       )
-      yield* effectTryPromise(
-        () =>
-          deps.db.query<unknown>(surql`
+    yield* deps.compactionCoordination.signal(threadIdString, value)
+  })
+
+  const clearThread = Effect.fn('ThreadService.clearThread')(function* (threadId: RecordIdRef) {
+    const existing = yield* getById(threadId)
+    yield* assertMutableThreadEffect(existing)
+    const threadRef = ensureRecordId(threadId, TABLES.THREAD)
+    yield* deps.db
+      .deleteWhere(TABLES.THREAD_MESSAGE, { threadId: threadRef })
+      .pipe(Effect.mapError((cause) => new ServiceError({ message: 'Failed to delete thread messages.', cause })))
+    yield* deps.db
+      .query<unknown>(surql`
           UPDATE ONLY ${threadRef}
           SET turnCount = 0,
               compactionSummary = NONE,
@@ -243,68 +232,102 @@ export function makeThreadService(deps: ThreadServiceDeps) {
               activeRunId = NONE,
               activeStreamId = NONE,
               isCompacting = false
-        `),
-        'Failed to reset thread state.',
-      )
-    })
-  }
+        `)
+      .pipe(Effect.mapError((cause) => new ServiceError({ message: 'Failed to reset thread state.', cause })))
+  })
 
-  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.')
-    })
-  }
+  const deleteThread = Effect.fn('ThreadService.deleteThread')(function* (threadId: RecordIdRef) {
+    const existing = yield* getById(threadId)
+    yield* assertMutableThreadEffect(existing)
+    yield* threadStore
+      .deleteById(threadId)
+      .pipe(Effect.mapError((cause) => new ServiceError({ message: 'Failed to delete thread.', cause })))
+  })
 
   function incrementTurnCount(threadId: RecordIdRef) {
     const threadRef = ensureRecordId(threadId, TABLES.THREAD)
     return Effect.gen(function* () {
-      const result = yield* effectTryPromise(
-        () =>
-          deps.db.query<{ turnCount: number }>(
-            surql`
+      const result = yield* deps.db
+        .query<{ turnCount: number }>(
+          surql`
         UPDATE ONLY ${threadRef}
         SET turnCount += 1
         RETURN turnCount
       `,
-          ),
-        'Failed to increment thread turn count.',
-      )
+        )
+        .pipe(
+          Effect.mapError((cause) => new ServiceError({ message: 'Failed to increment thread turn count.', cause })),
+        )
       return result[0].turnCount
     })
   }
 
   return {
     findById: (...args: Parameters<typeof threadStore.findById>) =>
-      effectTryPromise(() => threadStore.findById(...args), 'Failed to find thread.'),
+      threadStore.findById(...args).pipe(
+        Effect.mapError((cause) => new ServiceError({ message: 'Failed to find thread.', cause })),
+        Effect.withSpan('ThreadService.findById'),
+      ),
     getById,
     findAll: (...args: Parameters<typeof threadStore.findAll>) =>
-      effectTryPromise(() => threadStore.findAll(...args), 'Failed to find all threads.'),
+      threadStore.findAll(...args).pipe(
+        Effect.mapError((cause) => new ServiceError({ message: 'Failed to find all threads.', cause })),
+        Effect.withSpan('ThreadService.findAll'),
+      ),
     create: (...args: Parameters<typeof threadStore.create>) =>
-      effectTryPromise(() => threadStore.create(...args), 'Failed to create thread.'),
+      threadStore.create(...args).pipe(
+        Effect.mapError((cause) => new ServiceError({ message: 'Failed to create thread.', cause })),
+        Effect.withSpan('ThreadService.create'),
+      ),
     update: (...args: Parameters<typeof threadStore.update>) =>
-      effectTryPromise(() => threadStore.update(...args), 'Failed to update thread.'),
+      threadStore.update(...args).pipe(
+        Effect.mapError((cause) => new ServiceError({ message: 'Failed to update thread.', cause })),
+        Effect.withSpan('ThreadService.update'),
+      ),
     delete: (...args: Parameters<typeof threadStore.deleteById>) =>
-      effectTryPromise(() => threadStore.deleteById(...args), 'Failed to delete thread.'),
+      threadStore.deleteById(...args).pipe(
+        Effect.mapError((cause) => new ServiceError({ message: 'Failed to delete thread.', cause })),
+        Effect.withSpan('ThreadService.delete'),
+      ),
     getOrCreateDefault: (...args: Parameters<typeof bootstrap.getOrCreateDefault>) =>
-      effectTryPromise(() => bootstrap.getOrCreateDefault(...args), 'Failed to get or create default thread.'),
+      bootstrap.getOrCreateDefault(...args).pipe(
+        Effect.mapError((cause) => new ServiceError({ message: 'Failed to get or create default thread.', cause })),
+        Effect.withSpan('ThreadService.getOrCreateDefault'),
+      ),
     getOrCreateThread: (...args: Parameters<typeof bootstrap.getOrCreateThread>) =>
-      effectTryPromise(() => bootstrap.getOrCreateThread(...args), 'Failed to get or create thread.'),
+      bootstrap.getOrCreateThread(...args).pipe(
+        Effect.mapError((cause) => new ServiceError({ message: 'Failed to get or create thread.', cause })),
+        Effect.withSpan('ThreadService.getOrCreateThread'),
+      ),
     createThread: (...args: Parameters<typeof bootstrap.createThread>) =>
-      effectTryPromise(() => bootstrap.createThread(...args), 'Failed to create thread.'),
+      bootstrap.createThread(...args).pipe(
+        Effect.mapError((cause) => new ServiceError({ message: 'Failed to create thread.', cause })),
+        Effect.withSpan('ThreadService.createThread'),
+      ),
     ensureBootstrapThreads: (...args: Parameters<typeof bootstrap.ensureBootstrapThreads>) =>
-      effectTryPromise(() => bootstrap.ensureBootstrapThreads(...args), 'Failed to ensure bootstrap threads.'),
+      bootstrap.ensureBootstrapThreads(...args).pipe(
+        Effect.mapError((cause) => new ServiceError({ message: 'Failed to ensure bootstrap threads.', cause })),
+        Effect.withSpan('ThreadService.ensureBootstrapThreads'),
+      ),
     listThreads: (...args: Parameters<typeof listing.listThreads>) =>
-      effectTryPromise(() => listing.listThreads(...args), 'Failed to list threads.'),
+      listing.listThreads(...args).pipe(
+        Effect.mapError((cause) => new ServiceError({ message: 'Failed to list threads.', cause })),
+        Effect.withSpan('ThreadService.listThreads'),
+      ),
     listOrganizationThreads: (...args: Parameters<typeof listing.listOrganizationThreads>) =>
-      effectTryPromise(() => listing.listOrganizationThreads(...args), 'Failed to list organization threads.'),
+      listing.listOrganizationThreads(...args).pipe(
+        Effect.mapError((cause) => new ServiceError({ message: 'Failed to list organization threads.', cause })),
+        Effect.withSpan('ThreadService.listOrganizationThreads'),
+      ),
     getThread,
     updateTitle,
     updateStatus,
     setActiveTurn: activeRun.setActiveTurn,
     getActiveTurn: (...args: Parameters<typeof activeRun.getActiveTurn>) =>
-      effectTryPromise(() => activeRun.getActiveTurn(...args), 'Failed to get active turn.'),
+      activeRun.getActiveTurn(...args).pipe(
+        Effect.mapError((cause) => new ServiceError({ message: 'Failed to get active turn.', cause })),
+        Effect.withSpan('ThreadService.getActiveTurn'),
+      ),
     getActiveRunId: activeRun.getActiveRunId,
     hasActiveRunLease: activeRun.hasActiveRunLease,
     withActiveRunLease: activeRun.withActiveRunLease,
@@ -312,16 +335,28 @@ export function makeThreadService(deps: ThreadServiceDeps) {
     clearActiveTurn: activeRun.clearActiveTurn,
     clearStaleActiveRunIfMissingFromRegistry: activeRun.clearStaleActiveRunIfMissingFromRegistry,
     stopActiveRun: (...args: Parameters<typeof activeRun.stopActiveRun>) =>
-      effectTryPromise(() => activeRun.stopActiveRun(...args), 'Failed to stop active run.'),
+      activeRun.stopActiveRun(...args).pipe(
+        Effect.mapError((cause) => new ServiceError({ message: 'Failed to stop active run.', cause })),
+        Effect.withSpan('ThreadService.stopActiveRun'),
+      ),
     setCompacting,
     appendMemoryBlock: (...args: Parameters<typeof memory.appendMemoryBlock>) =>
-      effectTryPromise(() => memory.appendMemoryBlock(...args), 'Failed to append memory block.'),
+      memory.appendMemoryBlock(...args).pipe(
+        Effect.mapError((cause) => new ServiceError({ message: 'Failed to append memory block.', cause })),
+        Effect.withSpan('ThreadService.appendMemoryBlock'),
+      ),
     compactMemoryBlock: (...args: Parameters<typeof memory.compactMemoryBlock>) =>
-      effectTryPromise(() => memory.compactMemoryBlock(...args), 'Failed to compact memory block.'),
+      memory.compactMemoryBlock(...args).pipe(
+        Effect.mapError((cause) => new ServiceError({ message: 'Failed to compact memory block.', cause })),
+        Effect.withSpan('ThreadService.compactMemoryBlock'),
+      ),
     clearThread,
     deleteThread,
     listRecentThreads: (...args: Parameters<typeof listing.listRecentThreads>) =>
-      effectTryPromise(() => listing.listRecentThreads(...args), 'Failed to list recent threads.'),
+      listing.listRecentThreads(...args).pipe(
+        Effect.mapError((cause) => new ServiceError({ message: 'Failed to list recent threads.', cause })),
+        Effect.withSpan('ThreadService.listRecentThreads'),
+      ),
     formatMemoryBlockForPrompt,
     toPublicThread,
     incrementTurnCount,
@@ -343,7 +378,7 @@ export const ThreadServiceLive = Layer.effect(
     const threadMessageService = yield* ThreadMessageServiceTag
     const contextCompactionService = yield* ContextCompactionServiceTag
     const compactionCoordination = yield* CompactionCoordinationTag
-    const background = yield* BackgroundWorkService
+    const background = yield* BackgroundWorkServiceTag
     return makeThreadService({
       agentConfig,
       threadBootstrapConfig,