@lota-sdk/core 0.4.9 → 0.4.11

package/src/config/background-processing.ts

@@ -12,7 +12,7 @@ const DEFAULT_CONFIG: BackgroundProcessingConfig = {
   memoryConsolidationFrequency: 10,
 }
 
-let resolvedConfig: BackgroundProcessingConfig = { ...DEFAULT_CONFIG }
+const resolvedConfig: BackgroundProcessingConfig = { ...DEFAULT_CONFIG }
 
 export function getBackgroundProcessingConfig(): BackgroundProcessingConfig {
   return resolvedConfig

package/src/config/index.ts

@@ -4,5 +4,4 @@ export * from './background-processing'
 export * from './constants'
 export * from './logger'
 export * from './model-constants'
-export * from './search'
 export * from './thread-defaults'

package/src/config/logger.ts

@@ -44,15 +44,11 @@ function readEnvLogLevel(): LotaLogLevel | null {
   return resolveLotaLogLevel(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) {
@@ -209,34 +205,26 @@ 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[],
   message: string,
-  fields?: LogFields,
+  annotations: Record<string, unknown>,
 ): void {
-  if (!shouldLog(level)) return
-
   const formattedMessage = `[${category.join(':')}] ${message}`
-  const context = buildLogContext(fields)
   const sink = getConsoleMethod(level)
-  if (Object.keys(context).length === 0) {
+  const { lotaLogger: _lotaLogger, ...rest } = annotations
+  if (Object.keys(rest).length === 0) {
     sink(formattedMessage)
     return
   }
 
-  sink(formattedMessage, context)
+  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
 
@@ -244,8 +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))
 
+  // 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 {
-    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,8 +1,3 @@
-import { Effect } from 'effect'
-
-import { getCurrentRuntime } from '../effect/runtime-ref'
-import { ThreadConfigServiceTag } from '../effect/services'
-
 export interface ThreadBootstrapWelcomeConfig {
   defaultAgentId: string
   buildMessageText: (params: { userName?: string | null }) => string
@@ -72,13 +67,9 @@ export function resolveThreadConfig(params: {
   }
 }
 
-export function getThreadBootstrapConfig(): ResolvedThreadBootstrapConfig {
-  return getCurrentRuntime().runSync(Effect.service(ThreadConfigServiceTag))
-}
-
 export function resolveOnboardingOwnerAgentId(
   defaultLeadAgentId: string,
-  config: ResolvedThreadBootstrapConfig = getThreadBootstrapConfig(),
+  config: ResolvedThreadBootstrapConfig,
 ): string {
   return config.onboardingWelcome?.defaultAgentId ?? defaultLeadAgentId
 }