@lota-sdk/core 0.4.9 → 0.4.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lota-sdk/core",
-  "version": "0.4.9",
+  "version": "0.4.10",
   "type": "module",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
@@ -31,7 +31,7 @@
     "@ai-sdk/openai": "^3.0.53",
     "@chat-adapter/slack": "^4.26.0",
     "@chat-adapter/state-ioredis": "^4.26.0",
-    "@lota-sdk/shared": "0.4.9",
+    "@lota-sdk/shared": "0.4.10",
     "@mendable/firecrawl-js": "^4.18.3",
     "@surrealdb/node": "^3.0.3",
     "ai": "^6.0.167",

package/src/ai/embedding-cache.ts

@@ -107,7 +107,9 @@ export class EmbeddingCache {
   }
 }
 
-export class EmbeddingCacheTag extends Context.Service<EmbeddingCacheTag, EmbeddingCache>()('EmbeddingCache') {}
+export class EmbeddingCacheTag extends Context.Service<EmbeddingCacheTag, EmbeddingCache>()(
+  '@lota-sdk/core/EmbeddingCache',
+) {}
 
 export const EmbeddingCacheLive = Layer.effect(
   EmbeddingCacheTag,

package/src/ai-gateway/ai-gateway.ts

@@ -6,7 +6,7 @@ import { Cause, Clock, Context, Duration, Effect, ExecutionPlan, Fiber, Layer, S
 
 import { DEFAULT_AI_GATEWAY_URL } from '../config/constants'
 import { AiGenerationError, ConfigurationError } from '../effect/errors'
-import { getLotaSdkRuntime } from '../effect/runtime'
+import { resolveLotaService } from '../effect/runtime'
 import { RuntimeConfigServiceTag } from '../effect/services'
 import { getDirectOpenRouterProvider, normalizeDirectOpenRouterModelId } from '../openrouter/direct-provider'
 import { isRecord, readString } from '../utils/string'
@@ -28,12 +28,12 @@ type AiGatewayAttemptResult<A> = { source: string; result: A }
 class AiGatewayGenerateAttempt extends Context.Service<
   AiGatewayGenerateAttempt,
   { readonly execute: Effect.Effect<AiGatewayAttemptResult<AiGatewayGenerateResult>, AiGenerationError> }
->()('AiGatewayGenerateAttempt') {}
+>()('@lota-sdk/core/internal/AiGatewayGenerateAttempt') {}
 
 class AiGatewayStreamAttempt extends Context.Service<
   AiGatewayStreamAttempt,
   { readonly execute: Effect.Effect<AiGatewayAttemptResult<AiGatewayStreamResult>, AiGenerationError> }
->()('AiGatewayStreamAttempt') {}
+>()('@lota-sdk/core/internal/AiGatewayStreamAttempt') {}
 
 const EXPECTED_GATEWAY_KEY_PREFIX = 'sk-bf-'
 const AI_GATEWAY_VIRTUAL_KEY_HEADER = 'x-bf-vk'
@@ -69,6 +69,10 @@ const RETRYABLE_NETWORK_ERROR_PATTERNS = [
   /timed out/i,
 ]
 
+function isAiGenerationError(error: unknown): error is AiGenerationError {
+  return isRecord(error) && error._tag === 'AiGenerationError'
+}
+
 function getNumericField(value: Record<string, unknown>, key: string): number | null {
   const field = value[key]
   if (typeof field === 'number' && Number.isFinite(field)) return field
@@ -156,7 +160,7 @@ function stringifyProviderField(value: unknown, maxLength: number): string | und
 }
 
 function classifyAiGatewayError(source: string, error: unknown): AiGenerationError {
-  if (error instanceof AiGenerationError) {
+  if (isAiGenerationError(error)) {
     return error
   }
 
@@ -465,7 +469,7 @@ function normalizeAiGatewayUrl(value: string): string {
 export class AiGatewayTag extends Context.Service<
   AiGatewayTag,
   { readonly semaphore: Semaphore.Semaphore; readonly provider: ReturnType<typeof createOpenAI> }
->()('AiGateway') {}
+>()('@lota-sdk/core/AiGateway') {}
 
 export const AiGatewayLive = Layer.effect(
   AiGatewayTag,
@@ -487,12 +491,30 @@ export const AiGatewayLive = Layer.effect(
   }),
 )
 
-function resolveFromRuntime<I, T>(tag: Context.Key<I, T>): T {
-  return getLotaSdkRuntime().runSync(Effect.service(tag))
+type AiGatewayRuntimeConfig = Context.Service.Shape<typeof RuntimeConfigServiceTag>
+
+let currentAiGateway: AiGatewayTag['Service'] | null = null
+let currentAiGatewayRuntimeConfig: AiGatewayRuntimeConfig | null = null
+
+export function configureAiGatewayRuntimeAccessors(params: {
+  aiGateway: AiGatewayTag['Service']
+  runtimeConfig: AiGatewayRuntimeConfig
+}): void {
+  currentAiGateway = params.aiGateway
+  currentAiGatewayRuntimeConfig = params.runtimeConfig
+}
+
+export function clearAiGatewayRuntimeAccessors(): void {
+  currentAiGateway = null
+  currentAiGatewayRuntimeConfig = null
 }
 
 function getAiGateway(): AiGatewayTag['Service'] {
-  return resolveFromRuntime(AiGatewayTag)
+  return currentAiGateway ?? resolveLotaService(AiGatewayTag)
+}
+
+function getAiGatewayRuntimeConfig(): AiGatewayRuntimeConfig {
+  return currentAiGatewayRuntimeConfig ?? resolveLotaService(RuntimeConfigServiceTag)
 }
 
 function withAiGatewayConcurrency<A>(effect: Effect.Effect<A, AiGenerationError>): Effect.Effect<A, AiGenerationError> {
@@ -508,6 +530,11 @@ function withAiGatewayStreamConcurrency(
       const currentContext = yield* Effect.context<never>()
       yield* semaphore.take(1)
 
+      // NOTE: manual release intentional — permit outlives Effect scope for the
+      // stream lifetime. The stream consumer drains asynchronously after this
+      // Effect resolves; the permit is released by either the idle-timeout
+      // finalize callback or the error path below. The `released` guard makes
+      // the release idempotent across those paths.
       let released = false
       const release = () => {
         if (released) return
@@ -517,6 +544,7 @@ function withAiGatewayStreamConcurrency(
 
       const attempt = yield* restore(effect).pipe(
         Effect.catchTag('AiGenerationError', (error) => Effect.sync(release).pipe(Effect.andThen(Effect.fail(error)))),
+        Effect.onInterrupt(() => Effect.sync(release)),
       )
 
       return {
@@ -611,12 +639,12 @@ function isOpenRouterModel(modelId: string): boolean {
 }
 
 function hasDirectOpenRouterFallback(modelId: string): boolean {
-  const config = resolveFromRuntime(RuntimeConfigServiceTag)
+  const config = getAiGatewayRuntimeConfig()
   return isOpenRouterModel(modelId) && Boolean(config.aiGateway.openRouterApiKey?.trim())
 }
 
 function getDirectOpenRouterChatModel(modelId: string): AiGatewayLanguageModel {
-  const config = resolveFromRuntime(RuntimeConfigServiceTag)
+  const config = getAiGatewayRuntimeConfig()
   return getDirectOpenRouterProvider(config.aiGateway.openRouterApiKey).chat(normalizeDirectOpenRouterModelId(modelId))
 }
 

package/src/config/agent-defaults.ts

@@ -1,8 +1,7 @@
 import type { ToolSet } from 'ai'
-import { Effect } from 'effect'
 
 import { ConfigurationError } from '../effect/errors'
-import { getCurrentRuntime } from '../effect/runtime-ref'
+import { resolveLotaService } from '../effect/runtime'
 import { AgentConfigServiceTag, AgentFactoryServiceTag } from '../effect/services'
 import type {
   AgentFactory,
@@ -131,12 +130,28 @@ export interface CoreThreadProfile {
   instructions: string
 }
 
+let currentResolvedAgentConfig: ResolvedAgentConfig | null = null
+let currentResolvedAgentFactoryConfig: ResolvedAgentFactoryConfig | null = null
+
+export function configureAgentRuntimeDefaults(params: {
+  agentConfig: ResolvedAgentConfig
+  agentFactoryConfig: ResolvedAgentFactoryConfig
+}): void {
+  currentResolvedAgentConfig = params.agentConfig
+  currentResolvedAgentFactoryConfig = params.agentFactoryConfig
+}
+
+export function clearAgentRuntimeDefaults(): void {
+  currentResolvedAgentConfig = null
+  currentResolvedAgentFactoryConfig = null
+}
+
 function resolveAgentConfigFromRuntime(): ResolvedAgentConfig {
-  return getCurrentRuntime().runSync(Effect.service(AgentConfigServiceTag))
+  return currentResolvedAgentConfig ?? resolveLotaService(AgentConfigServiceTag)
 }
 
 function resolveAgentFactoryConfigFromRuntime(): ResolvedAgentFactoryConfig {
-  return getCurrentRuntime().runSync(Effect.service(AgentFactoryServiceTag))
+  return currentResolvedAgentFactoryConfig ?? resolveLotaService(AgentFactoryServiceTag)
 }
 
 export function getResolvedAgentConfig(): ResolvedAgentConfig {
@@ -220,18 +235,16 @@ export interface AgentMentionMatch {
   length: number
 }
 
-export function extractAgentMentions(
-  message: string,
-  agentConfig: ResolvedAgentConfig = resolveAgentConfigFromRuntime(),
-): AgentMentionMatch[] {
+export function extractAgentMentions(message: string, agentConfig?: ResolvedAgentConfig): AgentMentionMatch[] {
   const matches: AgentMentionMatch[] = []
   if (!message.trim()) return matches
 
+  const resolvedConfig = agentConfig ?? resolveAgentConfigFromRuntime()
   const regex = new RegExp(AGENT_MENTION_REGEX)
   for (const rawMatch of message.matchAll(regex)) {
     const prefix = rawMatch[1]
     const rawAgent = rawMatch[2].toLowerCase()
-    if (!agentConfig.rosterSet.has(rawAgent)) continue
+    if (!resolvedConfig.rosterSet.has(rawAgent)) continue
 
     const index = rawMatch.index + prefix.length
     matches.push({ agent: rawAgent, mention: `@${rawAgent}`, index, length: rawAgent.length + 1 })

package/src/config/agent-types.ts

@@ -1,8 +1,8 @@
+import type { ChatMode, CreateRoutedAgentOptions } from '@lota-sdk/shared'
 import type { ToolLoopAgent, ToolSet } from 'ai'
 
 import type { RecordIdRef } from '../db/record-id'
 import type { AgentRuntimeConfig, AgentRuntimeRuleOptions } from '../runtime/agent-runtime-policy'
-import type { ChatMode, CreateRoutedAgentOptions } from '../runtime/agent-types'
 
 export interface AgentToolBuilderParams {
   agentId: string

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

@@ -1,5 +1,7 @@
 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'
@@ -44,6 +46,10 @@ 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 {
@@ -222,19 +228,17 @@ 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)
 }
 
 function emit(level: LotaLogLevel, category: readonly string[], message: string, fields?: LogFields): void {
@@ -244,8 +248,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()
   try {
-    runStandaloneLogEffect(effect)
+    if (runtime) {
+      runtime.runFork(effect)
+    } else {
+      runStandaloneLogEffect(effect)
+    }
   } catch {
     emitConsoleFallback(level, category, formattedMessage, annotations)
   }

package/src/config/thread-defaults.ts

@@ -1,6 +1,4 @@
-import { Effect } from 'effect'
-
-import { getCurrentRuntime } from '../effect/runtime-ref'
+import { resolveLotaService } from '../effect/runtime'
 import { ThreadConfigServiceTag } from '../effect/services'
 
 export interface ThreadBootstrapWelcomeConfig {
@@ -30,6 +28,16 @@ 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[] = []
@@ -73,7 +81,7 @@ export function resolveThreadConfig(params: {
 }
 
 export function getThreadBootstrapConfig(): ResolvedThreadBootstrapConfig {
-  return getCurrentRuntime().runSync(Effect.service(ThreadConfigServiceTag))
+  return currentThreadBootstrapConfig ?? resolveLotaService(ThreadConfigServiceTag)
 }
 
 export function resolveOnboardingOwnerAgentId(