@lota-sdk/core 0.4.8 → 0.4.9

package/src/config/logger.ts

@@ -1,27 +1,294 @@
-import type { LogLevel } from '@logtape/logtape'
-import { configure, getAnsiColorFormatter, getConsoleSink, getLogger as getLogTapeLogger } from '@logtape/logtape'
+import { Effect, Logger, References } from 'effect'
 
 const LOG_CATEGORY = 'lota-sdk'
 
-export async function configureLotaLogger(logLevel: LogLevel = 'info'): Promise<void> {
-  const formatter = getAnsiColorFormatter({ level: 'FULL' })
+export type LotaLogLevel = 'trace' | 'debug' | 'info' | 'warning' | 'error' | 'fatal'
 
-  await configure({
-    reset: true,
-    sinks: { console: getConsoleSink({ formatter }) },
-    loggers: [
-      { category: ['logtape', 'meta'], lowestLevel: 'warning', sinks: ['console'] },
-      { category: ['server'], lowestLevel: logLevel, sinks: ['console'] },
-      { category: [LOG_CATEGORY], lowestLevel: logLevel, sinks: ['console'] },
-      { category: ['hono'], lowestLevel: logLevel, sinks: ['console'] },
-    ],
-  })
+type LogFields = Record<string, unknown>
+type LotaLogEffect = Effect.Effect<void, never, never>
+type EffectLogLevel = 'Trace' | 'Debug' | 'Info' | 'Warn' | 'Error' | 'Fatal'
+
+export interface LotaLoggerMethod {
+  (message: string, fields?: LogFields): void
+  (strings: TemplateStringsArray, ...values: Array<unknown>): void
+}
+
+export interface LotaLogger {
+  trace: LotaLoggerMethod
+  debug: LotaLoggerMethod
+  info: LotaLoggerMethod
+  warn: LotaLoggerMethod
+  error: LotaLoggerMethod
+  fatal: LotaLoggerMethod
+}
+
+const LOG_LEVEL_PRIORITY: Record<LotaLogLevel, number> = { trace: 0, debug: 1, info: 2, warning: 3, error: 4, fatal: 5 }
+
+export function resolveLotaLogLevel(value: string | null | undefined): LotaLogLevel | null {
+  const normalized = value?.trim().toLowerCase()
+  switch (normalized) {
+    case 'trace':
+    case 'debug':
+    case 'info':
+    case 'warning':
+    case 'error':
+    case 'fatal':
+      return normalized
+    default:
+      return null
+  }
+}
+
+function readEnvLogLevel(): LotaLogLevel | null {
+  const value = Bun.env.LOG_LEVEL?.trim().toLowerCase()
+  return resolveLotaLogLevel(value)
+}
+
+let configuredLogLevel: LotaLogLevel = readEnvLogLevel() ?? 'info'
+
+export function configureLotaLogger(logLevel: LotaLogLevel = 'info'): void {
+  configuredLogLevel = logLevel
+}
+
+export function getConfiguredLogLevel(): LotaLogLevel {
+  return configuredLogLevel
+}
+
+export function toEffectLogLevel(logLevel: LotaLogLevel): EffectLogLevel {
+  switch (logLevel) {
+    case 'trace':
+      return 'Trace'
+    case 'debug':
+      return 'Debug'
+    case 'info':
+      return 'Info'
+    case 'warning':
+      return 'Warn'
+    case 'error':
+      return 'Error'
+    case 'fatal':
+      return 'Fatal'
+  }
+}
+
+function shouldLog(level: LotaLogLevel): boolean {
+  return LOG_LEVEL_PRIORITY[level] >= LOG_LEVEL_PRIORITY[configuredLogLevel]
 }
 
-export function getLogger(category: readonly string[]) {
-  return getLogTapeLogger([...category])
+function isTemplateStringsArray(value: unknown): value is TemplateStringsArray {
+  return Array.isArray(value) && Object.prototype.hasOwnProperty.call(value, 'raw')
 }
 
-export const serverLogger = getLogger([LOG_CATEGORY])
-export const chatLogger = getLogger([LOG_CATEGORY, 'chat'])
-export const aiLogger = getLogger([LOG_CATEGORY, 'ai'])
+function describeObject(value: object): string {
+  return Object.prototype.toString.call(value)
+}
+
+function describeScalar(value: unknown): string {
+  if (value === null) return 'null'
+  if (value === undefined) return 'undefined'
+  if (typeof value === 'symbol') {
+    return value.description ? `Symbol(${value.description})` : 'Symbol'
+  }
+  if (typeof value === 'function') {
+    return `[Function ${value.name || 'anonymous'}]`
+  }
+
+  return JSON.stringify(value)
+}
+
+function normalizeJsonValue(value: unknown): unknown {
+  if (typeof value === 'bigint') return value.toString()
+  if (value instanceof Date) return value.toISOString()
+  if (value instanceof Error) {
+    return { name: value.name, message: value.message, stack: value.stack }
+  }
+  return value
+}
+
+function normalizeAnnotationValue(value: unknown): unknown {
+  if (value === null || value === undefined) return value
+  if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') return value
+  if (typeof value === 'bigint') return value.toString()
+  if (value instanceof Date) return value.toISOString()
+  if (value instanceof Error) {
+    return { name: value.name, message: value.message, stack: value.stack }
+  }
+
+  try {
+    return JSON.parse(JSON.stringify(value, (_key, nestedValue) => normalizeJsonValue(nestedValue)))
+  } catch {
+    return typeof value === 'object' ? describeObject(value) : describeScalar(value)
+  }
+}
+
+function formatLogValue(value: unknown): string {
+  if (value instanceof Error) {
+    return `${value.name}: ${value.message}`
+  }
+  if (typeof value === 'string') return value
+  if (typeof value === 'number' || typeof value === 'boolean' || typeof value === 'bigint') return String(value)
+  if (value === null) return 'null'
+  if (value === undefined) return 'undefined'
+  if (value instanceof Date) return value.toISOString()
+
+  try {
+    return JSON.stringify(normalizeAnnotationValue(value))
+  } catch {
+    return typeof value === 'object' ? describeObject(value) : describeScalar(value)
+  }
+}
+
+function formatTemplate(strings: TemplateStringsArray, values: Array<unknown>): string {
+  let output = ''
+
+  for (let index = 0; index < strings.length; index++) {
+    output += strings[index]
+    if (index < values.length) {
+      output += formatLogValue(values[index])
+    }
+  }
+
+  return output
+}
+
+function applyFieldPlaceholders(message: string, fields?: LogFields): string {
+  if (!fields) return message
+
+  let output = message
+  for (const [key, value] of Object.entries(fields)) {
+    output = output.replaceAll(`{${key}}`, formatLogValue(value))
+  }
+  return output
+}
+
+function buildLogContext(fields?: LogFields): Record<string, unknown> {
+  const context: Record<string, unknown> = {}
+  if (!fields) {
+    return context
+  }
+
+  for (const [key, value] of Object.entries(fields)) {
+    if (value === undefined) continue
+    context[key] = normalizeAnnotationValue(value)
+  }
+
+  return context
+}
+
+function getConsoleMethod(level: LotaLogLevel): (...args: Array<unknown>) => void {
+  switch (level) {
+    case 'trace':
+      return console.trace
+    case 'debug':
+      return console.debug
+    case 'info':
+      return console.info
+    case 'warning':
+      return console.warn
+    case 'error':
+      return console.error
+    case 'fatal':
+      return console.error
+  }
+}
+
+function getLogEffect(level: LotaLogLevel, message: string): LotaLogEffect {
+  switch (level) {
+    case 'trace':
+      return Effect.logTrace(message)
+    case 'debug':
+      return Effect.logDebug(message)
+    case 'info':
+      return Effect.logInfo(message)
+    case 'warning':
+      return Effect.logWarning(message)
+    case 'error':
+      return Effect.logError(message)
+    case 'fatal':
+      return Effect.logFatal(message)
+  }
+}
+
+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,
+): void {
+  if (!shouldLog(level)) return
+
+  const formattedMessage = `[${category.join(':')}] ${message}`
+  const context = buildLogContext(fields)
+  const sink = getConsoleMethod(level)
+  if (Object.keys(context).length === 0) {
+    sink(formattedMessage)
+    return
+  }
+
+  sink(formattedMessage, context)
+}
+
+function emit(level: LotaLogLevel, category: readonly string[], message: string, fields?: LogFields): void {
+  if (!shouldLog(level)) return
+
+  const formattedMessage = applyFieldPlaceholders(message, fields)
+  const annotations = { lotaLogger: category.join(':'), ...buildLogContext(fields) }
+  const effect = getLogEffect(level, formattedMessage).pipe(Effect.annotateLogs(annotations))
+
+  try {
+    runStandaloneLogEffect(effect)
+  } catch {
+    emitConsoleFallback(level, category, formattedMessage, annotations)
+  }
+}
+
+function createLoggerMethod(level: LotaLogLevel, category: readonly string[]): LotaLoggerMethod {
+  return (messageOrStrings: string | TemplateStringsArray, ...values: Array<unknown>) => {
+    if (isTemplateStringsArray(messageOrStrings)) {
+      emit(level, category, formatTemplate(messageOrStrings, values))
+      return
+    }
+
+    const [candidateFields] = values
+    const fields =
+      candidateFields && typeof candidateFields === 'object' && !Array.isArray(candidateFields)
+        ? (candidateFields as LogFields)
+        : undefined
+
+    emit(level, category, messageOrStrings, fields)
+  }
+}
+
+export function getLogger(category: readonly string[]): LotaLogger {
+  return {
+    trace: createLoggerMethod('trace', category),
+    debug: createLoggerMethod('debug', category),
+    info: createLoggerMethod('info', category),
+    warn: createLoggerMethod('warning', category),
+    error: createLoggerMethod('error', category),
+    fatal: createLoggerMethod('fatal', category),
+  }
+}
+
+export const serverLogger: LotaLogger = getLogger([LOG_CATEGORY])
+export const chatLogger: LotaLogger = getLogger([LOG_CATEGORY, 'chat'])
+export const aiLogger: LotaLogger = getLogger([LOG_CATEGORY, 'ai'])
+
+export interface LotaLoggerSet {
+  server: LotaLogger
+  chat: LotaLogger
+  ai: LotaLogger
+}
+
+export function getLotaLoggers(): LotaLoggerSet {
+  return { server: serverLogger, chat: chatLogger, ai: aiLogger }
+}

package/src/config/thread-defaults.ts

@@ -1,3 +1,8 @@
+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
@@ -23,16 +28,9 @@ interface ResolvedThreadBootstrapConfig {
   onboardingWelcome?: ThreadBootstrapWelcomeConfig
 }
 
-const DEFAULT_THREAD_BOOTSTRAP_CONFIG: ResolvedThreadBootstrapConfig = {
-  onboardingDefaultAgents: [],
-  completedDefaultAgents: [],
-  threadTypesAfterOnboarding: [],
-  ensureDefaultGroupOnCompleted: true,
-}
-
-let resolvedThreadBootstrapConfig: ResolvedThreadBootstrapConfig = DEFAULT_THREAD_BOOTSTRAP_CONFIG
+export type { ResolvedThreadBootstrapConfig }
 
-function withDedupedStrings(values: readonly string[]): string[] {
+function normalizeThreadAgentIds(values: readonly string[]): readonly string[] {
   const seen = new Set<string>()
   const deduped: string[] = []
 
@@ -46,27 +44,41 @@ function withDedupedStrings(values: readonly string[]): string[] {
   return deduped
 }
 
-export function configureThreads(params: { agentRoster: readonly string[]; config?: LotaThreadConfig }): void {
+function resolveBootstrapAgentIds(
+  agentRoster: readonly string[],
+  onboardingAgents: readonly string[] | undefined,
+  welcomeAgentId: string | undefined,
+): readonly string[] {
+  return normalizeThreadAgentIds([...(onboardingAgents ?? agentRoster), ...(welcomeAgentId ? [welcomeAgentId] : [])])
+}
+
+export function resolveThreadConfig(params: {
+  agentRoster: readonly string[]
+  config?: LotaThreadConfig
+}): ResolvedThreadBootstrapConfig {
   const bootstrap = params.config?.bootstrap
   const onboardingWelcome = bootstrap?.onboardingWelcome
-  const onboardingDefaultAgents = withDedupedStrings([
-    ...(bootstrap?.onboardingDefaultAgents ?? params.agentRoster),
-    ...(onboardingWelcome ? [onboardingWelcome.defaultAgentId] : []),
-  ])
 
-  resolvedThreadBootstrapConfig = {
-    onboardingDefaultAgents,
-    completedDefaultAgents: withDedupedStrings(bootstrap?.completedDefaultAgents ?? params.agentRoster),
-    threadTypesAfterOnboarding: withDedupedStrings(bootstrap?.threadTypesAfterOnboarding ?? []),
+  return {
+    onboardingDefaultAgents: resolveBootstrapAgentIds(
+      params.agentRoster,
+      bootstrap?.onboardingDefaultAgents,
+      onboardingWelcome?.defaultAgentId,
+    ),
+    completedDefaultAgents: normalizeThreadAgentIds(bootstrap?.completedDefaultAgents ?? params.agentRoster),
+    threadTypesAfterOnboarding: normalizeThreadAgentIds(bootstrap?.threadTypesAfterOnboarding ?? []),
     ensureDefaultGroupOnCompleted: bootstrap?.ensureDefaultGroupOnCompleted ?? true,
     ...(onboardingWelcome ? { onboardingWelcome } : {}),
   }
 }
 
 export function getThreadBootstrapConfig(): ResolvedThreadBootstrapConfig {
-  return resolvedThreadBootstrapConfig
+  return getCurrentRuntime().runSync(Effect.service(ThreadConfigServiceTag))
 }
 
-export function resolveOnboardingOwnerAgentId(defaultLeadAgentId: string): string {
-  return resolvedThreadBootstrapConfig.onboardingWelcome?.defaultAgentId ?? defaultLeadAgentId
+export function resolveOnboardingOwnerAgentId(
+  defaultLeadAgentId: string,
+  config: ResolvedThreadBootstrapConfig = getThreadBootstrapConfig(),
+): string {
+  return config.onboardingWelcome?.defaultAgentId ?? defaultLeadAgentId
 }