@lota-sdk/core 0.4.9 → 0.4.10

package/src/redis/connection.ts

@@ -1,8 +1,8 @@
-import { Duration, Effect, Exit, Fiber } from 'effect'
+import { Duration, Effect, Exit, Scope } from 'effect'
 import IORedis from 'ioredis'
 import type { RedisOptions } from 'ioredis'
 
-import { ConfigurationError } from '../effect/errors'
+import { RedisError } from '../effect/errors'
 import { effectTryServicePromise } from '../effect/helpers'
 import { getErrorMessage } from '../utils/errors'
 
@@ -32,8 +32,6 @@ const REDIS_RETRY_STEP_MS = 50
 const REDIS_RETRY_MAX_DELAY_MS = 2000
 const REDIS_CONNECT_TIMEOUT_MS = 10_000
 
-type HealthCheckFiber = ReturnType<typeof Effect.runFork>
-
 export const DEFAULT_REDIS_OPTIONS: RedisOptions = {
   maxRetriesPerRequest: null,
   enableReadyCheck: true,
@@ -57,181 +55,200 @@ function log(logger: RedisConnectionLogger | undefined, level: keyof RedisConnec
   }
 }
 
-class RedisConnectionManagerImpl implements RedisConnectionManager {
-  private redis: IORedis | null = null
-  private isHealthy = false
-  private isInitialized = false
-  private isClosing = false
-  private isHealthCheckRunning = false
-  private healthChecksActive = false
-  private healthCheckFiber: HealthCheckFiber | null = null
-
-  constructor(private readonly options: CreateRedisConnectionManagerOptions) {
-    this.initializeConnection()
-  }
-
-  private initializeConnection(): void {
-    if (this.isInitialized) {
-      return
-    }
-
-    this.isInitialized = true
-
-    try {
-      const redisOptions = this.options.redisOptions ?? DEFAULT_REDIS_OPTIONS
-      this.redis = new IORedis(this.options.url, redisOptions)
-      this.setupEventHandlers()
-      this.startHealthChecks()
-    } catch (error) {
-      log(this.options.logger, 'error', `Failed to initialize Redis connection: ${getErrorMessage(error)}`)
-    }
-  }
-
-  private setupEventHandlers(): void {
-    if (!this.redis) return
-
-    this.redis.on('connect', () => {
-      log(this.options.logger, 'info', 'Redis connected')
-      this.isHealthy = true
-    })
-
-    this.redis.on('ready', () => {
-      log(this.options.logger, 'info', 'Redis ready')
-      this.isHealthy = true
-    })
-
-    this.redis.on('error', (error: Error) => {
-      log(this.options.logger, 'error', `Redis error: ${error.message}`)
-      this.isHealthy = false
-    })
-
-    this.redis.on('close', () => {
-      log(
-        this.options.logger,
-        this.isClosing ? 'info' : 'warn',
-        this.isClosing ? 'Redis connection closed during shutdown' : 'Redis connection closed',
-      )
-      this.isHealthy = false
-    })
-
-    this.redis.on('reconnecting', () => {
-      log(this.options.logger, 'info', 'Redis reconnecting...')
-    })
-
-    this.redis.on('end', () => {
-      log(
-        this.options.logger,
-        this.isClosing ? 'info' : 'warn',
-        this.isClosing ? 'Redis connection ended during shutdown' : 'Redis connection ended',
-      )
-      this.isHealthy = false
-    })
-  }
+interface ManagerState {
+  isHealthy: boolean
+  isClosing: boolean
+}
 
-  private startHealthChecks(): void {
-    if (this.healthChecksActive || this.healthCheckFiber) {
-      return
-    }
+/**
+ * Build the IORedis client + listeners as an `Effect.acquireRelease`. Each
+ * handler is held as a const ref so the release step can pass the same
+ * function to `client.off(...)`, then `quit()` (falling back to
+ * `disconnect()`) the client. Prevents tracked-handler leaks on disposal.
+ */
+function acquireRedisClient(
+  options: CreateRedisConnectionManagerOptions,
+  state: ManagerState,
+): Effect.Effect<IORedis, RedisError, Scope.Scope> {
+  return Effect.acquireRelease(
+    Effect.try({
+      try: () => {
+        const redisOptions = options.redisOptions ?? DEFAULT_REDIS_OPTIONS
+        const client = new IORedis(options.url, redisOptions)
+
+        const onConnect = () => {
+          log(options.logger, 'info', 'Redis connected')
+          state.isHealthy = true
+        }
+        const onReady = () => {
+          log(options.logger, 'info', 'Redis ready')
+          state.isHealthy = true
+        }
+        const onError = (error: Error) => {
+          log(options.logger, 'error', `Redis error: ${error.message}`)
+          state.isHealthy = false
+        }
+        const onClose = () => {
+          log(
+            options.logger,
+            state.isClosing ? 'info' : 'warn',
+            state.isClosing ? 'Redis connection closed during shutdown' : 'Redis connection closed',
+          )
+          state.isHealthy = false
+        }
+        const onReconnecting = () => {
+          log(options.logger, 'info', 'Redis reconnecting...')
+        }
+        const onEnd = () => {
+          log(
+            options.logger,
+            state.isClosing ? 'info' : 'warn',
+            state.isClosing ? 'Redis connection ended during shutdown' : 'Redis connection ended',
+          )
+          state.isHealthy = false
+        }
 
-    this.healthChecksActive = true
-    const intervalMs = this.options.healthCheckIntervalMs ?? DEFAULT_HEALTH_CHECK_INTERVAL_MS
-    const logger = this.options.logger
-    const isHealthChecksActive = () => this.healthChecksActive
-    const isHealthCheckRunning = () => this.isHealthCheckRunning
-    const setHealthCheckRunning = (value: boolean) => {
-      this.isHealthCheckRunning = value
-    }
-    const getRedis = () => this.redis
-    const setHealthy = (value: boolean) => {
-      this.isHealthy = value
-    }
+        client.on('connect', onConnect)
+        client.on('ready', onReady)
+        client.on('error', onError)
+        client.on('close', onClose)
+        client.on('reconnecting', onReconnecting)
+        client.on('end', onEnd)
+
+        // Carry the handler refs alongside the client so the release closure
+        // can detach exactly what was attached.
+        ;(client as ClientWithHandlers).__lotaHandlers = {
+          connect: onConnect,
+          ready: onReady,
+          error: onError,
+          close: onClose,
+          reconnecting: onReconnecting,
+          end: onEnd,
+        }
 
-    this.healthCheckFiber = Effect.runFork(
+        return client
+      },
+      catch: (cause) =>
+        new RedisError({ message: `Failed to initialize Redis connection: ${getErrorMessage(cause)}`, cause }),
+    }),
+    (client) =>
       Effect.gen(function* () {
-        for (;;) {
-          yield* Effect.sleep(Duration.millis(intervalMs))
-          if (!isHealthChecksActive()) break
-          if (isHealthCheckRunning()) continue
-
-          setHealthCheckRunning(true)
-          try {
-            const redis = getRedis()
-            if (redis && redis.status === 'ready') {
-              const pingExit = yield* Effect.exit(
-                effectTryServicePromise(() => redis.ping(), 'Redis health check failed'),
-              )
-              if (Exit.isFailure(pingExit)) {
-                log(logger, 'warn', `Redis health check failed: ${getErrorMessage(pingExit.cause)}`)
-                setHealthy(false)
-              } else {
-                setHealthy(true)
-              }
-            }
-          } finally {
-            setHealthCheckRunning(false)
+        state.isClosing = true
+
+        const handlers = (client as ClientWithHandlers).__lotaHandlers
+        if (handlers) {
+          client.off('connect', handlers.connect)
+          client.off('ready', handlers.ready)
+          client.off('error', handlers.error)
+          client.off('close', handlers.close)
+          client.off('reconnecting', handlers.reconnecting)
+          client.off('end', handlers.end)
+        }
+
+        if (client.status !== 'end') {
+          const quitExit = yield* Effect.exit(
+            effectTryServicePromise(() => client.quit(), 'Failed to close Redis connection manager'),
+          )
+          if (Exit.isFailure(quitExit)) {
+            log(options.logger, 'warn', `Redis quit failed, forcing disconnect: ${getErrorMessage(quitExit.cause)}`)
+            client.disconnect()
           }
         }
       }),
-    )
-  }
-
-  private stopHealthChecks(): Promise<void> {
-    this.healthChecksActive = false
-
-    const fiber = this.healthCheckFiber
-    if (!fiber) {
-      return Promise.resolve()
-    }
+  )
+}
 
-    this.healthCheckFiber = null
-    return Effect.runPromise(Fiber.interrupt(fiber)).then(
-      () => undefined,
-      () => undefined,
-    )
-  }
+interface RedisHandlers {
+  readonly connect: () => void
+  readonly ready: () => void
+  readonly error: (error: Error) => void
+  readonly close: () => void
+  readonly reconnecting: () => void
+  readonly end: () => void
+}
 
-  getConnection(): IORedis {
-    if (!this.redis) {
-      throw new ConfigurationError({ message: 'Redis connection not initialized', key: 'redis' })
+type ClientWithHandlers = IORedis & { __lotaHandlers?: RedisHandlers }
+
+/**
+ * Health-check loop wired via `Effect.forkScoped` so interruption is automatic
+ * when the owning scope closes. No more imperative fiber tracking.
+ */
+function startHealthCheckFiber(
+  client: IORedis,
+  options: CreateRedisConnectionManagerOptions,
+  state: ManagerState,
+): Effect.Effect<void, never, Scope.Scope> {
+  const intervalMs = options.healthCheckIntervalMs ?? DEFAULT_HEALTH_CHECK_INTERVAL_MS
+  const logger = options.logger
+  let isHealthCheckRunning = false
+
+  const loop = Effect.gen(function* () {
+    for (;;) {
+      yield* Effect.sleep(Duration.millis(intervalMs))
+      if (isHealthCheckRunning) continue
+
+      isHealthCheckRunning = true
+      try {
+        if (client.status === 'ready') {
+          const pingExit = yield* Effect.exit(effectTryServicePromise(() => client.ping(), 'Redis health check failed'))
+          if (Exit.isFailure(pingExit)) {
+            log(logger, 'warn', `Redis health check failed: ${getErrorMessage(pingExit.cause)}`)
+            state.isHealthy = false
+          } else {
+            state.isHealthy = true
+          }
+        }
+      } finally {
+        isHealthCheckRunning = false
+      }
     }
-    return this.redis
-  }
+  })
 
-  getConnectionForBullMQ(): IORedis {
-    return this.getConnection()
-  }
-
-  isConnectionHealthy(): boolean {
-    return this.isHealthy && this.redis?.status === 'ready'
-  }
+  return Effect.asVoid(Effect.forkScoped(loop))
+}
 
-  closeConnection(): Promise<void> {
-    this.isClosing = true
-    const logger = this.options.logger
-    const getRedis = () => this.redis
-    const stopHealthChecks = () => this.stopHealthChecks()
-    const disconnect = () => {
-      this.redis?.disconnect()
+/**
+ * Scoped builder for the Redis connection manager. The IORedis client and
+ * health-check fiber are both bound to the surrounding scope, so closing the
+ * scope tears down listeners + quits the client + interrupts the fiber.
+ */
+export function makeRedisConnectionManager(
+  options: CreateRedisConnectionManagerOptions,
+): Effect.Effect<RedisConnectionManager, RedisError, Scope.Scope> {
+  return Effect.gen(function* () {
+    const state: ManagerState = { isHealthy: false, isClosing: false }
+    const client = yield* acquireRedisClient(options, state)
+    yield* startHealthCheckFiber(client, options, state)
+
+    const manager: RedisConnectionManager = {
+      getConnection: () => client,
+      getConnectionForBullMQ: () => client,
+      isConnectionHealthy: () => state.isHealthy && client.status === 'ready',
+      closeConnection: () => Promise.resolve(),
     }
 
-    return Effect.runPromise(
-      Effect.gen(function* () {
-        yield* Effect.tryPromise(() => stopHealthChecks())
-        const redis = getRedis()
-        if (redis && redis.status !== 'end') {
-          const quitExit = yield* Effect.exit(
-            effectTryServicePromise(() => redis.quit(), 'Failed to close Redis connection manager'),
-          )
-          if (Exit.isFailure(quitExit)) {
-            log(logger, 'warn', `Redis quit failed, forcing disconnect: ${getErrorMessage(quitExit.cause)}`)
-            disconnect()
-          }
-        }
-      }),
-    )
-  }
+    return manager
+  })
 }
 
+/**
+ * Standalone Promise-friendly factory for hosts that build the manager outside
+ * a Layer. Owns its own `Scope`; `closeConnection()` closes that scope, which
+ * runs the same finalizer chain (listener removal, quit/disconnect, fiber
+ * interrupt) that `Layer.effect` runs at runtime shutdown.
+ */
 export function createRedisConnectionManager(options: CreateRedisConnectionManagerOptions): RedisConnectionManager {
-  return new RedisConnectionManagerImpl(options)
+  const scope = Scope.makeUnsafe()
+  const built = Effect.runSync(Scope.provide(makeRedisConnectionManager(options), scope))
+  let closePromise: Promise<void> | null = null
+
+  return {
+    ...built,
+    closeConnection: () => {
+      if (!closePromise) {
+        closePromise = Effect.runPromise(Scope.close(scope, Exit.void).pipe(Effect.catchCause(() => Effect.void)))
+      }
+      return closePromise
+    },
+  }
 }

package/src/redis/runtime-connection.ts

@@ -1,10 +1,20 @@
-import { Effect } from 'effect'
 import type IORedis from 'ioredis'
 
-import { getCurrentRuntime } from '../effect/runtime-ref'
+import { resolveLotaService } from '../effect/runtime'
 import { RedisServiceTag } from '../effect/services'
+import type { RedisConnectionManager } from './connection'
+
+let currentRedisManager: RedisConnectionManager | null = null
+
+export function configureRuntimeRedisManager(redisManager: RedisConnectionManager): void {
+  currentRedisManager = redisManager
+}
+
+export function clearRuntimeRedisManager(): void {
+  currentRedisManager = null
+}
 
 export function getRuntimeRedisConnection(): IORedis {
-  const redis = getCurrentRuntime().runSync(Effect.service(RedisServiceTag))
+  const redis = currentRedisManager ?? resolveLotaService(RedisServiceTag)
   return redis.getConnection()
 }

package/src/redis/stream-context.ts

@@ -1,11 +1,14 @@
-import { Context, Schema, Effect, Fiber, Layer, PubSub, Stream } from 'effect'
+import { Context, Schema, Effect, Fiber, Layer, Queue, Stream } from 'effect'
 import type { Redis } from 'ioredis'
 import type { Publisher, Subscriber } from 'resumable-stream/ioredis'
 import { createResumableStreamContext } from 'resumable-stream/ioredis'
 
+import { serverLogger } from '../config/logger'
 import { RedisServiceTag } from '../effect/services'
 import type { RedisConnectionManager } from './connection'
 
+const SUBSCRIBER_QUEUE_CAPACITY = 1024
+
 function toPublisher(client: Redis): Publisher {
   return {
     connect: () => Promise.resolve(),
@@ -26,7 +29,7 @@ class SharedSubscriberCloseError extends Schema.TaggedErrorClass<SharedSubscribe
 export class SharedThreadStreamSubscriberTag extends Context.Service<
   SharedThreadStreamSubscriberTag,
   { readonly subscriber: Subscriber }
->()('SharedThreadStreamSubscriber') {}
+>()('@lota-sdk/core/SharedThreadStreamSubscriber') {}
 
 export const SharedThreadStreamSubscriberLive = Layer.effect(
   SharedThreadStreamSubscriberTag,
@@ -35,13 +38,15 @@ export const SharedThreadStreamSubscriberLive = Layer.effect(
     // Disable enableReadyCheck — the ready check sends INFO which is rejected
     // on connections in subscribe mode, causing unhandled ioredis error events.
     const client = redisManager.getConnection().duplicate({ enableReadyCheck: false })
-    client.on('error', () => {}) // prevent [ioredis] Unhandled error event logs
+    client.on('error', (error: unknown) => {
+      serverLogger.warn('Redis subscriber error', { cause: error })
+    })
 
-    const events = yield* PubSub.unbounded<SharedSubscriberEvent>()
+    const events = yield* Queue.bounded<SharedSubscriberEvent>(SUBSCRIBER_QUEUE_CAPACITY)
     const handlers = new Map<string, (message: string) => void>()
 
     const dispatchFiber = yield* Effect.forkScoped(
-      Stream.fromPubSub(events).pipe(
+      Stream.fromQueue(events).pipe(
         Stream.runForEach((event) =>
           Effect.sync(() => {
             handlers.get(event.channel)?.(event.message)
@@ -50,10 +55,13 @@ export const SharedThreadStreamSubscriberLive = Layer.effect(
       ),
     )
 
-    const currentContext = yield* Effect.context()
-    const runFork = Effect.runForkWith(currentContext)
     const messageListener = (channel: string, message: string) => {
-      void runFork(PubSub.publish(events, { channel, message }).pipe(Effect.asVoid))
+      // Synchronous bounded enqueue — drops (returns false) when consumer is slow,
+      // surfacing back-pressure instead of growing memory unbounded.
+      const accepted = Queue.offerUnsafe(events, { channel, message })
+      if (!accepted) {
+        serverLogger.warn('Redis subscriber queue full, dropping message', { channel })
+      }
     }
     client.on('message', messageListener)
 
@@ -78,7 +86,7 @@ export const SharedThreadStreamSubscriberLive = Layer.effect(
         handlers.clear()
         client.removeListener('message', messageListener)
         yield* Fiber.interrupt(dispatchFiber)
-        yield* PubSub.shutdown(events)
+        yield* Queue.shutdown(events)
         yield* Effect.tryPromise({
           try: () => client.quit(),
           catch: (cause) =>

package/src/runtime/agent-runtime-policy.ts

@@ -1,4 +1,5 @@
 import type {
+  ChatMode,
   ExecutionMode,
   OwnershipDispatchContext,
   PlanArtifactSubmission,
@@ -8,7 +9,6 @@ import type {
 
 import { getLeadAgentId } from '../config/agent-defaults'
 import { resolveOnboardingOwnerAgentId } from '../config/thread-defaults'
-import type { ChatMode } from './agent-types'
 export interface AgentRuntimeConfig<TAgent extends string> {
   id: TAgent
   displayName: string

package/src/runtime/agent-stream-helpers.ts

@@ -1,6 +1,6 @@
 import type { ChatMessage } from '@lota-sdk/shared'
 import type { LanguageModelUsage, UIMessageStreamOptions } from 'ai'
-import { Duration, Effect, Fiber } from 'effect'
+import { Duration, Effect, Exit, Scope } from 'effect'
 
 import { getAgentDisplayNames, getLeadAgentDisplayName } from '../config/agent-defaults'
 import { nowEpochMillis } from '../utils/date-time'
@@ -106,17 +106,20 @@ export function createTimedAbortSignal(parentSignal: AbortSignal, timeoutMs: num
   const abortFromParent = () => {
     controller.abort((parentSignal as AbortSignal & { reason?: unknown }).reason)
   }
-  const timeoutFiber = Effect.runFork(
-    Effect.sleep(Duration.millis(timeoutMs)).pipe(
-      Effect.tap(() =>
-        Effect.sync(() => {
-          if (disposed || controller.signal.aborted) return
-          didTimeout = true
-          controller.abort(new Error(`Timed out after ${timeoutMs}ms`))
-        }),
-      ),
+
+  // Own a scope so the timeout fiber is cleaned up via Scope.close() on dispose,
+  // matching Effect v4 best practices (forkScoped + scope-bound finalizers).
+  const scope = Scope.makeUnsafe()
+  const timeoutEffect = Effect.sleep(Duration.millis(timeoutMs)).pipe(
+    Effect.andThen(
+      Effect.sync(() => {
+        if (disposed || controller.signal.aborted) return
+        didTimeout = true
+        controller.abort(new Error(`Timed out after ${timeoutMs}ms`))
+      }),
     ),
   )
+  Effect.runFork(Scope.provide(Effect.forkScoped(timeoutEffect), scope))
 
   if (parentSignal.aborted) {
     abortFromParent()
@@ -128,9 +131,10 @@ export function createTimedAbortSignal(parentSignal: AbortSignal, timeoutMs: num
     signal: controller.signal,
     didTimeout: () => didTimeout,
     dispose: () => {
+      if (disposed) return
       disposed = true
       parentSignal.removeEventListener('abort', abortFromParent)
-      void Effect.runFork(Fiber.interrupt(timeoutFiber))
+      void Effect.runPromise(Scope.close(scope, Exit.void).pipe(Effect.catchCause(() => Effect.void)))
     },
   }
 }

package/src/runtime/chat-run-orchestration.ts

@@ -37,7 +37,7 @@ interface CompactionCoordination {
 }
 
 export class CompactionCoordinationTag extends Context.Service<CompactionCoordinationTag, CompactionCoordination>()(
-  'CompactionCoordination',
+  '@lota-sdk/core/CompactionCoordination',
 ) {}
 
 export const CompactionCoordinationLive = Layer.effect(

package/src/runtime/context-compaction/context-compaction-runtime.ts

@@ -66,7 +66,7 @@ function runContextCompacter(helperModelRuntime: HelperModelRuntime, params: Con
         schema: ContextCompactionOutputSchema,
         maxOutputTokens: 8_000,
       }),
-    ).pipe(Effect.map(parseCompactionOutput)),
+    ).pipe(Effect.flatMap(parseCompactionOutput)),
   )
 }