@lota-sdk/core 0.4.13 → 0.4.15

package/src/runtime/runtime-lifecycle.ts

@@ -3,18 +3,15 @@
  *
  * The plugin connect/disconnect helpers run inside the supplied
  * `ManagedRuntime` so spans, logging, and layer context stay consistent with
- * the rest of the SDK runtime. `createRuntimeDisconnect` instead drives the
- * shutdown sequence through the caller-supplied `runPromiseWithCurrentContext`
- * (currently `Effect.runPromiseWith(Context.empty())`), which intentionally
- * does not preserve the SDK runtime context — by then the runtime is being
- * torn down.
+ * the rest of the SDK runtime. Disconnect runs its teardown sequence as a
+ * plain `Effect.runPromise` — the services it yields have no layer
+ * requirements because they are closure-captured shutdown thunks.
  */
 
 import type { ManagedRuntime } from 'effect'
 import { Effect } from 'effect'
 
-import { clearAiGatewayRuntime } from '../ai-gateway/ai-gateway'
-import { effectTryPromise } from '../effect/helpers'
+import { RuntimeLifecycleError } from '../effect/errors'
 import type { LotaPlugin } from './plugin-types'
 
 // eslint-disable-next-line typescript-eslint/no-explicit-any -- ManagedRuntime is contravariant in R; `any` is the only valid wildcard
@@ -24,6 +21,26 @@ function getPluginLifecycleServices(plugin: LotaPlugin): Record<string, unknown>
   return plugin.services
 }
 
+function toRuntimeLifecycleError(
+  operation: RuntimeLifecycleError['operation'],
+  cause: unknown,
+  pluginName?: string,
+): RuntimeLifecycleError {
+  const detail = pluginName ? ` "${pluginName}"` : ''
+  const action =
+    operation === 'connect-plugin-database'
+      ? `connect plugin database${detail}`
+      : operation === 'disconnect-plugin-database'
+        ? `disconnect plugin database${detail}`
+        : operation === 'shutdown-social-chat'
+          ? 'shut down social chat'
+          : operation === 'disconnect-plugin-databases'
+            ? 'disconnect plugin databases'
+            : 'dispose managed runtime'
+
+  return new RuntimeLifecycleError({ operation, message: `Failed to ${action}.`, cause })
+}
+
 /**
  * Build a plugin database connector that iterates the configured plugins and
  * calls each `services.connectDatabase()` once, tracking completion in
@@ -49,7 +66,10 @@ export function createPluginDatabaseConnector(
           }
 
           const connectDatabaseFn = connectDatabase as (this: typeof services) => Promise<void>
-          yield* effectTryPromise(() => connectDatabaseFn.call(services))
+          yield* Effect.tryPromise({
+            try: () => connectDatabaseFn.call(services),
+            catch: (cause) => toRuntimeLifecycleError('connect-plugin-database', cause, pluginName),
+          })
           connectedPluginDatabases.add(pluginName)
         }
       }),
@@ -82,7 +102,10 @@ export function createPluginDatabaseDisconnector(
           }
 
           const disconnectDatabaseFn = disconnectDatabase as (this: typeof services) => Promise<void>
-          yield* effectTryPromise(() => disconnectDatabaseFn.call(services))
+          yield* Effect.tryPromise({
+            try: () => disconnectDatabaseFn.call(services),
+            catch: (cause) => toRuntimeLifecycleError('disconnect-plugin-database', cause, pluginName),
+          })
           connectedPluginDatabases.delete(pluginName)
         }
       }),
@@ -91,7 +114,6 @@ export function createPluginDatabaseDisconnector(
 
 interface CreateDisconnectInput {
   managedRuntime: SdkManagedRuntime
-  runPromiseWithCurrentContext: <A, E>(effect: Effect.Effect<A, E, never>) => Promise<A>
   socialChatShutdown: () => Promise<void>
   disconnectPluginDatabases: () => Promise<void>
 }
@@ -100,9 +122,15 @@ interface CreateDisconnectInput {
  * Compose the runtime `disconnect()` function. The returned function is
  * idempotent: the first call starts the shutdown sequence, subsequent calls
  * return the same in-flight promise.
+ *
+ * Teardown order:
+ *   1. socialChat shutdown (user-facing bots must go quiet first)
+ *   2. plugin database disconnect (release external connections)
+ *   3. clear AI gateway runtime slot BEFORE dispose (no new fibers)
+ *   4. managedRuntime.dispose() (release all scoped layer resources)
  */
 export function createRuntimeDisconnect(input: CreateDisconnectInput): () => Promise<void> {
-  const { managedRuntime, runPromiseWithCurrentContext, socialChatShutdown, disconnectPluginDatabases } = input
+  const { managedRuntime, socialChatShutdown, disconnectPluginDatabases } = input
 
   let disconnectPromise: Promise<void> | null = null
 
@@ -111,12 +139,24 @@ export function createRuntimeDisconnect(input: CreateDisconnectInput): () => Pro
       return disconnectPromise
     }
 
-    disconnectPromise = runPromiseWithCurrentContext(
+    disconnectPromise = Effect.runPromise(
       Effect.gen(function* () {
-        yield* Effect.ignore(effectTryPromise(() => socialChatShutdown()))
-        yield* Effect.ignore(effectTryPromise(() => disconnectPluginDatabases()))
-        yield* effectTryPromise(() => managedRuntime.dispose())
-        yield* Effect.sync(() => clearAiGatewayRuntime())
+        yield* Effect.ignore(
+          Effect.tryPromise({
+            try: () => socialChatShutdown(),
+            catch: (cause) => toRuntimeLifecycleError('shutdown-social-chat', cause),
+          }),
+        )
+        yield* Effect.ignore(
+          Effect.tryPromise({
+            try: () => disconnectPluginDatabases(),
+            catch: (cause) => toRuntimeLifecycleError('disconnect-plugin-databases', cause),
+          }),
+        )
+        yield* Effect.tryPromise({
+          try: () => managedRuntime.dispose(),
+          catch: (cause) => toRuntimeLifecycleError('dispose-managed-runtime', cause),
+        })
       }),
     )
     return disconnectPromise

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