@lota-sdk/core 0.4.13 → 0.4.14

package/src/create-runtime.ts

@@ -1,8 +1,15 @@
 import type { Fiber } from 'effect'
-import { Effect, ManagedRuntime } from 'effect'
+import { Deferred, Effect, Layer, ManagedRuntime } from 'effect'
 import type { Subscriber } from 'resumable-stream/ioredis'
 
-import { AiGatewayTag, bindAiGatewayRuntime } from './ai-gateway/ai-gateway'
+import {
+  AiGatewayModelsTag,
+  AiGatewayTag,
+  RuntimeBridgeTag,
+  createAiGatewayModels,
+  makeAiGatewayService,
+} from './ai-gateway/ai-gateway'
+import type { AiGatewayModels, RuntimeBridge } from './ai-gateway/ai-gateway'
 import { computeSchemaFingerprint } from './db/schema-fingerprint'
 import { publishDatabaseBootstrapEffect } from './db/startup'
 import {
@@ -12,10 +19,8 @@ import {
   DatabaseServiceTag as EffectDatabaseService,
   RedisServiceTag as EffectRedisService,
   RuntimeAdaptersServiceTag,
-  RuntimeConfigServiceTag,
 } from './effect'
 import { ConfigurationError, ServiceError } from './effect/errors'
-import { effectTryPromise } from './effect/helpers'
 import { LotaQueuesServiceTag } from './queues/queues.service'
 import type { RedisConnectionManager } from './redis/connection'
 import { SharedThreadStreamSubscriberTag } from './redis/stream-context'
@@ -74,6 +79,10 @@ export interface LotaRuntime {
   config: ResolvedLotaRuntimeConfig
   plugins: Record<string, LotaPlugin>
   systemExecutors: Record<string, SystemNodeExecutor>
+  /** Pre-bound AI gateway model factories. Use instead of the legacy
+   * `aiGatewayChatModel(modelId)` / `aiGatewayModel(modelId)` module-level
+   * helpers — those now require a `deps` argument. */
+  ai: AiGatewayModels
   connectPluginDatabases(): Promise<void>
   connect(): Promise<void>
   disconnect(): Promise<void>
@@ -88,87 +97,136 @@ export function createLotaRuntimeFromEnv(
   )
 }
 
-export function createLotaRuntime(config: LotaRuntimeConfig): Promise<LotaRuntime> {
-  let effectRuntime: { dispose(): Promise<void> } | null = null
+// @effect-diagnostics-next-line asyncFunction:off -- public host entrypoint; returns Promise by design.
+export async function createLotaRuntime(config: LotaRuntimeConfig): Promise<LotaRuntime> {
+  const resolvedConfig = parseLotaRuntimeConfig(config)
+  const systemExecutors = { ...getBuiltInSystemExecutors(), ...resolvedConfig.systemExecutors }
+  const runtimeConfig = { ...resolvedConfig, systemExecutors } satisfies ResolvedLotaRuntimeConfig
 
-  return Effect.runPromise(
-    Effect.gen(function* () {
-      const resolvedConfig = parseLotaRuntimeConfig(config)
-      const systemExecutors = { ...getBuiltInSystemExecutors(), ...resolvedConfig.systemExecutors }
-      const runtimeConfig = { ...resolvedConfig, systemExecutors } satisfies ResolvedLotaRuntimeConfig
+  const socialChatAgentId = runtimeConfig.socialChat?.agentId?.trim() || 'socialChat'
+  const socialChatAgentDisplayName = runtimeConfig.socialChat?.agentDisplayName?.trim() || 'Lota'
+  if (runtimeConfig.socialChat && !runtimeConfig.agents.roster.includes(socialChatAgentId)) {
+    throw new ConfigurationError({
+      message: `socialChat.agentId must be present in agents.roster: ${socialChatAgentId}`,
+      key: 'socialChat.agentId',
+    })
+  }
+  const resolvedAgentDisplayNames = runtimeConfig.socialChat
+    ? { ...runtimeConfig.agents.displayNames, [socialChatAgentId]: socialChatAgentDisplayName }
+    : runtimeConfig.agents.displayNames
 
-      const socialChatAgentId = runtimeConfig.socialChat?.agentId?.trim() || 'socialChat'
-      const socialChatAgentDisplayName = runtimeConfig.socialChat?.agentDisplayName?.trim() || 'Lota'
-      if (runtimeConfig.socialChat && !runtimeConfig.agents.roster.includes(socialChatAgentId)) {
-        return yield* new ConfigurationError({
-          message: `socialChat.agentId must be present in agents.roster: ${socialChatAgentId}`,
-          key: 'socialChat.agentId',
-        })
-      }
-      const resolvedAgentDisplayNames = runtimeConfig.socialChat
-        ? { ...runtimeConfig.agents.displayNames, [socialChatAgentId]: socialChatAgentDisplayName }
-        : runtimeConfig.agents.displayNames
+  const infrastructureLayer = buildInfrastructureLayer(runtimeConfig, { resolvedAgentDisplayNames })
+  const aiGateway = Effect.runSync(makeAiGatewayService(runtimeConfig))
+  const aiGatewayModelsDeferred = Effect.runSync(Deferred.make<AiGatewayModels>())
+  const runtimeBridgeDeferred = Effect.runSync(Deferred.make<RuntimeBridge>())
+  const bridgeLayer = Layer.mergeAll(
+    Layer.succeed(AiGatewayTag, aiGateway),
+    Layer.effect(AiGatewayModelsTag, Deferred.await(aiGatewayModelsDeferred)),
+    Layer.effect(RuntimeBridgeTag, Deferred.await(runtimeBridgeDeferred)),
+  )
+  const fullLayer = buildDomainServiceLayer(infrastructureLayer, bridgeLayer)
+  const managedRuntime = ManagedRuntime.make(fullLayer)
+  const runtimeBridge: RuntimeBridge = {
+    runPromise: (effect, options) => managedRuntime.runPromise(effect, options),
+    runFork: (effect) => managedRuntime.runFork(effect),
+  }
+  const aiGatewayModels = createAiGatewayModels({
+    gateway: aiGateway,
+    runtimeConfig,
+    runPromise: runtimeBridge.runPromise,
+    runFork: runtimeBridge.runFork,
+  })
 
-      // ── Infrastructure + domain layer composition ─────────────────────
-      const infrastructureLayer = buildInfrastructureLayer(runtimeConfig, { resolvedAgentDisplayNames })
-      const fullLayer = buildDomainServiceLayer(infrastructureLayer)
+  if (!Effect.runSync(Deferred.succeed(runtimeBridgeDeferred, runtimeBridge))) {
+    throw new ServiceError({ message: 'Failed to initialize the runtime bridge.' })
+  }
+  if (!Effect.runSync(Deferred.succeed(aiGatewayModelsDeferred, aiGatewayModels))) {
+    throw new ServiceError({ message: 'Failed to initialize AI gateway models.' })
+  }
 
-      const managedRuntime = ManagedRuntime.make(fullLayer)
-      effectRuntime = managedRuntime
+  try {
+    const resolvedServices = await managedRuntime.runPromise(
+      Effect.gen(function* () {
+        return {
+          db: yield* EffectDatabaseService,
+          redisManager: yield* EffectRedisService,
+          sharedSubscriber: yield* SharedThreadStreamSubscriberTag,
+          threadTurnService: yield* ThreadTurnServiceTag,
+          socialChatHistoryService: yield* SocialChatHistoryServiceTag,
+          learnedSkillService: yield* LearnedSkillServiceTag,
+          memoryService: yield* MemoryServiceTag,
+          runtimeAdapters: yield* RuntimeAdaptersServiceTag,
+          agentConfig: yield* AgentConfigServiceTag,
+          agentFactoryConfig: yield* AgentFactoryServiceTag,
+          queues: yield* LotaQueuesServiceTag,
+          autonomousJobService: yield* AutonomousJobServiceTag,
+          contextCompactionService: yield* ContextCompactionServiceTag,
+          threadService: yield* ThreadServiceTag,
+          planAgentHeartbeatService: yield* PlanAgentHeartbeatServiceTag,
+          planSchedulerService: yield* PlanSchedulerServiceTag,
+          planDeadlineService: yield* PlanDeadlineServiceTag,
+          planExecutorService: yield* PlanExecutorServiceTag,
+          planCycleService: yield* PlanCycleServiceTag,
+          threadTitleService: yield* ThreadTitleServiceTag,
+          recentActivityTitleService: yield* RecentActivityTitleServiceTag,
+        }
+      }),
+    )
+    const {
+      db,
+      redisManager,
+      sharedSubscriber,
+      threadTurnService,
+      socialChatHistoryService,
+      learnedSkillService,
+      memoryService,
+      runtimeAdapters,
+      agentConfig,
+      agentFactoryConfig,
+      queues,
+      autonomousJobService,
+      contextCompactionService,
+      threadService,
+      planAgentHeartbeatService,
+      planSchedulerService,
+      planDeadlineService,
+      planExecutorService,
+      planCycleService,
+      threadTitleService,
+      recentActivityTitleService,
+    } = resolvedServices
 
-      // Eagerly resolve the services the outer entrypoint needs directly.
-      const resolvedServices = yield* Effect.tryPromise({
-        try: () =>
-          managedRuntime.runPromise(
-            Effect.gen(function* () {
-              return {
-                db: yield* EffectDatabaseService,
-                redisManager: yield* EffectRedisService,
-                sharedSubscriber: yield* SharedThreadStreamSubscriberTag,
-                threadTurnService: yield* ThreadTurnServiceTag,
-                socialChatHistoryService: yield* SocialChatHistoryServiceTag,
-                learnedSkillService: yield* LearnedSkillServiceTag,
-                memoryService: yield* MemoryServiceTag,
-                runtimeAdapters: yield* RuntimeAdaptersServiceTag,
-                agentConfig: yield* AgentConfigServiceTag,
-                agentFactoryConfig: yield* AgentFactoryServiceTag,
-                queues: yield* LotaQueuesServiceTag,
-                autonomousJobService: yield* AutonomousJobServiceTag,
-                contextCompactionService: yield* ContextCompactionServiceTag,
-                threadService: yield* ThreadServiceTag,
-                planAgentHeartbeatService: yield* PlanAgentHeartbeatServiceTag,
-                planSchedulerService: yield* PlanSchedulerServiceTag,
-                planDeadlineService: yield* PlanDeadlineServiceTag,
-                planExecutorService: yield* PlanExecutorServiceTag,
-                planCycleService: yield* PlanCycleServiceTag,
-                threadTitleService: yield* ThreadTitleServiceTag,
-                recentActivityTitleService: yield* RecentActivityTitleServiceTag,
-                aiGateway: yield* AiGatewayTag,
-                runtimeConfigService: yield* RuntimeConfigServiceTag,
-              }
-            }),
-          ),
-        catch: (error) =>
-          new ServiceError({
-            message: `Failed to initialize Effect runtime services: ${error instanceof Error ? error.message : String(error)}`,
-            cause: error,
-          }),
-      })
-      const {
-        db,
-        redisManager,
-        sharedSubscriber,
-        threadTurnService,
-        socialChatHistoryService,
-        learnedSkillService,
-        memoryService,
-        runtimeAdapters,
-        agentConfig,
-        agentFactoryConfig,
-        queues,
-        autonomousJobService,
-        contextCompactionService,
+    // ── Schema + plugin + worker + social-chat composition ────────────
+    const pluginRuntime = runtimeConfig.pluginRuntime ?? {}
+    const pluginContributions = Object.values(pluginRuntime).map((plugin) => plugin.contributions)
+    const hostContributionSchemaFiles = pluginContributions.flatMap((plugin) => plugin.schemaFiles)
+    const schemaFiles = [
+      ...getBuiltInSchemaFiles(),
+      ...(runtimeConfig.extraSchemaFiles ?? []),
+      ...hostContributionSchemaFiles,
+    ]
+    const contributionEnvKeys = [...LOTA_RUNTIME_ENV_KEYS, ...pluginContributions.flatMap((plugin) => plugin.envKeys)]
+    const connectedPluginDatabases = new Set<string>()
+    const connectPluginDatabases = createPluginDatabaseConnector(
+      managedRuntime,
+      pluginRuntime,
+      connectedPluginDatabases,
+    )
+    const disconnectPluginDatabases = createPluginDatabaseDisconnector(
+      managedRuntime,
+      pluginRuntime,
+      connectedPluginDatabases,
+    )
+    const workers = buildRuntimeWorkerRegistry(
+      queues,
+      {
+        databaseService: db,
+        runPromise: <A, E, R>(effect: Effect.Effect<A, E, R>) =>
+          managedRuntime.runPromise(effect as unknown as Effect.Effect<A, E, never>),
         threadService,
+        contextCompactionService,
+        autonomousJobService,
+        memoryService,
         planAgentHeartbeatService,
         planSchedulerService,
         planDeadlineService,
@@ -176,134 +234,135 @@ export function createLotaRuntime(config: LotaRuntimeConfig): Promise<LotaRuntim
         planCycleService,
         threadTitleService,
         recentActivityTitleService,
-        aiGateway,
-        runtimeConfigService,
-      } = resolvedServices
-
-      // Seed the AI gateway middleware so wrapGenerate/wrapStream/wrapEmbed
-      // edges can run Effects without reaching for an ambient runtime slot.
-      bindAiGatewayRuntime({
-        gateway: aiGateway,
-        runtimeConfig: runtimeConfigService,
-        runPromise: (effect) => managedRuntime.runPromise(effect),
-        runFork: (effect) => managedRuntime.runFork(effect),
-      })
-
-      // ── Schema + plugin + worker + social-chat composition ────────────
-      const pluginRuntime = runtimeConfig.pluginRuntime ?? {}
-      const pluginContributions = Object.values(pluginRuntime).map((plugin) => plugin.contributions)
-      const hostContributionSchemaFiles = pluginContributions.flatMap((plugin) => plugin.schemaFiles)
-      const schemaFiles = [
-        ...getBuiltInSchemaFiles(),
-        ...(runtimeConfig.extraSchemaFiles ?? []),
-        ...hostContributionSchemaFiles,
-      ]
-      const contributionEnvKeys = [...LOTA_RUNTIME_ENV_KEYS, ...pluginContributions.flatMap((plugin) => plugin.envKeys)]
-      const connectedPluginDatabases = new Set<string>()
-      const connectPluginDatabases = createPluginDatabaseConnector(
-        managedRuntime,
-        pluginRuntime,
-        connectedPluginDatabases,
-      )
-      const disconnectPluginDatabases = createPluginDatabaseDisconnector(
-        managedRuntime,
-        pluginRuntime,
-        connectedPluginDatabases,
-      )
-      const workers = buildRuntimeWorkerRegistry(
-        queues,
-        {
-          databaseService: db,
-          threadService,
-          contextCompactionService,
-          autonomousJobService,
-          memoryService,
-          planAgentHeartbeatService,
-          planSchedulerService,
-          planDeadlineService,
-          planExecutorService,
-          planCycleService,
-          threadTitleService,
-          recentActivityTitleService,
-          redisManager,
-        },
-        runtimeConfig.extraWorkers,
-      )
-      const socialChat = createSocialChatRuntime({
-        agentConfig,
-        agentFactoryConfig,
-        redisClient: redisManager.getConnection() as unknown as Parameters<
-          typeof createSocialChatRuntime
-        >[0]['redisClient'],
-        socialChat: runtimeConfig.socialChat,
-        services: { learnedSkillService, memoryService, socialChatHistoryService, runtimeAdapters, queues },
-      })
-      const currentContext = yield* Effect.context()
-      const runPromiseWithCurrentContext = Effect.runPromiseWith(currentContext)
-
-      // ── Service surface (eager, plain-property) ───────────────────────
-      const { services, lota } = buildRuntimeServiceSurface({
-        managedRuntime,
-        db,
         redisManager,
-        sharedSubscriber,
-        threadTurnService,
-        socialChatHistoryService,
-      })
+      },
+      runtimeConfig.extraWorkers,
+    )
+    const socialChat = createSocialChatRuntime({
+      agentConfig,
+      agentFactoryConfig,
+      // Bridge ioredis version mismatch: `@chat-adapter/state-ioredis` ships
+      // its own Redis type with newer methods (hexpireat etc.) not present
+      // in our pinned ioredis. The runtime behaviour is compatible.
+      redisClient: redisManager.getConnection() as unknown as Parameters<
+        typeof createSocialChatRuntime
+      >[0]['redisClient'],
+      socialChat: runtimeConfig.socialChat,
+      services: { learnedSkillService, memoryService, socialChatHistoryService, runtimeAdapters, queues },
+    })
 
-      const disconnect = createRuntimeDisconnect({
-        managedRuntime,
-        runPromiseWithCurrentContext,
-        socialChatShutdown: () => socialChat.shutdown(),
-        disconnectPluginDatabases,
-      })
+    // ── Service surface (eager, plain-property) ───────────────────────
+    const { services, lota } = buildRuntimeServiceSurface({
+      managedRuntime,
+      db,
+      redisManager,
+      sharedSubscriber,
+      threadTurnService,
+      socialChatHistoryService,
+    })
 
-      const lotaRuntime: LotaRuntime = {
-        runPromise: <A, E, R>(effect: Effect.Effect<A, E, R>, options?: { readonly signal?: AbortSignal }) =>
-          managedRuntime.runPromise(effect as unknown as Effect.Effect<A, E, never>, options),
-        runSync: <A, E, R>(effect: Effect.Effect<A, E, R>) =>
-          managedRuntime.runSync(effect as unknown as Effect.Effect<A, E, never>),
-        runFork: <A, E, R>(effect: Effect.Effect<A, E, R>) =>
-          managedRuntime.runFork(effect as unknown as Effect.Effect<A, E, never>),
-        services,
-        lota,
-        redis: {
-          manager: redisManager,
-          subscriber: sharedSubscriber.subscriber,
-          getConnection: () => redisManager.getConnection(),
-          getConnectionForBullMQ: () => redisManager.getConnectionForBullMQ(),
-          closeConnection: () => managedRuntime.runPromise(effectTryPromise(() => redisManager.closeConnection())),
-        },
-        workers,
-        socialChat,
-        schemaFiles,
-        contributions: { envKeys: [...new Set(contributionEnvKeys)], schemaFiles: hostContributionSchemaFiles },
-        config: runtimeConfig,
-        plugins: pluginRuntime,
-        systemExecutors,
-        connectPluginDatabases,
-        connect: () =>
+    const disconnect = createRuntimeDisconnect({
+      managedRuntime,
+      socialChatShutdown: () => socialChat.shutdown(),
+      disconnectPluginDatabases,
+    })
+
+    // Host boundary: the ManagedRuntime carries the full 76-service union
+    // the SDK composes, but exposing that union in the public `LotaRuntime`
+    // interface would force every consumer to import every service tag. The
+    // cast keeps the public signature generic while trusting the runtime's
+    // actual capabilities — any missing service surfaces at runtime.
+    const lotaRuntime: LotaRuntime = {
+      runPromise: <A, E, R>(effect: Effect.Effect<A, E, R>, options?: { readonly signal?: AbortSignal }) =>
+        managedRuntime.runPromise(effect as unknown as Effect.Effect<A, E, never>, options),
+      runSync: <A, E, R>(effect: Effect.Effect<A, E, R>) =>
+        managedRuntime.runSync(effect as unknown as Effect.Effect<A, E, never>),
+      runFork: <A, E, R>(effect: Effect.Effect<A, E, R>) =>
+        managedRuntime.runFork(effect as unknown as Effect.Effect<A, E, never>),
+      services,
+      lota,
+      redis: {
+        manager: redisManager,
+        subscriber: sharedSubscriber.subscriber,
+        getConnection: () => redisManager.getConnection(),
+        getConnectionForBullMQ: () => redisManager.getConnectionForBullMQ(),
+        closeConnection: () =>
           managedRuntime.runPromise(
-            Effect.gen(function* () {
-              yield* db.connect()
-              const bunFiles = schemaFiles.map((schemaFile) =>
-                schemaFile instanceof URL ? Bun.file(schemaFile.pathname) : Bun.file(schemaFile),
-              )
-              yield* db.applySchema(bunFiles)
-              const schemaFingerprint = yield* effectTryPromise(() => computeSchemaFingerprint(schemaFiles))
-              yield* publishDatabaseBootstrapEffect({ databaseService: db, schemaFingerprint })
+            Effect.tryPromise({
+              try: () => redisManager.closeConnection(),
+              catch: (cause) => new ServiceError({ message: 'Failed to close Redis connection.', cause }),
             }),
           ),
-        disconnect,
-      }
-      return lotaRuntime
-    }),
-  ).catch((error) => {
-    if (effectRuntime) {
-      void effectRuntime.dispose().catch(() => undefined)
+      },
+      workers,
+      socialChat,
+      ai: aiGatewayModels,
+      schemaFiles,
+      contributions: { envKeys: [...new Set(contributionEnvKeys)], schemaFiles: hostContributionSchemaFiles },
+      config: runtimeConfig,
+      plugins: pluginRuntime,
+      systemExecutors,
+      connectPluginDatabases,
+      connect: () =>
+        managedRuntime.runPromise(
+          Effect.gen(function* () {
+            yield* db.connect()
+            const bunFiles = schemaFiles.map((schemaFile) =>
+              schemaFile instanceof URL ? Bun.file(schemaFile.pathname) : Bun.file(schemaFile),
+            )
+            yield* db.applySchema(bunFiles)
+            const schemaFingerprint = yield* Effect.tryPromise({
+              try: () => computeSchemaFingerprint(schemaFiles),
+              catch: (cause) => new ServiceError({ message: 'Failed to compute schema fingerprint.', cause }),
+            })
+            yield* publishDatabaseBootstrapEffect({ databaseService: db, schemaFingerprint })
+          }),
+        ),
+      disconnect,
     }
-    throw error
-  })
+    registerRuntimeShutdownHandlers(lotaRuntime)
+    return lotaRuntime
+  } catch (error) {
+    await managedRuntime.dispose()
+    throw new ServiceError({
+      message: `Failed to initialize Effect runtime services: ${error instanceof Error ? error.message : String(error)}`,
+      cause: error,
+    })
+  }
+}
+
+/**
+ * Per-runtime shutdown handler — the previous module-level latch meant that
+ * a second `createLotaRuntime` call (e.g. reconnect after a test harness
+ * disposes the first runtime) silently skipped signal wiring and left the
+ * fresh runtime leaking on SIGTERM/SIGINT. We instead maintain a live set
+ * and dispatch each signal to every registered runtime, removing each as it
+ * disconnects. `process.on` (not `once`) keeps the dispatcher alive across
+ * multiple registrations within the same process.
+ */
+const activeShutdownHandlers = new Set<() => Promise<void>>()
+let signalDispatcherInstalled = false
+
+function installSignalDispatcherOnce(): void {
+  if (signalDispatcherInstalled) return
+  signalDispatcherInstalled = true
+  const dispatch = () => {
+    for (const handler of activeShutdownHandlers) {
+      void handler().catch(() => undefined)
+    }
+  }
+  process.on('SIGTERM', dispatch)
+  process.on('SIGINT', dispatch)
+}
+
+function registerRuntimeShutdownHandlers(runtime: LotaRuntime): void {
+  installSignalDispatcherOnce()
+  // @effect-diagnostics-next-line asyncFunction:off -- signal dispatcher callback; Promise-based by design.
+  const handler = async () => {
+    activeShutdownHandlers.delete(handler)
+    await runtime.disconnect().catch(() => undefined)
+  }
+  activeShutdownHandlers.add(handler)
 }
 
 function getBuiltInSchemaFiles(): URL[] {

package/src/db/cursor-pagination.ts

@@ -3,6 +3,7 @@ import { Schema, Effect } from 'effect'
 import type { BoundQuery, RecordId } from 'surrealdb'
 import { z } from 'zod'
 
+import { ERROR_TAGS } from '../effect/errors'
 import type { RecordIdRef } from './record-id'
 import type { SurrealDBService } from './service'
 import type { DatabaseTable } from './tables'
@@ -25,19 +26,11 @@ export interface CursorPaginationConfig {
   queryBefore: (parentId: RecordIdRef, cursorCreatedAt: Date, cursorId: RecordId, limit: number) => BoundQuery
 }
 
-class CursorPaginationError extends Schema.TaggedErrorClass<CursorPaginationError>()('CursorPaginationError', {
+class CursorPaginationError extends Schema.TaggedErrorClass<CursorPaginationError>()(ERROR_TAGS.CursorPaginationError, {
   message: Schema.String,
   cause: Schema.optional(Schema.Defect),
 }) {}
 
-export function listMessageHistoryPage(
-  db: SurrealDBService,
-  config: CursorPaginationConfig,
-  params: { parentId: RecordIdRef; take: number; beforeMessageId?: string },
-): Promise<MessageHistoryPage> {
-  return Effect.runPromise(listMessageHistoryPageEffect(db, config, params))
-}
-
 export function listMessageHistoryPageEffect(
   db: SurrealDBService,
   config: CursorPaginationConfig,