@lota-sdk/core 0.4.10 → 0.4.11

package/src/config/logger.ts

@@ -1,7 +1,5 @@
 import { Effect, Logger, References } from 'effect'
 
-import { getOptionalCurrentRuntime } from '../effect/runtime-ref'
-
 const LOG_CATEGORY = 'lota-sdk'
 
 export type LotaLogLevel = 'trace' | 'debug' | 'info' | 'warning' | 'error' | 'fatal'
@@ -46,19 +44,11 @@ function readEnvLogLevel(): LotaLogLevel | null {
   return resolveLotaLogLevel(value)
 }
 
-// Module-level cache: loggers expose a sync `.info(...)` API that must work
-// from both Effect and non-Effect call sites, so the level cannot live in
-// Effect.Config (which requires Effect context to read). `configureLotaLogger`
-// is called once from `buildInfrastructureLayer` with the resolved value.
-let configuredLogLevel: LotaLogLevel = readEnvLogLevel() ?? 'info'
-
-export function configureLotaLogger(logLevel: LotaLogLevel = 'info'): void {
-  configuredLogLevel = logLevel
-}
-
-export function getConfiguredLogLevel(): LotaLogLevel {
-  return configuredLogLevel
-}
+// Loggers expose a sync `.info(...)` API that must work from both Effect
+// and non-Effect call sites, so the level cannot live in Effect.Config
+// (which requires Effect context to read). Resolve once from the environment
+// at module load; hosts set `LOG_LEVEL` before importing the SDK.
+const configuredLogLevel: LotaLogLevel = readEnvLogLevel() ?? 'info'
 
 export function toEffectLogLevel(logLevel: LotaLogLevel): EffectLogLevel {
   switch (logLevel) {
@@ -215,15 +205,6 @@ function getLogEffect(level: LotaLogLevel, message: string): LotaLogEffect {
   }
 }
 
-function runStandaloneLogEffect(effect: LotaLogEffect): void {
-  Effect.runSync(
-    effect.pipe(
-      Effect.provide(Logger.layer([Logger.consolePretty()])),
-      Effect.provideService(References.MinimumLogLevel, toEffectLogLevel(configuredLogLevel)),
-    ),
-  )
-}
-
 function emitConsoleFallback(
   level: LotaLogLevel,
   category: readonly string[],
@@ -241,6 +222,9 @@ function emitConsoleFallback(
   sink(formattedMessage, rest)
 }
 
+const standaloneLoggerLayer = Logger.layer([Logger.consolePretty()])
+const standaloneMinLogLevel = toEffectLogLevel(configuredLogLevel)
+
 function emit(level: LotaLogLevel, category: readonly string[], message: string, fields?: LogFields): void {
   if (!shouldLog(level)) return
 
@@ -248,17 +232,17 @@ function emit(level: LotaLogLevel, category: readonly string[], message: string,
   const annotations = { lotaLogger: category.join(':'), ...buildLogContext(fields) }
   const effect = getLogEffect(level, formattedMessage).pipe(Effect.annotateLogs(annotations))
 
-  // Route through the seated managed runtime so log timestamps stay on the
-  // caller's fiber and inherit its span/log annotations. Pre-bootstrap (no
-  // runtime seated) uses the standalone Effect logger so output stays
-  // consistent with post-bootstrap formatting.
-  const runtime = getOptionalCurrentRuntime()
+  // Loggers run outside any managed runtime: every call provides its own
+  // console logger layer and minimum log level so the emit path does not
+  // depend on ambient runtime state. Effect-native code paths recover spans
+  // and fiber annotations naturally via `Effect.log*`.
   try {
-    if (runtime) {
-      runtime.runFork(effect)
-    } else {
-      runStandaloneLogEffect(effect)
-    }
+    Effect.runSync(
+      effect.pipe(
+        Effect.provide(standaloneLoggerLayer),
+        Effect.provideService(References.MinimumLogLevel, standaloneMinLogLevel),
+      ),
+    )
   } catch {
     emitConsoleFallback(level, category, formattedMessage, annotations)
   }

package/src/config/thread-defaults.ts

@@ -1,6 +1,3 @@
-import { resolveLotaService } from '../effect/runtime'
-import { ThreadConfigServiceTag } from '../effect/services'
-
 export interface ThreadBootstrapWelcomeConfig {
   defaultAgentId: string
   buildMessageText: (params: { userName?: string | null }) => string
@@ -28,16 +25,6 @@ interface ResolvedThreadBootstrapConfig {
 
 export type { ResolvedThreadBootstrapConfig }
 
-let currentThreadBootstrapConfig: ResolvedThreadBootstrapConfig | null = null
-
-export function configureThreadRuntimeDefaults(config: ResolvedThreadBootstrapConfig): void {
-  currentThreadBootstrapConfig = config
-}
-
-export function clearThreadRuntimeDefaults(): void {
-  currentThreadBootstrapConfig = null
-}
-
 function normalizeThreadAgentIds(values: readonly string[]): readonly string[] {
   const seen = new Set<string>()
   const deduped: string[] = []
@@ -80,13 +67,9 @@ export function resolveThreadConfig(params: {
   }
 }
 
-export function getThreadBootstrapConfig(): ResolvedThreadBootstrapConfig {
-  return currentThreadBootstrapConfig ?? resolveLotaService(ThreadConfigServiceTag)
-}
-
 export function resolveOnboardingOwnerAgentId(
   defaultLeadAgentId: string,
-  config: ResolvedThreadBootstrapConfig = getThreadBootstrapConfig(),
+  config: ResolvedThreadBootstrapConfig,
 ): string {
   return config.onboardingWelcome?.defaultAgentId ?? defaultLeadAgentId
 }

package/src/create-runtime.ts

@@ -1,22 +1,26 @@
+import type { Fiber } from 'effect'
 import { Effect, ManagedRuntime } from 'effect'
 import type { Subscriber } from 'resumable-stream/ioredis'
 
+import { AiGatewayTag, bindAiGatewayRuntime } from './ai-gateway/ai-gateway'
 import { computeSchemaFingerprint } from './db/schema-fingerprint'
 import { publishDatabaseBootstrapEffect } from './db/startup'
 import {
+  AgentConfigServiceTag,
+  AgentFactoryServiceTag,
   buildInfrastructureLayer,
-  clearLotaSdkRuntime,
   DatabaseServiceTag as EffectDatabaseService,
   RedisServiceTag as EffectRedisService,
-  setLotaSdkRuntime,
+  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'
 import { buildDomainServiceLayer } from './runtime/domain-layer'
 import type { LotaPlugin, SystemNodeExecutor } from './runtime/plugin-types'
-import { clearRuntimeModuleAccessors, configureRuntimeModuleAccessors } from './runtime/runtime-accessors'
 import { LOTA_RUNTIME_ENV_KEYS, loadLotaRuntimeConfigFromEnv, parseLotaRuntimeConfig } from './runtime/runtime-config'
 import type { LotaRuntimeConfig, ResolvedLotaRuntimeConfig } from './runtime/runtime-config'
 import {
@@ -26,26 +30,34 @@ import {
 } from './runtime/runtime-lifecycle'
 import { buildRuntimeServiceSurface } from './runtime/runtime-services'
 import type { LotaRuntimeLota, LotaRuntimeServices } from './runtime/runtime-services'
-import { acquireRuntimeTokenEffect, isRuntimeTokenActive, releaseRuntimeToken } from './runtime/runtime-token'
 import type { LotaRuntimeWorkers } from './runtime/runtime-worker-registry'
 import { buildRuntimeWorkerRegistry } from './runtime/runtime-worker-registry'
 import type { LotaRuntimeSocialChat } from './runtime/social-chat/social-chat'
 import { createSocialChatRuntime } from './runtime/social-chat/social-chat'
+import { AutonomousJobServiceTag } from './services/autonomous-job.service'
+import { ContextCompactionServiceTag } from './services/context-compaction.service'
 import { LearnedSkillServiceTag } from './services/learned-skill.service'
 import { MemoryServiceTag } from './services/memory/memory.service'
+import { PlanAgentHeartbeatServiceTag } from './services/plan/plan-agent-heartbeat.service'
+import { PlanCycleServiceTag } from './services/plan/plan-cycle.service'
+import { PlanDeadlineServiceTag } from './services/plan/plan-deadline.service'
+import { PlanExecutorServiceTag } from './services/plan/plan-executor.service'
+import { PlanSchedulerServiceTag } from './services/plan/plan-scheduler.service'
+import { RecentActivityTitleServiceTag } from './services/recent-activity-title.service'
 import { SocialChatHistoryServiceTag } from './services/social-chat-history.service'
 import { getBuiltInSystemExecutors } from './services/system-executor.service'
+import { ThreadTitleServiceTag } from './services/thread/thread-title.service'
 import { ThreadTurnServiceTag } from './services/thread/thread-turn'
-
-// Re-exported for consumers that reason about the runtime slot without
-// instantiating one (e.g., diagnostic harnesses).
-export { isRuntimeTokenActive }
+import { ThreadServiceTag } from './services/thread/thread.service'
 
 export interface LotaRuntime {
   /** Run an Effect as a Promise through the SDK runtime (carries OTLP context). */
-  runPromise: <A, E>(effect: Effect.Effect<A, E>, options?: { readonly signal?: AbortSignal }) => Promise<A>
+  runPromise: <A, E, R>(effect: Effect.Effect<A, E, R>, options?: { readonly signal?: AbortSignal }) => Promise<A>
   /** Run an Effect synchronously through the SDK runtime. */
-  runSync: <A, E>(effect: Effect.Effect<A, E>) => A
+  runSync: <A, E, R>(effect: Effect.Effect<A, E, R>) => A
+  /** Fork an Effect as a Fiber through the SDK runtime (carries OTLP context). */
+  // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
+  runFork: <A, E, R>(effect: Effect.Effect<A, E, R>) => Fiber.Fiber<A, E | unknown>
   services: LotaRuntimeServices
   lota: LotaRuntimeLota
   redis: {
@@ -77,14 +89,10 @@ export function createLotaRuntimeFromEnv(
 }
 
 export function createLotaRuntime(config: LotaRuntimeConfig): Promise<LotaRuntime> {
-  let runtimeToken: symbol | null = null
   let effectRuntime: { dispose(): Promise<void> } | null = null
 
   return Effect.runPromise(
     Effect.gen(function* () {
-      // Fail fast if another runtime is already active in this process.
-      runtimeToken = yield* acquireRuntimeTokenEffect()
-
       const resolvedConfig = parseLotaRuntimeConfig(config)
       const systemExecutors = { ...getBuiltInSystemExecutors(), ...resolvedConfig.systemExecutors }
       const runtimeConfig = { ...resolvedConfig, systemExecutors } satisfies ResolvedLotaRuntimeConfig
@@ -121,6 +129,22 @@ export function createLotaRuntime(config: LotaRuntimeConfig): Promise<LotaRuntim
                 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,
               }
             }),
           ),
@@ -138,10 +162,32 @@ export function createLotaRuntime(config: LotaRuntimeConfig): Promise<LotaRuntim
         socialChatHistoryService,
         learnedSkillService,
         memoryService,
+        runtimeAdapters,
+        agentConfig,
+        agentFactoryConfig,
+        queues,
+        autonomousJobService,
+        contextCompactionService,
+        threadService,
+        planAgentHeartbeatService,
+        planSchedulerService,
+        planDeadlineService,
+        planExecutorService,
+        planCycleService,
+        threadTitleService,
+        recentActivityTitleService,
+        aiGateway,
+        runtimeConfigService,
       } = resolvedServices
 
-      setLotaSdkRuntime(managedRuntime)
-      configureRuntimeModuleAccessors({ managedRuntime, runtimeConfig, redisManager })
+      // 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 ?? {}
@@ -164,13 +210,33 @@ export function createLotaRuntime(config: LotaRuntimeConfig): Promise<LotaRuntim
         pluginRuntime,
         connectedPluginDatabases,
       )
-      const workers = buildRuntimeWorkerRegistry(runtimeConfig.extraWorkers)
+      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 },
+        services: { learnedSkillService, memoryService, socialChatHistoryService, runtimeAdapters, queues },
       })
       const currentContext = yield* Effect.context()
       const runPromiseWithCurrentContext = Effect.runPromiseWith(currentContext)
@@ -190,16 +256,15 @@ export function createLotaRuntime(config: LotaRuntimeConfig): Promise<LotaRuntim
         runPromiseWithCurrentContext,
         socialChatShutdown: () => socialChat.shutdown(),
         disconnectPluginDatabases,
-        onFinalize: () => {
-          clearRuntimeModuleAccessors()
-          clearLotaSdkRuntime()
-          if (runtimeToken) releaseRuntimeToken(runtimeToken)
-        },
       })
 
       const lotaRuntime: LotaRuntime = {
-        runPromise: (effect, options) => managedRuntime.runPromise(effect, options),
-        runSync: (effect) => managedRuntime.runSync(effect),
+        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: {
@@ -235,11 +300,8 @@ export function createLotaRuntime(config: LotaRuntimeConfig): Promise<LotaRuntim
     }),
   ).catch((error) => {
     if (effectRuntime) {
-      clearRuntimeModuleAccessors()
-      clearLotaSdkRuntime()
       void effectRuntime.dispose().catch(() => undefined)
     }
-    if (runtimeToken) releaseRuntimeToken(runtimeToken)
     throw error
   })
 }

package/src/db/base.service.ts

@@ -1,8 +1,6 @@
 import { Effect } from 'effect'
 import type { z } from 'zod'
 
-import type { AwaitableEffect } from '../effect/awaitable-effect'
-import { toAwaitableEffect } from '../effect/awaitable-effect'
 import { NotFoundError } from '../effect/errors'
 import { ensureRecordId } from './record-id'
 import type { SurrealDBService } from './service'
@@ -16,7 +14,7 @@ export abstract class BaseService<T extends z.ZodType> {
     protected readonly databaseService: SurrealDBService,
   ) {}
 
-  findById(id: unknown): AwaitableEffect<z.infer<T> | null, SurrealDBError> {
+  findById(id: unknown): Effect.Effect<z.infer<T> | null, SurrealDBError, never> {
     return this.databaseService.findOne(
       this.table,
       { id: ensureRecordId(id as Parameters<typeof ensureRecordId>[0], this.table) },
@@ -24,61 +22,55 @@ export abstract class BaseService<T extends z.ZodType> {
     )
   }
 
-  getById(id: unknown): AwaitableEffect<z.infer<T>, SurrealDBError | NotFoundError> {
+  getById(id: unknown): Effect.Effect<z.infer<T>, SurrealDBError | NotFoundError, never> {
     const { table, databaseService, schema } = this
-    return toAwaitableEffect(
-      Effect.gen(function* () {
-        const record = yield* databaseService.findOne(
-          table,
-          { id: ensureRecordId(id as Parameters<typeof ensureRecordId>[0], table) },
-          schema,
-        )
+    return Effect.gen(function* () {
+      const record = yield* databaseService.findOne(
+        table,
+        { id: ensureRecordId(id as Parameters<typeof ensureRecordId>[0], table) },
+        schema,
+      )
 
-        if (!record) {
-          return yield* new NotFoundError({ resource: table, message: `${table} record not found` })
-        }
+      if (!record) {
+        return yield* new NotFoundError({ resource: table, message: `${table} record not found` })
+      }
 
-        return record
-      }),
-    )
+      return record
+    })
   }
 
   findAll(
     filter: Record<string, unknown> = {},
     options?: { limit?: number; offset?: number; orderBy?: keyof z.infer<T> & string; orderDir?: 'ASC' | 'DESC' },
-  ): AwaitableEffect<z.infer<T>[], SurrealDBError> {
+  ): Effect.Effect<z.infer<T>[], SurrealDBError, never> {
     return this.databaseService.findMany(this.table, filter, this.schema, options)
   }
 
-  create(data: Record<string, unknown>): AwaitableEffect<z.infer<T>, SurrealDBError> {
+  create(data: Record<string, unknown>): Effect.Effect<z.infer<T>, SurrealDBError, never> {
     return this.databaseService.create(this.table, data, this.schema)
   }
 
-  update(id: unknown, data: Record<string, unknown>): AwaitableEffect<z.infer<T>, SurrealDBError | NotFoundError> {
+  update(id: unknown, data: Record<string, unknown>): Effect.Effect<z.infer<T>, SurrealDBError | NotFoundError, never> {
     const { table, databaseService, schema } = this
-    return toAwaitableEffect(
-      Effect.gen(function* () {
-        const updated = yield* databaseService.update(table, id, data, schema)
+    return Effect.gen(function* () {
+      const updated = yield* databaseService.update(table, id, data, schema)
 
-        if (!updated) {
-          return yield* new NotFoundError({ resource: table, message: `${table} record not found` })
-        }
+      if (!updated) {
+        return yield* new NotFoundError({ resource: table, message: `${table} record not found` })
+      }
 
-        return updated
-      }),
-    )
+      return updated
+    })
   }
 
-  delete(id: unknown): AwaitableEffect<void, SurrealDBError | NotFoundError> {
+  delete(id: unknown): Effect.Effect<void, SurrealDBError | NotFoundError, never> {
     const { table, databaseService } = this
-    return toAwaitableEffect(
-      Effect.gen(function* () {
-        const deleted = yield* databaseService.deleteById(table, id)
+    return Effect.gen(function* () {
+      const deleted = yield* databaseService.deleteById(table, id)
 
-        if (!deleted) {
-          return yield* new NotFoundError({ resource: table, message: `${table} record not found` })
-        }
-      }),
-    )
+      if (!deleted) {
+        return yield* new NotFoundError({ resource: table, message: `${table} record not found` })
+      }
+    })
   }
 }