@lota-sdk/core 0.4.9 → 0.4.10

package/src/services/system-executor.service.ts

@@ -1,8 +1,13 @@
 import type { OwnershipDispatchContext, PlanNodeResult, PlanNodeSpec, SystemPlanNodeOwner } from '@lota-sdk/shared'
 import { Context, Effect, Layer } from 'effect'
 
-import { BadRequestError } from '../effect/errors'
+import { BadRequestError, ServiceError } from '../effect/errors'
+import { makeEffectTryPromiseWithMessage } from '../effect/helpers'
 import { RuntimeConfigServiceTag } from '../effect/services'
+
+const trySystemExecutorPromise = makeEffectTryPromiseWithMessage(
+  (message, cause) => new ServiceError({ message, cause }),
+)
 import type { SystemNodeExecutor, PluginNodeExecutionParams } from '../runtime/plugin-types'
 import type { ResolvedLotaRuntimeConfig } from '../runtime/runtime-config'
 import type { PlanValidationIssueInput } from './plan/plan-validator.service'
@@ -86,27 +91,27 @@ export function makeSystemExecutorService(config: ResolvedLotaRuntimeConfig) {
       return []
     },
 
-    executeNode(params: {
+    executeNode: Effect.fn('SystemExecutor.executeNode')(function* (params: {
       nodeSpec: PlanNodeSpec
       resolvedInput: Record<string, unknown>
       context: OwnershipDispatchContext
     }) {
-      return Effect.gen(function* () {
-        const owner = params.nodeSpec.owner
-        if (!isSystemOwner(owner)) {
-          return yield* new BadRequestError({
-            message: `SystemExecutor cannot execute owner type "${owner.executorType}".`,
-          })
-        }
+      const owner = params.nodeSpec.owner
+      if (!isSystemOwner(owner)) {
+        return yield* new BadRequestError({
+          message: `SystemExecutor cannot execute owner type "${owner.executorType}".`,
+        })
+      }
 
-        const executor = getSystemExecutors()[owner.ref]
-        if (!executor || !executor.supportedOperations.includes(owner.operation)) {
-          return yield* new BadRequestError({
-            message: `System executor ${owner.ref}.${owner.operation} is not registered.`,
-          })
-        }
+      const executor = getSystemExecutors()[owner.ref]
+      if (!executor || !executor.supportedOperations.includes(owner.operation)) {
+        return yield* new BadRequestError({
+          message: `System executor ${owner.ref}.${owner.operation} is not registered.`,
+        })
+      }
 
-        return yield* Effect.tryPromise(() =>
+      return yield* trySystemExecutorPromise(
+        () =>
           executor.executeNode(
             buildSystemExecutionParams({
               owner,
@@ -115,16 +120,16 @@ export function makeSystemExecutorService(config: ResolvedLotaRuntimeConfig) {
               context: params.context,
             }),
           ),
-        )
-      })
-    },
+        `System executor "${owner.ref}.${owner.operation}" failed.`,
+      ).pipe(Effect.withSpan('SystemExecutor.invoke'))
+    }),
   }
 }
 
 export class SystemExecutorServiceTag extends Context.Service<
   SystemExecutorServiceTag,
   ReturnType<typeof makeSystemExecutorService>
->()('SystemExecutorService') {}
+>()('@lota-sdk/core/SystemExecutorService') {}
 
 export const SystemExecutorServiceLive = Layer.effect(
   SystemExecutorServiceTag,

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

@@ -8,6 +8,7 @@ import type { RecordIdRef } from '../../db/record-id'
 import { ensureRecordId, recordIdToString } from '../../db/record-id'
 import { TABLES } from '../../db/tables'
 import { BadRequestError, DatabaseError } from '../../effect/errors'
+import type { LockAcquisitionError, LockLostError, NotFoundError, RedisError, ServiceError } from '../../effect/errors'
 import type { RedisConnectionManager } from '../../redis/connection'
 import { withLeaseLock } from '../../redis/redis-lease-lock'
 import type { makeThreadMessageService } from './thread-message.service'
@@ -31,7 +32,22 @@ function haveSameMembers(left: string[], right: string[]): boolean {
   return left.length === right.length && left.every((value, index) => value === right[index])
 }
 
-type NormalizedThreadFactory = (thread: ThreadRecord) => Effect.Effect<NormalizedThread, unknown>
+type ThreadNormalizationError = BadRequestError | ServiceError
+type ThreadBootstrapError =
+  | BadRequestError
+  | DatabaseError
+  | LockAcquisitionError
+  | LockLostError
+  | NotFoundError
+  | RedisError
+  | ServiceError
+
+type NormalizedThreadFactory = (thread: ThreadRecord) => Effect.Effect<NormalizedThread, ThreadNormalizationError>
+type DuplicateCreateErrorLike = { cause?: unknown; message?: unknown }
+
+function isDuplicateCreateErrorLike(value: unknown): value is DuplicateCreateErrorLike {
+  return (typeof value === 'object' || typeof value === 'function') && value !== null
+}
 
 export function createThreadBootstrapHelpers(deps: {
   threadStore: ThreadRecordStore
@@ -85,26 +101,26 @@ export function createThreadBootstrapHelpers(deps: {
     const seen = new Set<unknown>()
     let current = error
 
-    while ((typeof current === 'object' || typeof current === 'function') && current !== null && !seen.has(current)) {
+    while (isDuplicateCreateErrorLike(current) && !seen.has(current)) {
       seen.add(current)
-      const message = Reflect.get(current, 'message')
-      if (typeof message === 'string' && message.includes('already contains')) {
+      if (typeof current.message === 'string' && current.message.includes('already contains')) {
         return true
       }
-      current = Reflect.get(current, 'cause')
+      current = current.cause
     }
 
     return false
   }
 
-  const normalizeThreadEffect = (thread: ThreadRecord) => deps.normalizeThread(thread)
+  const normalizeThreadEffect = (thread: ThreadRecord): Effect.Effect<NormalizedThread, ThreadNormalizationError> =>
+    deps.normalizeThread(thread)
 
   const getOrCreateDefaultEffect = (
     orgId: RecordIdRef,
     userId: RecordIdRef,
     agentId: string,
     config?: { title?: string; nameGenerated?: boolean },
-  ) => {
+  ): Effect.Effect<{ created: boolean; record: ThreadRecord }, DatabaseError | NotFoundError> => {
     const lookup = { type: 'default' as const, organizationId: orgId, userId, agentId }
 
     return Effect.gen(function* () {
@@ -150,7 +166,7 @@ export function createThreadBootstrapHelpers(deps: {
     userId: RecordIdRef,
     threadType: string,
     config: { members: string[]; title: string; nameGenerated?: boolean },
-  ) => {
+  ): Effect.Effect<{ created: boolean; record: ThreadRecord }, DatabaseError | NotFoundError> => {
     const lookup = { type: 'thread' as const, organizationId: orgId, userId, threadType }
 
     return Effect.gen(function* () {
@@ -199,7 +215,7 @@ export function createThreadBootstrapHelpers(deps: {
     threadType?: string
     members?: string[]
     title?: string
-  }) =>
+  }): Effect.Effect<NormalizedThread, ThreadBootstrapError> =>
     Effect.gen(function* () {
       switch (input.type) {
         case 'default':
@@ -262,7 +278,7 @@ export function createThreadBootstrapHelpers(deps: {
     userId: RecordIdRef,
     orgId: RecordIdRef,
     options?: { onboardStatus?: string; userName?: string | null },
-  ) => {
+  ): Effect.Effect<void, ThreadBootstrapError> => {
     const bootstrapConfig = getThreadBootstrapConfig()
 
     return withLeaseLock(

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

@@ -5,6 +5,7 @@ import { BoundQuery } from 'surrealdb'
 import type { RecordIdRef } from '../../db/record-id'
 import type { SurrealDBService } from '../../db/service'
 import { TABLES } from '../../db/tables'
+import type { BadRequestError, ServiceError } from '../../effect/errors'
 import { makeEffectTryPromiseWithMessage } from '../../effect/helpers'
 import { ThreadSchema } from './thread.types'
 import type { NormalizedThread, ThreadRecord } from './thread.types'
@@ -38,7 +39,7 @@ export function createThreadListingHelpers(deps: {
   normalizeThreads(
     threads: ThreadRecord[],
     options?: { checkLease?: boolean },
-  ): Effect.Effect<NormalizedThread[], unknown>
+  ): Effect.Effect<NormalizedThread[], BadRequestError | ServiceError>
 }) {
   class ThreadListingError extends Schema.TaggedErrorClass<ThreadListingError>()('ThreadListingError', {
     message: Schema.String,

package/src/services/thread/thread-memory-block.ts

@@ -1,3 +1,4 @@
+import type { Context } from 'effect'
 import { Schema, Effect } from 'effect'
 
 import { serverLogger } from '../../config/logger'
@@ -9,16 +10,19 @@ import {
   appendToMemoryBlock,
   compactMemoryBlockEntries,
   formatPersistedMemoryBlockForPrompt,
+  MemoryBlockCompactError,
   parseMemoryBlock,
   serializeMemoryBlock,
 } from '../../runtime/memory/memory-block'
+import type { BackgroundWorkService } from '../background-work.service'
+import type { makeContextCompactionService } from '../context-compaction.service'
 import { MEMORY_BLOCK_COMPACTION_CHUNK_ENTRIES, MEMORY_BLOCK_COMPACTION_TRIGGER_ENTRIES } from './thread-constants'
 import type { ThreadRecordStore } from './thread-record-store'
 import type { ThreadRecord } from './thread.types'
 
-type ContextCompactionServiceLike = {
-  compactMemoryBlock(params: { previousSummary: string; newEntriesText: string }): Effect.Effect<string, unknown>
-}
+type ContextCompactionServiceLike = Pick<ReturnType<typeof makeContextCompactionService>, 'compactMemoryBlock'>
+
+type BackgroundWorker = Context.Service.Shape<typeof BackgroundWorkService>
 
 class ThreadMemoryBlockError extends Schema.TaggedErrorClass<ThreadMemoryBlockError>()('ThreadMemoryBlockError', {
   message: Schema.String,
@@ -39,6 +43,7 @@ export function formatMemoryBlockForPrompt(thread: Pick<ThreadRecord, 'memoryBlo
 export function createThreadMemoryBlockHelpers(deps: {
   threadStore: ThreadRecordStore
   contextCompactionService: ContextCompactionServiceLike
+  background: BackgroundWorker
 }) {
   function appendMemoryBlock(threadId: RecordIdRef, entry: string): Effect.Effect<string, ThreadMemoryBlockError> {
     return Effect.gen(function* () {
@@ -63,7 +68,7 @@ export function createThreadMemoryBlockHelpers(deps: {
       )
 
       if (updatedEntries.length >= MEMORY_BLOCK_COMPACTION_TRIGGER_ENTRIES) {
-        yield* Effect.forkDetach(
+        yield* deps.background.run(
           compactMemoryBlock(threadRef).pipe(
             Effect.catch((error: unknown) =>
               Effect.sync(() => {
@@ -71,6 +76,7 @@ export function createThreadMemoryBlockHelpers(deps: {
               }),
             ),
           ),
+          'thread-memory-block.compactMemoryBlock',
         )
       }
 
@@ -93,7 +99,14 @@ export function createThreadMemoryBlockHelpers(deps: {
             entries: parseMemoryBlock(thread.memoryBlock),
             triggerEntries: MEMORY_BLOCK_COMPACTION_TRIGGER_ENTRIES,
             chunkEntries: MEMORY_BLOCK_COMPACTION_CHUNK_ENTRIES,
-            compact: (params) => deps.contextCompactionService.compactMemoryBlock(params),
+            compact: (params) =>
+              deps.contextCompactionService
+                .compactMemoryBlock(params)
+                .pipe(
+                  Effect.mapError(
+                    (cause) => new MemoryBlockCompactError({ message: 'compact callback failed', cause }),
+                  ),
+                ),
           }),
         `Failed to compact memory block for thread ${threadIdString}`,
       )

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

@@ -3,6 +3,7 @@ import type { ChatMessage } from '@lota-sdk/shared'
 import { Context, Effect, Layer } from 'effect'
 import { RecordId, surql } from 'surrealdb'
 import { z } from 'zod'
+import type { ZodTypeAny } from 'zod'
 
 import { getAgentDisplayNames } from '../../config/agent-defaults'
 import { CursorRowSchema, listMessageHistoryPageEffect } from '../../db/cursor-pagination'
@@ -21,6 +22,17 @@ import { nowEpochMillis, unsafeDateFrom } from '../../utils/date-time'
 
 const ThreadMessageExistingRowSchema = z.object({ id: recordIdSchema, createdAt: z.coerce.date() })
 
+function parseRowOrFail<TSchema extends ZodTypeAny>(
+  schema: TSchema,
+  value: unknown,
+  operation: string,
+): Effect.Effect<z.infer<TSchema>, ServiceError> {
+  return Effect.try({
+    try: () => schema.parse(value) as z.infer<TSchema>,
+    catch: (cause) => new ServiceError({ message: `Failed to parse row for ${operation}.`, cause }),
+  })
+}
+
 function toMessageId(value: string | RecordIdRef): string {
   return recordIdToString(value, TABLES.THREAD_MESSAGE)
 }
@@ -160,7 +172,10 @@ export function makeThreadMessageService(db: SurrealDBService) {
       `),
         'Failed to list thread messages.',
       ).pipe(
-        Effect.map((rows) => rows.map((row) => ThreadMessageRowSchema.parse(row)).map((row) => toChatMessage(row))),
+        Effect.flatMap((rows) =>
+          Effect.forEach(rows, (row) => parseRowOrFail(ThreadMessageRowSchema, row, 'listMessages')),
+        ),
+        Effect.map((rows) => rows.map((row) => toChatMessage(row))),
       )
     },
     listMessagesEffect(threadId: RecordIdRef) {
@@ -210,7 +225,10 @@ export function makeThreadMessageService(db: SurrealDBService) {
           `),
           'Failed to list thread messages after cursor.',
         )
-        return rows.map((row) => ThreadMessageRowSchema.parse(row)).map((row) => toChatMessage(row))
+        const parsedRows = yield* Effect.forEach(rows, (row) =>
+          parseRowOrFail(ThreadMessageRowSchema, row, 'listMessagesAfterCursor'),
+        )
+        return parsedRows.map((row) => toChatMessage(row))
       })
     },
     listMessagesAfterCursorEffect(threadId: RecordIdRef, afterMessageId?: string) {
@@ -229,12 +247,10 @@ export function makeThreadMessageService(db: SurrealDBService) {
       `),
         'Failed to list recent thread messages.',
       ).pipe(
-        Effect.map((rows) =>
-          rows
-            .map((row) => ThreadMessageRowSchema.parse(row))
-            .reverse()
-            .map((row) => toChatMessage(row)),
+        Effect.flatMap((rows) =>
+          Effect.forEach(rows, (row) => parseRowOrFail(ThreadMessageRowSchema, row, 'listRecentMessages')),
         ),
+        Effect.map((rows) => rows.reverse().map((row) => toChatMessage(row))),
       )
     },
     listRecentMessagesEffect(threadId: RecordIdRef, limit: number) {
@@ -352,7 +368,7 @@ export function makeThreadMessageService(db: SurrealDBService) {
 export class ThreadMessageServiceTag extends Context.Service<
   ThreadMessageServiceTag,
   ReturnType<typeof makeThreadMessageService>
->()('ThreadMessageService') {}
+>()('@lota-sdk/core/ThreadMessageService') {}
 
 export const ThreadMessageServiceLive = Layer.effect(
   ThreadMessageServiceTag,

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

@@ -62,7 +62,7 @@ export function makeThreadTitleService(
 export class ThreadTitleServiceTag extends Context.Service<
   ThreadTitleServiceTag,
   ReturnType<typeof makeThreadTitleService>
->()('ThreadTitleService') {}
+>()('@lota-sdk/core/ThreadTitleService') {}
 
 export const ThreadTitleServiceLive = Layer.effect(
   ThreadTitleServiceTag,

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

@@ -142,7 +142,7 @@ export function createThreadTurnVisibleAgentRunner<TBuildTurnToolParams>(
       aiLogger.error`Agent run failed (agent=${agentId}): ${error}`
     },
     recordAbort: (error: unknown) => {
-      aiLogger.info`Agent run aborted (agent=${agentId}): ${error instanceof Error ? error.message : String(error)}`
+      aiLogger.debug`Agent run aborted (agent=${agentId}): ${error instanceof Error ? error.message : String(error)}`
     },
   })
 

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

@@ -570,20 +570,22 @@ const prepareThreadRunCoreEffect = Effect.fn('ThreadTurnPreparation.prepareThrea
       return Effect.succeed(preSeededMemoriesByAgent.get(agentId))
     }
 
-    return Effect.gen(function* () {
-      const preSeededMemories = yield* memoryService.getTopMemories({
-        orgId: orgIdString,
-        agentName: agentId,
-        limit: PRESEEDED_MEMORY_LOOKUP_LIMIT,
-      })
-      preSeededMemoriesByAgent.set(agentId, preSeededMemories)
-      return preSeededMemories
-    }).pipe(
-      Effect.mapError(
-        (error) =>
-          new ThreadTurnStreamingError({ message: `Failed to load pre-seeded memories for ${agentId}.`, cause: error }),
-      ),
-    )
+    return memoryService
+      .getTopMemories({ orgId: orgIdString, agentName: agentId, limit: PRESEEDED_MEMORY_LOOKUP_LIMIT })
+      .pipe(
+        Effect.tap((preSeededMemories) =>
+          Effect.sync(() => {
+            preSeededMemoriesByAgent.set(agentId, preSeededMemories)
+          }),
+        ),
+        Effect.mapError(
+          (error) =>
+            new ThreadTurnStreamingError({
+              message: `Failed to load pre-seeded memories for ${agentId}.`,
+              cause: error,
+            }),
+        ),
+      )
   }
 
   const learnedSkillsByAgent = new Map<string, string | undefined>()
@@ -1083,7 +1085,7 @@ export function makeThreadTurnPreparationService(deps: ThreadTurnPreparationDeps
       randomId: () => Bun.randomUUIDv7(),
     }),
   }
-  const annotateTurnSpans = <A, E>(params: ThreadRunCoreParams, effect: Effect.Effect<A, E>) =>
+  const annotateTurnSpans = <A, E, R>(params: ThreadRunCoreParams, effect: Effect.Effect<A, E, R>) =>
     effect.pipe(
       Effect.annotateSpans(
         compactSpanAttributes({
@@ -1116,7 +1118,7 @@ export function makeThreadTurnPreparationService(deps: ThreadTurnPreparationDeps
 export class ThreadTurnPreparationServiceTag extends Context.Service<
   ThreadTurnPreparationServiceTag,
   ReturnType<typeof makeThreadTurnPreparationService>
->()('ThreadTurnPreparationService') {}
+>()('@lota-sdk/core/ThreadTurnPreparationService') {}
 
 export const ThreadTurnPreparationServiceLive = Layer.effect(
   ThreadTurnPreparationServiceTag,

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

@@ -7,7 +7,7 @@ import { Effect, Ref, Schema, Stream } from 'effect'
 import { getAgentRuntimeConfig, getResolvedAgentFactoryConfig } from '../../config/agent-defaults'
 import { aiLogger } from '../../config/logger'
 import type { RecordIdRef } from '../../db/record-id'
-import { effectTryMaybeAsync, effectTryPromise as effectTryPromiseShared } from '../../effect/helpers'
+import { effectTryMaybeAsync, makeEffectTryPromiseWithMessage } from '../../effect/helpers'
 import { runPromise } from '../../effect/runtime'
 import {
   readRuntimeAgentIdentityOverrides,
@@ -44,12 +44,9 @@ export class ThreadTurnStreamingError extends Schema.TaggedErrorClass<ThreadTurn
   { message: Schema.String, cause: Schema.optional(Schema.Defect) },
 ) {}
 
-function effectTryPromise<A>(
-  evaluate: () => PromiseLike<A>,
-  message: string,
-): Effect.Effect<A, ThreadTurnStreamingError> {
-  return effectTryPromiseShared(evaluate, (error) => new ThreadTurnStreamingError({ message, cause: error }))
-}
+const effectTryPromise = makeEffectTryPromiseWithMessage(
+  (message, cause) => new ThreadTurnStreamingError({ message, cause }),
+)
 
 function effectFromMaybeEffect<A>(
   evaluate: () => A | PromiseLike<A> | Effect.Effect<A, ThreadTurnStreamingError>,
@@ -93,7 +90,9 @@ function isTextTokenChunkType(chunkType: string | undefined): boolean {
   return chunkType === 'text-delta'
 }
 
-function buildFallbackResponseMessage(result: ToolLoopGenerateResult): ChatMessage {
+function buildFallbackResponseMessage(
+  result: ToolLoopGenerateResult,
+): Effect.Effect<ChatMessage, ThreadTurnStreamingError> {
   const parts: ChatMessage['parts'] = []
 
   for (const step of result.steps ?? []) {
@@ -114,10 +113,12 @@ function buildFallbackResponseMessage(result: ToolLoopGenerateResult): ChatMessa
   }
 
   if (parts.length === 0) {
-    throw new Error('Agent generate fallback did not produce any response parts.')
+    return Effect.fail(
+      new ThreadTurnStreamingError({ message: 'Agent generate fallback did not produce any response parts.' }),
+    )
   }
 
-  return { id: Bun.randomUUIDv7(), role: 'assistant', parts }
+  return Effect.succeed({ id: Bun.randomUUIDv7(), role: 'assistant', parts })
 }
 
 export interface StreamAgentResponseContext {
@@ -287,7 +288,7 @@ const streamAgentResponseEffect = Effect.fn('ThreadTurnStreaming.streamAgentResp
           aiLogger.warn`Agent stream failed for ${resolvedAgentId}; falling back to generate: ${cause.message}`
         }),
       ),
-      Effect.map((result) => buildFallbackResponseMessage(result as ToolLoopGenerateResult)),
+      Effect.flatMap((result) => buildFallbackResponseMessage(result as ToolLoopGenerateResult)),
     )
 
   const result = yield* effectTryPromise(

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

@@ -6,7 +6,6 @@ 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'
@@ -299,7 +298,7 @@ export function makeThreadTurnService(deps: ThreadTurnDeps) {
 export class ThreadTurnServiceTag extends Context.Service<
   ThreadTurnServiceTag,
   ReturnType<typeof makeThreadTurnService>
->()('ThreadTurnService') {}
+>()('@lota-sdk/core/ThreadTurnService') {}
 
 export const ThreadTurnServiceLive = Layer.effect(
   ThreadTurnServiceTag,
@@ -313,24 +312,58 @@ export const ThreadTurnServiceLive = Layer.effect(
   }),
 )
 
-function getThreadTurnService() {
-  return getCurrentRuntime().runSync(Effect.service(ThreadTurnServiceTag))
-}
+const createThreadApprovalContinuationStreamWithRuntime = Effect.fn(
+  'ThreadTurn.createApprovalContinuationStreamWithRuntime',
+)(function* (params: ThreadApprovalContinuationParams) {
+  const threadTurnService = yield* ThreadTurnServiceTag
+  return yield* threadTurnService.createThreadApprovalContinuationStream(params)
+})
+
+const createThreadNativeToolApprovalStreamWithRuntime = Effect.fn(
+  'ThreadTurn.createNativeToolApprovalStreamWithRuntime',
+)(function* (params: ThreadApprovalContinuationParams) {
+  const threadTurnService = yield* ThreadTurnServiceTag
+  return yield* threadTurnService.createThreadNativeToolApprovalStream(params)
+})
+
+const createThreadTurnStreamWithRuntime = Effect.fn('ThreadTurn.createThreadTurnStreamWithRuntime')(function* (
+  params: ThreadTurnParams,
+) {
+  const threadTurnService = yield* ThreadTurnServiceTag
+  return yield* threadTurnService.createThreadTurnStream(params)
+})
+
+const runThreadTurnInBackgroundWithRuntime = Effect.fn('ThreadTurn.runThreadTurnInBackgroundWithRuntime')(function* (
+  params: ThreadTurnParams,
+) {
+  const threadTurnService = yield* ThreadTurnServiceTag
+  return yield* threadTurnService.runThreadTurnInBackground(params)
+})
+
+const triggerPlanNodeTurnWithRuntime = Effect.fn('ThreadTurn.triggerPlanNodeTurnWithRuntime')(function* (params: {
+  runId: string
+  nodeId: string
+  abortSignal?: AbortSignal
+  streamId?: string
+}) {
+  const threadTurnService = yield* ThreadTurnServiceTag
+  return yield* threadTurnService.triggerPlanNodeTurn(params)
+})
 
 export function createThreadApprovalContinuationStream(params: ThreadApprovalContinuationParams) {
-  return runPromise(getThreadTurnService().createThreadApprovalContinuationStream(params))
+  return runPromise(createThreadApprovalContinuationStreamWithRuntime(params))
 }
 
 export function createThreadNativeToolApprovalStream(params: ThreadApprovalContinuationParams) {
-  return runPromise(getThreadTurnService().createThreadNativeToolApprovalStream(params))
+  return runPromise(createThreadNativeToolApprovalStreamWithRuntime(params))
 }
 
 export function createThreadTurnStream(params: ThreadTurnParams) {
-  return runPromise(getThreadTurnService().createThreadTurnStream(params))
+  return runPromise(createThreadTurnStreamWithRuntime(params))
 }
 
 export function runThreadTurnInBackground(params: ThreadTurnParams): Promise<PreparedThreadTurnResult> {
-  return runPromise(getThreadTurnService().runThreadTurnInBackground(params))
+  return runPromise(runThreadTurnInBackgroundWithRuntime(params))
 }
 
 export function triggerPlanNodeTurn(params: {
@@ -339,5 +372,5 @@ export function triggerPlanNodeTurn(params: {
   abortSignal?: AbortSignal
   streamId?: string
 }): Promise<PreparedThreadTurnResult> {
-  return runPromise(getThreadTurnService().triggerPlanNodeTurn(params))
+  return runPromise(triggerPlanNodeTurnWithRuntime(params))
 }

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

@@ -13,6 +13,7 @@ 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 { BackgroundWorkService } from '../background-work.service'
 import { ChatRunRegistryTag } from '../chat-run-registry.service'
 import { ContextCompactionServiceTag } from '../context-compaction.service'
 import type { makeContextCompactionService } from '../context-compaction.service'
@@ -68,6 +69,7 @@ interface ThreadServiceDeps {
   threadMessageService: ReturnType<typeof makeThreadMessageService>
   contextCompactionService: ReturnType<typeof makeContextCompactionService>
   compactionCoordination: CompactionCoordination
+  background: Context.Service.Shape<typeof BackgroundWorkService>
 }
 
 export function makeThreadService(deps: ThreadServiceDeps) {
@@ -115,7 +117,7 @@ export function makeThreadService(deps: ThreadServiceDeps) {
         normalizeRecordIdStringEffect(thread.userId, TABLES.USER),
         normalizeRecordIdStringEffect(thread.organizationId, TABLES.ORGANIZATION),
       ])
-      return NormalizedThreadSchema.parse({
+      const candidate = {
         id,
         userId,
         organizationId,
@@ -131,6 +133,10 @@ export function makeThreadService(deps: ThreadServiceDeps) {
         members: thread.members,
         createdAt: toIsoDateTimeString(thread.createdAt),
         updatedAt: toIsoDateTimeString(thread.updatedAt),
+      }
+      return yield* Effect.try({
+        try: () => NormalizedThreadSchema.parse(candidate),
+        catch: (cause) => new ServiceError({ message: 'Failed to parse normalized thread.', cause }),
       })
     })
   }
@@ -154,6 +160,7 @@ export function makeThreadService(deps: ThreadServiceDeps) {
   const memory = createThreadMemoryBlockHelpers({
     threadStore,
     contextCompactionService: { compactMemoryBlock: deps.contextCompactionService.compactMemoryBlock },
+    background: deps.background,
   })
 
   function getById(threadId: RecordIdRef) {
@@ -311,7 +318,7 @@ export function makeThreadService(deps: ThreadServiceDeps) {
 }
 
 export class ThreadServiceTag extends Context.Service<ThreadServiceTag, ReturnType<typeof makeThreadService>>()(
-  'ThreadService',
+  '@lota-sdk/core/ThreadService',
 ) {}
 
 export const ThreadServiceLive = Layer.effect(
@@ -323,6 +330,7 @@ export const ThreadServiceLive = Layer.effect(
     const threadMessageService = yield* ThreadMessageServiceTag
     const contextCompactionService = yield* ContextCompactionServiceTag
     const compactionCoordination = yield* CompactionCoordinationTag
+    const background = yield* BackgroundWorkService
     return makeThreadService({
       db,
       redis,
@@ -330,6 +338,7 @@ export const ThreadServiceLive = Layer.effect(
       threadMessageService,
       contextCompactionService,
       compactionCoordination,
+      background,
     })
   }),
 )

package/src/services/user.service.ts

@@ -94,7 +94,7 @@ export function makeUserService(db: SurrealDBService) {
 }
 
 export class UserServiceTag extends Context.Service<UserServiceTag, ReturnType<typeof makeUserService>>()(
-  'UserService',
+  '@lota-sdk/core/UserService',
 ) {}
 
 export const UserServiceLive = Layer.effect(

package/src/services/write-intent-validator.service.ts

@@ -85,7 +85,7 @@ export function makeWriteIntentValidatorService() {
 export class WriteIntentValidatorServiceTag extends Context.Service<
   WriteIntentValidatorServiceTag,
   ReturnType<typeof makeWriteIntentValidatorService>
->()('WriteIntentValidatorService') {}
+>()('@lota-sdk/core/WriteIntentValidatorService') {}
 
 export const WriteIntentValidatorServiceLive = Layer.succeed(
   WriteIntentValidatorServiceTag,