@lota-sdk/core 0.4.12 → 0.4.14

package/src/runtime/runtime-services.ts

@@ -1,10 +1,10 @@
 /**
- * Eagerly resolves the full SDK service surface against a live ManagedRuntime.
+ * Eagerly resolves the host runtime surface against a live ManagedRuntime.
  *
- * The previous implementation used per-property `get` Proxies that re-resolved
- * each tag on every access. This module resolves every tag exactly once when
- * the runtime starts and returns a plain object whose shape matches the
- * `LotaRuntime['services']` + `LotaRuntime['lota']` contracts byte-for-byte.
+ * Services are resolved once at boot, then adapted into plain Promise-returning
+ * host methods. Sync helpers that are intentionally host-visible stay explicit
+ * on the returned objects instead of relying on runtime `Effect.isEffect(...)`
+ * checks or prototype walking.
  */
 
 import type { ChatMessage } from '@lota-sdk/shared'
@@ -16,8 +16,7 @@ import type { ResolvedAgentConfig } from '../config/agent-defaults'
 import { ensureRecordId } from '../db/record-id'
 import type { SurrealDBService } from '../db/service'
 import { TABLES } from '../db/tables'
-import { BadRequestError, NotFoundError } from '../effect/errors'
-import { effectTryPromise } from '../effect/helpers'
+import { BadRequestError, NotFoundError, ServiceError } from '../effect/errors'
 import { AgentConfigServiceTag } from '../effect/services'
 import type { RedisConnectionManager } from '../redis/connection'
 import type { SharedThreadStreamSubscriberTag } from '../redis/stream-context'
@@ -83,10 +82,8 @@ type PromisifiedService<T> = {
 
 type HostSvc<T extends { readonly Service: object }> = PromisifiedService<T['Service']>
 
-export type PromisifiedThreadService = HostSvc<typeof ThreadServiceTag> &
-  Pick<Svc<typeof ThreadServiceTag>, 'withActiveRunLease'>
-export type PromisifiedDocumentChunkService = HostSvc<typeof DocumentChunkServiceTag> &
-  Pick<Svc<typeof DocumentChunkServiceTag>, 'syncVersionedChunks'>
+export type PromisifiedThreadService = HostSvc<typeof ThreadServiceTag>
+export type PromisifiedDocumentChunkService = HostSvc<typeof DocumentChunkServiceTag>
 
 export type ArchiveSdkThread = (
   threadId: Parameters<Svc<typeof ThreadServiceTag>['updateStatus']>[0],
@@ -113,7 +110,7 @@ export interface LotaRuntimeServices {
   generatedDocumentStorageService: HostSvc<typeof GeneratedDocumentStorageServiceTag>
   memoryService: HostSvc<typeof MemoryServiceTag>
   rerankService: HostSvc<typeof RerankServiceTag>
-  verifyMutatingApproval: HostSvc<typeof MutatingApprovalServiceTag>
+  verifyMutatingApproval: PromisifiedValue<Svc<typeof MutatingApprovalServiceTag>>
   organizationService: HostSvc<typeof OrganizationServiceTag>
   organizationMemberService: HostSvc<typeof OrganizationMemberServiceTag>
   userService: HostSvc<typeof UserServiceTag>
@@ -133,13 +130,13 @@ export interface LotaRuntimeServices {
   threadMessageService: HostSvc<typeof ThreadMessageServiceTag>
   threadService: PromisifiedThreadService
   threadTitleService: HostSvc<typeof ThreadTitleServiceTag>
-  createThreadApprovalContinuationStream: typeof createThreadApprovalContinuationStream
-  createThreadNativeToolApprovalStream: typeof createThreadNativeToolApprovalStream
-  createThreadTurnStream: typeof createThreadTurnStream
+  createThreadApprovalContinuationStream: PromisifiedValue<typeof createThreadApprovalContinuationStream>
+  createThreadNativeToolApprovalStream: PromisifiedValue<typeof createThreadNativeToolApprovalStream>
+  createThreadTurnStream: PromisifiedValue<typeof createThreadTurnStream>
   isApprovalContinuationRequest: typeof isApprovalContinuationRequestFn
-  launchBackgroundThreadWork: typeof launchBackgroundThreadWork
-  runThreadTurnInBackground: typeof runThreadTurnInBackground
-  triggerPlanNodeTurn: typeof triggerPlanNodeTurn
+  launchBackgroundThreadWork: PromisifiedValue<typeof launchBackgroundThreadWork>
+  runThreadTurnInBackground: PromisifiedValue<typeof runThreadTurnInBackground>
+  triggerPlanNodeTurn: PromisifiedValue<typeof triggerPlanNodeTurn>
 }
 
 export interface LotaRuntimeLota {
@@ -212,51 +209,33 @@ interface RuntimeServiceSurface {
 }
 
 /**
- * Build a Promise-method shell around a service whose methods return Effects.
- *
- * Non-function properties and non-Effect-returning methods pass through
- * unchanged. Each Effect-returning method is wrapped so callers receive a
- * Promise resolved by the supplied `managedRuntime`, keeping the host-facing
- * API stable while the SDK internals stay pure Effect.
+ * Host-facing runtime services are plain object literals, so we adapt only the
+ * explicit method table we pass in here. Sync helpers stay on the raw object
+ * and are reattached explicitly at the call site.
  */
-function promisifyServiceMethods<T extends object>(
-  managedRuntime: SdkManagedRuntime,
+type EffectMethod = (...args: Array<never>) => Effect.Effect<unknown, object, object>
+
+function bindEffectMethod<TMethod extends EffectMethod>(
+  runPromise: <A, E extends object, R extends object>(effect: Effect.Effect<A, E, R>) => Promise<A>,
+  method: TMethod,
+): PromisifiedValue<TMethod> {
+  return ((...args: Parameters<TMethod>) => runPromise(method(...args))) as PromisifiedValue<TMethod>
+}
+
+function bindEffectService<T extends { [K in keyof T]: EffectMethod }>(
+  runPromise: <A, E extends object, R extends object>(effect: Effect.Effect<A, E, R>) => Promise<A>,
   rawService: T,
-): PromisifiedService<T> {
-  const out: Record<string, unknown> = {}
-  // Walk own + prototype chain so class-based Context.Service implementations
-  // whose methods live on the prototype get wrapped too. Object.entries alone
-  // only sees own enumerable string keys — silent miss for class methods.
-  let proto: object | null = rawService
-  while (proto && proto !== Object.prototype) {
-    for (const key of Object.getOwnPropertyNames(proto)) {
-      if (key === 'constructor' || key in out) continue
-      const descriptor = Object.getOwnPropertyDescriptor(proto, key)
-      if (!descriptor || typeof descriptor.value !== 'function') continue
-      const method = descriptor.value as (...args: unknown[]) => unknown
-      out[key] = (...args: unknown[]) => {
-        const result = method.apply(rawService, args)
-        return Effect.isEffect(result)
-          ? managedRuntime.runPromise(result as Effect.Effect<unknown, unknown, never>)
-          : result
-      }
-    }
-    proto = Object.getPrototypeOf(proto)
-  }
-  // Copy non-function own properties not already set.
-  for (const [key, value] of Object.entries(rawService)) {
-    if (!(key in out)) out[key] = value
+): { [K in keyof T]: PromisifiedValue<T[K]> } {
+  const bound = {} as { [K in keyof T]: PromisifiedValue<T[K]> }
+  for (const key of Object.keys(rawService) as Array<keyof T>) {
+    bound[key] = bindEffectMethod(runPromise, rawService[key]) as { [K in keyof T]: PromisifiedValue<T[K]> }[typeof key]
   }
-  return out as PromisifiedService<T>
+  return bound
 }
 
 /**
- * Eagerly resolve the full service surface exactly once.
- *
- * Effect-returning service methods are wrapped into plain Promise-returning
- * functions by `promisifyServiceMethods`, which means callers can `await`
- * them directly. The SDK retains the raw Effect-aware services internally
- * for composition within `Effect.gen` blocks.
+ * Eagerly resolve the full service surface exactly once and adapt it into the
+ * public Promise-based runtime boundary.
  */
 export function buildRuntimeServiceSurface(input: BuildRuntimeServiceSurfaceInput): RuntimeServiceSurface {
   const { managedRuntime, db, redisManager, threadTurnService, socialChatHistoryService } = input
@@ -265,58 +244,155 @@ export function buildRuntimeServiceSurface(input: BuildRuntimeServiceSurfaceInpu
   // The explicit `any` for R lets this helper accept effects with residual
   // service requirements (e.g. `ThreadTurnServiceTag | LotaQueuesServiceTag`)
   // without forcing each call site to provide them.
-  const runPromise = <A, E, R>(effect: Effect.Effect<A, E, R>): Promise<A> =>
+  const runPromise = <A, E extends object, R extends object>(effect: Effect.Effect<A, E, R>): Promise<A> =>
     managedRuntime.runPromise(effect as unknown as Effect.Effect<A, E, never>)
 
   const resolveRaw = <I, T>(tag: Context.Key<I, T>): T => managedRuntime.runSync(Effect.service(tag))
-  const resolveOnce = <I, T extends object>(tag: Context.Key<I, T>): PromisifiedService<T> =>
-    promisifyServiceMethods(managedRuntime, resolveRaw(tag))
 
   // ── Resolve every tag eagerly. Each binding is a plain value from here. ──
-  const agentActivityService = resolveOnce(AgentActivityServiceTag)
-  const artifactService = resolveOnce(ArtifactServiceTag)
-  const attachmentService = resolveOnce(AttachmentServiceTag)
-  const autonomousJobService = resolveOnce(AutonomousJobServiceTag)
-  const contextCompactionService = resolveOnce(ContextCompactionServiceTag)
-  const documentChunkService = resolveOnce(DocumentChunkServiceTag) as PromisifiedDocumentChunkService
-  const generatedDocumentStorageService = resolveOnce(GeneratedDocumentStorageServiceTag)
-  const memoryService = resolveOnce(MemoryServiceTag)
-  const rerankService = resolveOnce(RerankServiceTag)
-  const verifyMutatingApproval = resolveOnce(MutatingApprovalServiceTag)
-  const organizationService = resolveOnce(OrganizationServiceTag)
-  const organizationMemberService = resolveOnce(OrganizationMemberServiceTag)
-  const userService = resolveOnce(UserServiceTag)
-  const recentActivityService = resolveOnce(RecentActivityServiceTag)
-  const recentActivityTitleService = resolveOnce(RecentActivityTitleServiceTag)
-  const executionPlanService = resolveOnce(ExecutionPlanServiceTag)
-  const planDeadlineService = resolveOnce(PlanDeadlineServiceTag)
-  const planExecutorService = resolveOnce(PlanExecutorServiceTag)
-  const planRunService = resolveOnce(PlanRunServiceTag)
-  const planTemplateService = resolveOnce(PlanTemplateServiceTag)
-  const planCoordinationService = resolveOnce(PlanCoordinationServiceTag)
-  const planSchedulerService = resolveOnce(PlanSchedulerServiceTag)
-  const planAgentHeartbeatService = resolveOnce(PlanAgentHeartbeatServiceTag)
-  const planAgentQueryService = resolveOnce(PlanAgentQueryServiceTag)
-  const planCycleService = resolveOnce(PlanCycleServiceTag)
-  const threadMessageService = resolveOnce(ThreadMessageServiceTag)
-  const threadService = resolveOnce(ThreadServiceTag) as PromisifiedThreadService
-  const threadTitleService = resolveOnce(ThreadTitleServiceTag)
+  const agentActivityService = bindEffectService(runPromise, resolveRaw(AgentActivityServiceTag))
+  const artifactService = bindEffectService(runPromise, resolveRaw(ArtifactServiceTag))
+  const attachmentServiceRaw = resolveRaw(AttachmentServiceTag)
+  const attachmentService = {
+    extractStoredAttachmentText: (...args) => runPromise(attachmentServiceRaw.extractStoredAttachmentText(...args)),
+    extractStoredAttachmentPages: (...args) => runPromise(attachmentServiceRaw.extractStoredAttachmentPages(...args)),
+    readFilePartsFromUpload: (...args) => runPromise(attachmentServiceRaw.readFilePartsFromUpload(...args)),
+    writeOrganizationDocument: (...args) => runPromise(attachmentServiceRaw.writeOrganizationDocument(...args)),
+    uploadOrganizationDocument: (...args) => runPromise(attachmentServiceRaw.uploadOrganizationDocument(...args)),
+    uploadThreadAttachment: (...args) => runPromise(attachmentServiceRaw.uploadThreadAttachment(...args)),
+    hydrateSignedFileUrlsInMessageParts: (...args) => attachmentServiceRaw.hydrateSignedFileUrlsInMessageParts(...args),
+    listReadableUploadsFromMessages: (...args) => attachmentServiceRaw.listReadableUploadsFromMessages(...args),
+    getAttachmentUrl: (...args) => attachmentServiceRaw.getAttachmentUrl(...args),
+  } satisfies HostSvc<typeof AttachmentServiceTag>
+  const autonomousJobServiceRaw = resolveRaw(AutonomousJobServiceTag)
+  const { computeNextRunAt, ...autonomousJobEffectMethods } = autonomousJobServiceRaw
+  const autonomousJobService = {
+    ...bindEffectService(runPromise, autonomousJobEffectMethods),
+    computeNextRunAt,
+  } satisfies HostSvc<typeof AutonomousJobServiceTag>
+  const contextCompactionServiceRaw = resolveRaw(ContextCompactionServiceTag)
+  const contextCompactionService = {
+    compactThreadHistory: (...args) => runPromise(contextCompactionServiceRaw.compactThreadHistory(...args)),
+    compactMemoryBlock: (...args) => runPromise(contextCompactionServiceRaw.compactMemoryBlock(...args)),
+    createSummaryMessage: (...args) => contextCompactionServiceRaw.createSummaryMessage(...args),
+    estimateThreshold: (...args) => contextCompactionServiceRaw.estimateThreshold(...args),
+    shouldCompactHistory: (...args) => contextCompactionServiceRaw.shouldCompactHistory(...args),
+  } satisfies HostSvc<typeof ContextCompactionServiceTag>
+  const documentChunkServiceRaw = resolveRaw(DocumentChunkServiceTag)
+  const documentChunkService = {
+    syncVersionedChunks: (...args) => runPromise(documentChunkServiceRaw.syncVersionedChunks(...args)),
+    buildChunks: (...args) => documentChunkServiceRaw.buildChunks(...args),
+    hashContent: (...args) => documentChunkServiceRaw.hashContent(...args),
+    estimateTokenCount: (...args) => documentChunkServiceRaw.estimateTokenCount(...args),
+    embedQuery: (...args) => documentChunkServiceRaw.embedQuery(...args),
+  } satisfies PromisifiedDocumentChunkService
+  const generatedDocumentStorageService = bindEffectService(runPromise, resolveRaw(GeneratedDocumentStorageServiceTag))
+  const memoryService = bindEffectService(runPromise, resolveRaw(MemoryServiceTag))
+  const rerankService = bindEffectService(runPromise, resolveRaw(RerankServiceTag))
+  const verifyMutatingApproval = bindEffectMethod(runPromise, resolveRaw(MutatingApprovalServiceTag))
+  const organizationService = bindEffectService(runPromise, resolveRaw(OrganizationServiceTag))
+  const organizationMemberService = bindEffectService(runPromise, resolveRaw(OrganizationMemberServiceTag))
+  const userService = bindEffectService(runPromise, resolveRaw(UserServiceTag))
+  const recentActivityServiceRaw = resolveRaw(RecentActivityServiceTag)
+  const recentActivityService = {
+    recordEvent: (...args) => runPromise(recentActivityServiceRaw.recordEvent(...args)),
+    recordEvents: (...args) => runPromise(recentActivityServiceRaw.recordEvents(...args)),
+    listRecentActivities: (...args) => runPromise(recentActivityServiceRaw.listRecentActivities(...args)),
+    listRecentEvents: (...args) => runPromise(recentActivityServiceRaw.listRecentEvents(...args)),
+    getRecentActivityById: (...args) => runPromise(recentActivityServiceRaw.getRecentActivityById(...args)),
+    refineTitle: (...args) => runPromise(recentActivityServiceRaw.refineTitle(...args)),
+    getRefinementCandidate: (...args) => runPromise(recentActivityServiceRaw.getRefinementCandidate(...args)),
+    isMeaningfulRefinementCandidate: (...args) => recentActivityServiceRaw.isMeaningfulRefinementCandidate(...args),
+    isAgentTitleUseful: (...args) => recentActivityServiceRaw.isAgentTitleUseful(...args),
+  } satisfies HostSvc<typeof RecentActivityServiceTag>
+  const recentActivityTitleService = bindEffectService(runPromise, resolveRaw(RecentActivityTitleServiceTag))
+  const executionPlanService = bindEffectService(runPromise, resolveRaw(ExecutionPlanServiceTag))
+  const planDeadlineServiceRaw = resolveRaw(PlanDeadlineServiceTag)
+  const planDeadlineService = {
+    checkDeadlines: (...args) => runPromise(planDeadlineServiceRaw.checkDeadlines(...args)),
+    recoverDeadlineChecks: (...args) => runPromise(planDeadlineServiceRaw.recoverDeadlineChecks(...args)),
+    applyDeadlineMissAction: (...args) => runPromise(planDeadlineServiceRaw.applyDeadlineMissAction(...args)),
+    maybeEmitEscalationPolicyEvent: (...args) =>
+      runPromise(planDeadlineServiceRaw.maybeEmitEscalationPolicyEvent(...args)),
+    emitDeadlineEvent: (...args) => runPromise(planDeadlineServiceRaw.emitDeadlineEvent(...args)),
+    enqueueDeadlineCheck: (...args) => runPromise(planDeadlineServiceRaw.enqueueDeadlineCheck(...args)),
+    evaluateDeadline: (...args) => planDeadlineServiceRaw.evaluateDeadline(...args),
+  } satisfies HostSvc<typeof PlanDeadlineServiceTag>
+  const planExecutorServiceRaw = resolveRaw(PlanExecutorServiceTag)
+  const planExecutorService = {
+    submitNodeResult: (...args) => runPromise(planExecutorServiceRaw.submitNodeResult(...args)),
+    submitHumanNodeResponse: (...args) => runPromise(planExecutorServiceRaw.submitHumanNodeResponse(...args)),
+    resumeRun: (...args) => runPromise(planExecutorServiceRaw.resumeRun(...args)),
+    transitionNodeToRunning: (...args) => runPromise(planExecutorServiceRaw.transitionNodeToRunning(...args)),
+    blockNodeOnDispatchFailure: (...args) => runPromise(planExecutorServiceRaw.blockNodeOnDispatchFailure(...args)),
+    promoteDelayedNode: (...args) => runPromise(planExecutorServiceRaw.promoteDelayedNode(...args)),
+    syncRunGraph: (...args) => runPromise(planExecutorServiceRaw.syncRunGraph(...args)),
+    resolveFailureAction: (...args) => planExecutorServiceRaw.resolveFailureAction(...args),
+    buildResolvedInput: (...args) => runPromise(planExecutorServiceRaw.buildResolvedInput(...args)),
+  } satisfies HostSvc<typeof PlanExecutorServiceTag>
+  const planRunService = bindEffectService(runPromise, resolveRaw(PlanRunServiceTag))
+  const planTemplateService = bindEffectService(runPromise, resolveRaw(PlanTemplateServiceTag))
+  const planCoordinationServiceRaw = resolveRaw(PlanCoordinationServiceTag)
+  const { isStale, validateNoCycles, ...planCoordinationEffectMethods } = planCoordinationServiceRaw
+  const planCoordinationService = {
+    ...bindEffectService(runPromise, planCoordinationEffectMethods),
+    isStale,
+    validateNoCycles,
+  } satisfies HostSvc<typeof PlanCoordinationServiceTag>
+  const planSchedulerServiceRaw = resolveRaw(PlanSchedulerServiceTag)
+  const planSchedulerService = {
+    createSchedule: (...args) => runPromise(planSchedulerServiceRaw.createSchedule(...args)),
+    fireScheduleById: (...args) => runPromise(planSchedulerServiceRaw.fireScheduleById(...args)),
+    fireSchedule: (...args) => runPromise(planSchedulerServiceRaw.fireSchedule(...args)),
+    recoverActiveSchedules: (...args) => runPromise(planSchedulerServiceRaw.recoverActiveSchedules(...args)),
+    cancelSchedule: (...args) => runPromise(planSchedulerServiceRaw.cancelSchedule(...args)),
+    pauseSchedule: (...args) => runPromise(planSchedulerServiceRaw.pauseSchedule(...args)),
+    resumeSchedule: (...args) => runPromise(planSchedulerServiceRaw.resumeSchedule(...args)),
+    listSchedules: (...args) => runPromise(planSchedulerServiceRaw.listSchedules(...args)),
+    computeNextFireAt: (...args) => planSchedulerServiceRaw.computeNextFireAt(...args),
+  } satisfies HostSvc<typeof PlanSchedulerServiceTag>
+  const planAgentHeartbeatService = bindEffectService(runPromise, resolveRaw(PlanAgentHeartbeatServiceTag))
+  const planAgentQueryService = bindEffectService(runPromise, resolveRaw(PlanAgentQueryServiceTag))
+  const planCycleServiceRaw = resolveRaw(PlanCycleServiceTag)
+  const planCycleService = {
+    createCycle: (...args) => runPromise(planCycleServiceRaw.createCycle(...args)),
+    advanceCycle: (...args) => runPromise(planCycleServiceRaw.advanceCycle(...args)),
+    cancelCycle: (...args) => runPromise(planCycleServiceRaw.cancelCycle(...args)),
+    pauseCycle: (...args) => runPromise(planCycleServiceRaw.pauseCycle(...args)),
+    resumeCycle: (...args) => runPromise(planCycleServiceRaw.resumeCycle(...args)),
+    listCycles: (...args) => runPromise(planCycleServiceRaw.listCycles(...args)),
+    getCycle: (...args) => runPromise(planCycleServiceRaw.getCycle(...args)),
+    cycleScheduleToSpec: (...args) => planCycleServiceRaw.cycleScheduleToSpec(...args),
+    buildCarryForwardDraft: (...args) => planCycleServiceRaw.buildCarryForwardDraft(...args),
+  } satisfies HostSvc<typeof PlanCycleServiceTag>
+  const threadMessageServiceRaw = resolveRaw(ThreadMessageServiceTag)
+  const threadMessageService = bindEffectService(runPromise, threadMessageServiceRaw)
+  const threadServiceRaw = resolveRaw(ThreadServiceTag)
+  const { formatMemoryBlockForPrompt, toPublicThread, ...threadServiceEffectMethods } = threadServiceRaw
+  const threadService = {
+    ...bindEffectService(runPromise, threadServiceEffectMethods),
+    formatMemoryBlockForPrompt,
+    toPublicThread,
+  } satisfies PromisifiedThreadService
+  const threadTitleService = bindEffectService(runPromise, resolveRaw(ThreadTitleServiceTag))
   const firecrawl = resolveRaw(FirecrawlTag)
   const agentConfig = resolveRaw(AgentConfigServiceTag)
 
   // ── Resolve the raw service instances once for inline Effect composition ──
-  // `promisifyServiceMethods` (used above) converts Effect-returning methods
-  // into Promise-returning shims. The `getMessage`/`sendMessage`/
-  // `continueApproval` wrappers below need the raw Effect-returning
-  // signatures so they can `yield*` service methods inside `Effect.gen`.
-  const threadMessageServiceRaw = resolveRaw(ThreadMessageServiceTag)
-  const threadServiceRaw = resolveRaw(ThreadServiceTag)
+  // `getMessage` / `sendMessage` / `continueApproval` still compose multiple
+  // service calls in a single fiber, so they keep the raw Effect methods here.
 
   const services: LotaRuntimeServices = {
     agentConfig,
     database: db,
     redis: redisManager,
-    closeRedisConnection: () => runPromise(effectTryPromise(() => redisManager.closeConnection())),
+    closeRedisConnection: () =>
+      runPromise(
+        Effect.tryPromise({
+          try: () => redisManager.closeConnection(),
+          catch: (cause) => new ServiceError({ message: 'Failed to close Redis connection.', cause }),
+        }),
+      ),
     firecrawl,
     agentActivityService,
     artifactService,
@@ -347,14 +423,16 @@ export function buildRuntimeServiceSurface(input: BuildRuntimeServiceSurfaceInpu
     threadMessageService,
     threadService,
     threadTitleService,
-    createThreadApprovalContinuationStream: (...args) =>
-      threadTurnService.createThreadApprovalContinuationStream(...args),
-    createThreadNativeToolApprovalStream: (...args) => threadTurnService.createThreadNativeToolApprovalStream(...args),
-    createThreadTurnStream: (...args) => threadTurnService.createThreadTurnStream(...args),
+    createThreadApprovalContinuationStream: (params: Parameters<typeof createThreadApprovalContinuationStream>[0]) =>
+      runPromise(threadTurnService.createThreadApprovalContinuationStream(params)),
+    createThreadNativeToolApprovalStream: (params: Parameters<typeof createThreadNativeToolApprovalStream>[0]) =>
+      runPromise(threadTurnService.createThreadNativeToolApprovalStream(params)),
+    createThreadTurnStream: (params: Parameters<typeof createThreadTurnStream>[0]) =>
+      runPromise(threadTurnService.createThreadTurnStream(params)),
     isApprovalContinuationRequest: isApprovalContinuationRequestFn,
-    launchBackgroundThreadWork: (...args) => threadTurnService.launchBackgroundThreadWork(...args),
-    runThreadTurnInBackground: (...args) => threadTurnService.runThreadTurnInBackground(...args),
-    triggerPlanNodeTurn: (...args) => threadTurnService.triggerPlanNodeTurn(...args),
+    launchBackgroundThreadWork: (params) => runPromise(threadTurnService.launchBackgroundThreadWork(params)),
+    runThreadTurnInBackground: (params) => runPromise(threadTurnService.runThreadTurnInBackground(params)),
+    triggerPlanNodeTurn: (params) => runPromise(threadTurnService.triggerPlanNodeTurn(params)),
   }
 
   const lota: LotaRuntimeLota = {

package/src/runtime/runtime-worker-registry.ts

@@ -1,4 +1,4 @@
-import type { Context } from 'effect'
+import type { Context, Effect } from 'effect'
 
 import type { DatabaseServiceTag } from '../effect/services'
 import type { LotaQueuesRuntime } from '../queues/queues.service'
@@ -19,6 +19,7 @@ type StartWorkerResult = ReturnType<LotaQueuesRuntime['autonomousJob']['startWor
 
 export interface LotaRuntimeWorkerServices {
   databaseService: Context.Service.Shape<typeof DatabaseServiceTag>
+  runPromise: <A, E, R>(effect: Effect.Effect<A, E, R>) => Promise<A>
   threadService: Context.Service.Shape<typeof ThreadServiceTag>
   contextCompactionService: Context.Service.Shape<typeof ContextCompactionServiceTag>
   autonomousJobService: Context.Service.Shape<typeof AutonomousJobServiceTag>
@@ -102,6 +103,7 @@ export function buildRuntimeWorkerRegistry(
           registerSignals: options.registerSignals,
           deps: {
             databaseService: services.databaseService,
+            runPromise: services.runPromise,
             planSchedulerService: services.planSchedulerService,
             planDeadlineService: services.planDeadlineService,
             planExecutorService: services.planExecutorService,

package/src/runtime/social-chat/social-chat-agent-runner.ts

@@ -10,7 +10,7 @@ interface ExecutableToolDefinition {
 }
 
 class SocialChatAgentRunnerError extends Schema.TaggedErrorClass<SocialChatAgentRunnerError>()(
-  'SocialChatAgentRunnerError',
+  '@lota-sdk/core/SocialChatAgentRunnerError',
   { message: Schema.String, cause: Schema.optional(Schema.Defect) },
 ) {}
 

package/src/runtime/social-chat/social-chat-history.ts

@@ -3,7 +3,7 @@ import type { Message, Thread } from 'chat'
 import { Schema, Effect } from 'effect'
 
 import type { ResolvedAgentConfig } from '../../config/agent-defaults'
-import { iterateEffect } from '../../effect/helpers'
+import { ERROR_TAGS } from '../../effect/errors'
 import type {
   SocialChatHistoryMessage,
   SocialChatHistoryMetadata,
@@ -11,10 +11,10 @@ import type {
 } from '../../services/social-chat-history.service'
 import { toHistoryMessages, toOptionalTrimmedString } from '../thread-chat-helpers'
 
-class SocialChatHistoryError extends Schema.TaggedErrorClass<SocialChatHistoryError>()('SocialChatHistoryError', {
-  message: Schema.String,
-  cause: Schema.optional(Schema.Defect),
-}) {}
+class SocialChatHistoryError extends Schema.TaggedErrorClass<SocialChatHistoryError>()(
+  ERROR_TAGS.SocialChatHistoryError,
+  { message: Schema.String, cause: Schema.optional(Schema.Defect) },
+) {}
 
 export function readSlackAuthorName(message: Message): string | undefined {
   return (
@@ -112,24 +112,27 @@ export function collectThreadMessages(thread: Thread, incomingMessage: Message):
       Effect.gen(function* () {
         const iterator = thread.allMessages[Symbol.asyncIterator]()
 
-        const collected = yield* iterateEffect<{ messages: Message[]; done: boolean }, SocialChatHistoryError, never>(
-          { messages: [], done: false },
-          {
-            while: (state) => !state.done,
-            body: (state) =>
-              Effect.tryPromise({
+        const collectMessages = (state: {
+          messages: Message[]
+          done: boolean
+        }): Effect.Effect<{ messages: Message[]; done: boolean }, SocialChatHistoryError> =>
+          state.done
+            ? Effect.succeed(state)
+            : Effect.tryPromise({
                 try: () => iterator.next(),
                 catch: (error: unknown) =>
                   new SocialChatHistoryError({ message: 'Failed to read thread messages', cause: error }),
               }).pipe(
-                Effect.map((next) =>
-                  next.done
-                    ? { messages: state.messages, done: true }
-                    : { messages: [...state.messages, next.value], done: false },
+                Effect.flatMap((next) =>
+                  collectMessages(
+                    next.done
+                      ? { messages: state.messages, done: true }
+                      : { messages: [...state.messages, next.value], done: false },
+                  ),
                 ),
-              ),
-          },
-        )
+              )
+
+        const collected = yield* collectMessages({ messages: [] as Message[], done: false })
 
         return collected.messages.length > 0
           ? collected.messages