@lota-sdk/core 0.4.9 → 0.4.10

package/src/db/startup.ts

@@ -1,5 +1,5 @@
 import { recordIdSchema } from '@lota-sdk/shared'
-import { Duration, Effect, Schedule } from 'effect'
+import { Duration, Effect, Match, Schedule } from 'effect'
 import { BoundQuery, RecordId } from 'surrealdb'
 import { z } from 'zod'
 
@@ -146,35 +146,46 @@ function waitForDatabaseBootstrapEffectInternal(params: {
     }),
   )
 
+  const logFailure = Match.type<BootstrapWaitFailure>().pipe(
+    Match.tag('schema-not-ready', (failure) => {
+      params.logger?.info?.(
+        `Waiting for ${params.label} schema readiness (${attempt}, expected=${expectedFingerprint}, current=${failure.currentFingerprint})`,
+      )
+    }),
+    Match.tag('read-failed', (failure) => {
+      params.logger?.warn?.(
+        `Waiting for ${params.label} schema readiness (${attempt}): ${getErrorMessage(failure.cause)}`,
+      )
+    }),
+    Match.exhaustive,
+  )
+
+  const toTimeoutError = Match.type<BootstrapWaitFailure>().pipe(
+    Match.tag(
+      'schema-not-ready',
+      () => new DatabaseError({ message: `Timed out waiting for ${params.label} schema readiness` }),
+    ),
+    Match.tag(
+      'read-failed',
+      (failure) =>
+        new DatabaseError({ message: `Timed out waiting for ${params.label} schema readiness`, cause: failure.cause }),
+    ),
+    Match.exhaustive,
+  )
+
   return waitForExpectedFingerprint.pipe(
     Effect.tapError((failure) =>
       Effect.sync(() => {
         attempt++
         if (!shouldLogRetry(attempt)) return
-
-        if (failure._tag === 'schema-not-ready') {
-          params.logger?.info?.(
-            `Waiting for ${params.label} schema readiness (${attempt}, expected=${expectedFingerprint}, current=${failure.currentFingerprint})`,
-          )
-          return
-        }
-
-        params.logger?.warn?.(
-          `Waiting for ${params.label} schema readiness (${attempt}): ${getErrorMessage(failure.cause)}`,
-        )
+        logFailure(failure)
       }),
     ),
     Effect.retry({
       times: Math.max(0, Math.ceil(maxWaitMs / retryDelayMs) - 1),
       schedule: Schedule.fixed(Duration.millis(retryDelayMs)),
     }),
-    Effect.mapError(
-      (failure) =>
-        new DatabaseError({
-          message: `Timed out waiting for ${params.label} schema readiness`,
-          ...(failure._tag === 'read-failed' ? { cause: failure.cause } : {}),
-        }),
-    ),
+    Effect.mapError(toTimeoutError),
   )
 }
 

package/src/effect/awaitable-effect.ts

@@ -1,9 +1,5 @@
 import { Effect } from 'effect'
 
-const awaitableEffectMarker = Symbol('AwaitableEffect')
-
-type AwaitableEffectState<A> = { promise?: Promise<A> }
-
 export type AwaitableEffect<A, E> = Effect.Effect<A, E, never> & Promise<A>
 
 export type AwaitableValue<T> = T extends (...args: infer TArgs) => Effect.Effect<infer A, infer E, never>
@@ -22,62 +18,75 @@ export type MaybeAwaitableService<T extends object> = T | AwaitableService<T>
 
 type AwaitableEffectOptions = { runPromise?: <A, E>(effect: Effect.Effect<A, E, never>) => Promise<A> }
 
+type Callable = (...args: Array<unknown>) => unknown
+
+function isCallable(value: unknown): value is Callable {
+  return typeof value === 'function'
+}
+
+function isRuntimeEffect(value: unknown): value is Effect.Effect<unknown, never, never> {
+  return Effect.isEffect(value)
+}
+
+/**
+ * Wraps an Effect so it can be `await`-ed as if it were a Promise, while still
+ * passing `Effect.isEffect` checks and exposing the underlying Effect properties.
+ *
+ * Implementation: returns a `Proxy` around the Effect that only intercepts the
+ * PromiseLike methods (`then`/`catch`/`finally`) plus `Symbol.toStringTag`. The
+ * Promise is created lazily on first `await` and cached for the wrapper's
+ * lifetime so repeated awaits share a result. The original Effect object is
+ * never mutated.
+ */
 export function toAwaitableEffect<A, E>(
   effect: Effect.Effect<A, E, never>,
   options?: AwaitableEffectOptions,
 ): AwaitableEffect<A, E> {
-  const existing = effect as AwaitableEffect<A, E> & { [awaitableEffectMarker]?: AwaitableEffectState<A> }
+  const runPromise = options?.runPromise ?? Effect.runPromise
+  let cachedPromise: Promise<A> | undefined
+  const getPromise = (): Promise<A> => (cachedPromise ??= runPromise(effect))
 
-  if (existing[awaitableEffectMarker]) {
-    return existing
-  }
+  const then: Promise<A>['then'] = (onFulfilled, onRejected) => getPromise().then(onFulfilled, onRejected)
+  const catchMethod: Promise<A>['catch'] = (onRejected) => getPromise().catch(onRejected)
+  const finallyMethod: Promise<A>['finally'] = (onFinally) => getPromise().finally(onFinally)
 
-  const state: AwaitableEffectState<A> = {}
-  const runPromise = options?.runPromise ?? Effect.runPromise
-  const ensurePromise = () => (state.promise ??= runPromise(effect))
-  const candidate = Object.create(
-    Object.getPrototypeOf(effect),
-    Object.getOwnPropertyDescriptors(effect),
-  ) as AwaitableEffect<A, E> & { [awaitableEffectMarker]?: AwaitableEffectState<A> }
-
-  const then: Promise<A>['then'] = (onfulfilled, onrejected) => ensurePromise().then(onfulfilled, onrejected)
-  const catchMethod: Promise<A>['catch'] = (onrejected) => ensurePromise().catch(onrejected)
-  const finallyMethod: Promise<A>['finally'] = (onfinally) => ensurePromise().finally(onfinally)
-
-  void Object.defineProperties(candidate, {
-    then: { value: then, configurable: true },
-    catch: { value: catchMethod, configurable: true },
-    finally: { value: finallyMethod, configurable: true },
-    [Symbol.toStringTag]: { value: 'Promise', configurable: true },
-    [awaitableEffectMarker]: { value: state },
-  })
-
-  return candidate
+  return new Proxy(effect as object, {
+    get(target, property, receiver) {
+      if (property === 'then') return then
+      if (property === 'catch') return catchMethod
+      if (property === 'finally') return finallyMethod
+      if (property === Symbol.toStringTag) return 'Promise'
+      return Reflect.get(target, property, receiver) as unknown
+    },
+  }) as AwaitableEffect<A, E>
 }
 
+/**
+ * Returns a proxy over a service whose Effect-returning methods are
+ * transparently wrapped with `toAwaitableEffect`. Non-Effect return values
+ * pass through untouched.
+ */
 export function toAwaitableService<T extends object>(
   service: T,
   options?: AwaitableEffectOptions,
 ): AwaitableService<T> {
-  const wrappedMethods = new Map<PropertyKey, unknown>()
+  const wrappedMethods = new Map<PropertyKey, Callable>()
 
   return new Proxy(service, {
     get(target, property, receiver) {
       const value = Reflect.get(target, property, receiver)
-      if (typeof value !== 'function') {
+      if (!isCallable(value)) {
         return value
       }
 
       const existing = wrappedMethods.get(property)
-      if (existing !== undefined) {
+      if (existing) {
         return existing
       }
 
-      const wrapped = (...args: unknown[]) => {
-        const result = Reflect.apply(value, target, args)
-        return Effect.isEffect(result)
-          ? toAwaitableEffect(result as Effect.Effect<unknown, unknown, never>, options)
-          : result
+      const wrapped: Callable = (...args) => {
+        const result = value.apply(target, args)
+        return isRuntimeEffect(result) ? toAwaitableEffect(result, options) : result
       }
 
       wrappedMethods.set(property, wrapped)

package/src/effect/helpers.ts

@@ -18,6 +18,12 @@ type PromiseEffectEvaluator<A, E = never, R = never> =
   | (() => PromiseLike<A> | Effect.Effect<A, E, R>)
   | ((signal: AbortSignal) => PromiseLike<A> | Effect.Effect<A, E, R>)
 
+function invokePromiseEffectEvaluator<A, E, R>(
+  evaluate: PromiseEffectEvaluator<A, E, R>,
+): PromiseLike<A> | Effect.Effect<A, E, R> {
+  return (evaluate as () => PromiseLike<A> | Effect.Effect<A, E, R>)()
+}
+
 export function effectTryPromise<A, E = never, R = never>(
   evaluate: PromiseEffectEvaluator<A, E, R>,
 ): Effect.Effect<A, Cause.UnknownError, R>
@@ -31,7 +37,7 @@ export function effectTryPromise<A, E1, E2, R>(
 ): Effect.Effect<A, E2 | Cause.UnknownError, R> {
   return Effect.suspend(() => {
     try {
-      const value = (evaluate as () => PromiseLike<A> | Effect.Effect<A, E1, R>)()
+      const value = invokePromiseEffectEvaluator(evaluate)
       if (Effect.isEffect(value)) {
         if (onError) {
           return value.pipe(Effect.mapError((cause) => onError(cause)))
@@ -49,13 +55,13 @@ export function effectTryPromise<A, E1, E2, R>(
   })
 }
 
-export function effectTryServicePromise<A>(
-  evaluate: PromiseEffectEvaluator<A, unknown, never>,
+export function effectTryServicePromise<A, E = never, R = never>(
+  evaluate: PromiseEffectEvaluator<A, E, R>,
   message: string,
-): Effect.Effect<A, ServiceError, never> {
+): Effect.Effect<A, ServiceError, R> {
   return Effect.suspend(() => {
     try {
-      const value = (evaluate as () => PromiseLike<A> | Effect.Effect<A, unknown, never>)()
+      const value = invokePromiseEffectEvaluator(evaluate)
       if (Effect.isEffect(value)) {
         return value.pipe(Effect.mapError((cause) => new ServiceError({ message, cause })))
       }
@@ -74,6 +80,16 @@ export function makeEffectTryPromiseWithMessage<E>(onError: (message: string, ca
   ): Effect.Effect<A, E, R> => effectTryPromise(evaluate, (cause) => onError(message, cause))
 }
 
+export function makeEffectTryPromiseWithOperation<E>(
+  onError: (operation: string, message: string, cause: unknown) => E,
+) {
+  return <A, E1 = never, R = never>(
+    operation: string,
+    message: string,
+    evaluate: PromiseEffectEvaluator<A, E1, R>,
+  ): Effect.Effect<A, E, R> => effectTryPromise(evaluate, (cause) => onError(operation, message, cause))
+}
+
 export function effectTryMaybeAsync<A>(evaluate: () => A | PromiseLike<A>): Effect.Effect<A, Cause.UnknownError, never>
 export function effectTryMaybeAsync<A, E>(
   evaluate: () => A | PromiseLike<A>,
@@ -96,3 +112,12 @@ export function effectTryMaybeAsync<A, E>(
     }
   })
 }
+
+export function iterateEffect<A, E, R>(
+  initial: A,
+  options: { while: (state: A) => boolean; body: (state: A) => Effect.Effect<A, E, R> },
+): Effect.Effect<A, E, R> {
+  const step = (state: A): Effect.Effect<A, E, R> =>
+    options.while(state) ? options.body(state).pipe(Effect.flatMap(step)) : Effect.succeed(state)
+  return Effect.suspend(() => step(initial))
+}

package/src/effect/index.ts

@@ -6,17 +6,19 @@ export * from './services'
 export * from './zod'
 export {
   ActiveThreadRunConflictError,
+  AiGenerationError,
+  BaseServicePersistenceError,
   ConfigurationError,
   ConflictError,
   DatabaseError,
+  ForbiddenError,
   LockAcquisitionError,
   LockLostError,
   RedisError,
-  isEffectError,
-  ThreadTurnError as EffectThreadTurnError,
+  ServiceError,
+  ThreadTurnError,
   TimeoutError,
-  ValidationError as EffectValidationError,
-  BadRequestError as EffectBadRequestError,
-  NotFoundError as EffectNotFoundError,
+  ValidationError,
+  isEffectError,
 } from './errors'
 export type { EffectError, ValidationIssue } from './errors'

package/src/effect/layers.ts

@@ -1,5 +1,8 @@
 import type { ToolSet } from 'ai'
 import { Effect, Layer, Logger, References } from 'effect'
+import { DevTools } from 'effect/unstable/devtools'
+import { FetchHttpClient } from 'effect/unstable/http'
+import { Otlp } from 'effect/unstable/observability'
 
 import type { CoreThreadProfile } from '../config/agent-defaults'
 import { resolveAgentConfig, resolveAgentFactoryConfig } from '../config/agent-defaults'
@@ -12,14 +15,13 @@ import { LOTA_SDK_DATABASE_NAME } from '../db/sdk-database'
 import type { SurrealDatabaseConfig } from '../db/service'
 import { SurrealDBService } from '../db/service'
 import type { CreateRedisConnectionManagerOptions } from '../redis/connection'
-import { createRedisConnectionManager } from '../redis/connection'
+import { makeRedisConnectionManager } from '../redis/connection'
 import type { ResolvedLotaRuntimeConfig } from '../runtime/runtime-config'
 import type { LotaRuntimeAdapters, LotaRuntimeTurnHooks } from '../runtime/runtime-extensions'
 import type { LotaRuntimeWorkerExtensions } from '../runtime/runtime-worker-registry'
 import { QueueJobServiceLive } from '../services/queue-job.service'
 import { getErrorMessage } from '../utils/errors'
-import { DatabaseError, RedisError } from './errors'
-import { effectTryServicePromise } from './helpers'
+import { DatabaseError } from './errors'
 import {
   AppLoggerTag,
   AgentConfigServiceTag,
@@ -61,36 +63,23 @@ export function DatabaseLive(config: SurrealDatabaseConfig) {
 }
 
 export function RedisLive(config: CreateRedisConnectionManagerOptions) {
-  return Layer.effect(
-    RedisServiceTag,
-    Effect.acquireRelease(
-      Effect.try({
-        try: () => createRedisConnectionManager(config),
-        catch: (error) =>
-          new RedisError({
-            message: `Failed to create Redis connection manager: ${getErrorMessage(error)}`,
-            cause: error,
-          }),
-      }),
-      (redisManager) =>
-        Effect.ignore(
-          effectTryServicePromise(
-            () => redisManager.closeConnection(),
-            'Failed to close Redis connection manager',
-          ).pipe(
-            Effect.tapError((error) =>
-              Effect.logWarning(`Failed to clean up Redis connection manager: ${getErrorMessage(error)}`),
-            ),
-          ),
-        ),
-    ),
-  )
+  return Layer.effect(RedisServiceTag, makeRedisConnectionManager(config))
 }
 
 export function AppLoggerLive(level: LotaLogLevel = 'info') {
+  // Sequence `configureLotaLogger(level)` before `getLotaLoggers()` inside a
+  // single Effect.sync so the log-level mutation is observed when the loggers
+  // are assembled. `Layer.mergeAll` builds in parallel, so splitting these
+  // across two sub-layers is an ordering hazard.
+  const AppLoggersLayer = Layer.effect(
+    AppLoggerTag,
+    Effect.sync(() => {
+      configureLotaLogger(level)
+      return getLotaLoggers()
+    }),
+  )
   return Layer.mergeAll(
-    Layer.effectDiscard(Effect.sync(() => configureLotaLogger(level))),
-    Layer.succeed(AppLoggerTag, getLotaLoggers()),
+    AppLoggersLayer,
     Logger.layer([Logger.consolePretty()]),
     Layer.succeed(References.MinimumLogLevel, toEffectLogLevel(level)),
   )
@@ -143,12 +132,17 @@ export function RuntimeExtensionsLive(params: {
 // ── Shared Infrastructure Layer Builders ─────────────────────────────
 
 /**
- * Builds the full infrastructure layer used by `createLotaRuntime`.
- * Contains all config, database, redis, agent, thread, and extension layers.
+ * Common config-to-Layer conversions shared by the runtime and sandboxed
+ * worker infrastructure builders. Covers logging, runtime config, agents,
+ * threads, database, and redis. Agent display names are overridable for
+ * the socialChat agent injection flow.
  */
-export function buildInfrastructureLayer(
+function buildBaseConfigLayers(
   runtimeConfig: ResolvedLotaRuntimeConfig,
-  options: { resolvedAgentDisplayNames: Record<string, string>; observabilityLayer: Layer.Layer<never> },
+  options: {
+    resolvedAgentDisplayNames?: Record<string, string>
+    runtimeExtensions: Parameters<typeof RuntimeExtensionsLive>[0]
+  },
 ) {
   return Layer.mergeAll(
     AppLoggerLive(runtimeConfig.logging.level),
@@ -156,7 +150,7 @@ export function buildInfrastructureLayer(
     AgentConfigLive({
       roster: runtimeConfig.agents.roster,
       leadAgentId: runtimeConfig.agents.leadAgentId,
-      displayNames: options.resolvedAgentDisplayNames,
+      displayNames: options.resolvedAgentDisplayNames ?? runtimeConfig.agents.displayNames,
       shortDisplayNames: runtimeConfig.agents.shortDisplayNames,
       descriptions: runtimeConfig.agents.descriptions,
       routerModelId: runtimeConfig.agents.routerModelId,
@@ -170,12 +164,7 @@ export function buildInfrastructureLayer(
       pluginRuntime: runtimeConfig.pluginRuntime,
     }),
     ThreadConfigLive({ agentRoster: runtimeConfig.agents.roster, config: runtimeConfig.threads }),
-    RuntimeExtensionsLive({
-      adapters: runtimeConfig.runtimeAdapters,
-      turnHooks: runtimeConfig.turnHooks,
-      toolProviders: runtimeConfig.toolProviders ?? {},
-      extraWorkers: runtimeConfig.extraWorkers,
-    }),
+    RuntimeExtensionsLive(options.runtimeExtensions),
     DatabaseLive({
       url: runtimeConfig.database.url,
       namespace: runtimeConfig.database.namespace,
@@ -184,45 +173,66 @@ export function buildInfrastructureLayer(
       password: runtimeConfig.database.password,
     }),
     RedisLive({ url: runtimeConfig.redis.url }),
-    options.observabilityLayer,
   )
 }
 
 /**
- * Builds the minimal infrastructure layer used by sandboxed workers.
- * Omits observability and uses empty runtime extensions.
+ * Builds the observability layer (OTLP + DevTools) from a runtime config.
+ * Returns an empty layer when no observability endpoints are configured.
  */
-export function buildWorkerInfrastructureLayer(runtimeConfig: ResolvedLotaRuntimeConfig) {
-  const infrastructureLayer = Layer.mergeAll(
-    AppLoggerLive(runtimeConfig.logging.level),
-    RuntimeConfigLive(runtimeConfig),
-    AgentConfigLive({
-      roster: runtimeConfig.agents.roster,
-      leadAgentId: runtimeConfig.agents.leadAgentId,
-      displayNames: runtimeConfig.agents.displayNames,
-      shortDisplayNames: runtimeConfig.agents.shortDisplayNames,
-      descriptions: runtimeConfig.agents.descriptions,
-      routerModelId: runtimeConfig.agents.routerModelId,
-      teamConsultParticipants: runtimeConfig.agents.teamConsultParticipants,
-      getCoreThreadProfile: runtimeConfig.agents.getCoreThreadProfile,
-    }),
-    AgentFactoryLive({
-      createAgent: runtimeConfig.agents.createAgent,
-      buildAgentTools: runtimeConfig.agents.buildAgentTools,
-      getAgentRuntimeConfig: runtimeConfig.agents.getAgentRuntimeConfig,
-      pluginRuntime: runtimeConfig.pluginRuntime,
-    }),
-    ThreadConfigLive({ agentRoster: runtimeConfig.agents.roster, config: runtimeConfig.threads }),
-    RuntimeExtensionsLive({}),
-    DatabaseLive({
-      url: runtimeConfig.database.url,
-      namespace: runtimeConfig.database.namespace,
-      database: LOTA_SDK_DATABASE_NAME,
-      username: runtimeConfig.database.username,
-      password: runtimeConfig.database.password,
+function buildObservabilityLayer(runtimeConfig: ResolvedLotaRuntimeConfig): Layer.Layer<never> {
+  let layer: Layer.Layer<never> = Layer.empty
+  const observability = runtimeConfig.observability
+
+  if (observability.otlpBaseUrl) {
+    layer = Layer.merge(
+      layer,
+      Otlp.layerJson({
+        baseUrl: observability.otlpBaseUrl,
+        resource: {
+          serviceName: observability.serviceName,
+          ...(observability.serviceVersion ? { serviceVersion: observability.serviceVersion } : {}),
+        },
+        ...(observability.otlpHeaders ? { headers: observability.otlpHeaders } : {}),
+      }).pipe(Layer.provide(FetchHttpClient.layer)),
+    )
+  }
+
+  if (observability.devToolsUrl && Bun.env.NODE_ENV !== 'production') {
+    layer = Layer.merge(layer, DevTools.layer(observability.devToolsUrl))
+  }
+
+  return layer
+}
+
+/**
+ * Builds the full infrastructure layer used by `createLotaRuntime`. Combines
+ * all config, database, redis, agent, thread, and extension layers with the
+ * observability layer computed from the runtime config.
+ */
+export function buildInfrastructureLayer(
+  runtimeConfig: ResolvedLotaRuntimeConfig,
+  options: { resolvedAgentDisplayNames: Record<string, string> },
+) {
+  return Layer.mergeAll(
+    buildBaseConfigLayers(runtimeConfig, {
+      resolvedAgentDisplayNames: options.resolvedAgentDisplayNames,
+      runtimeExtensions: {
+        adapters: runtimeConfig.runtimeAdapters,
+        turnHooks: runtimeConfig.turnHooks,
+        toolProviders: runtimeConfig.toolProviders ?? {},
+        extraWorkers: runtimeConfig.extraWorkers,
+      },
     }),
-    RedisLive({ url: runtimeConfig.redis.url }),
+    buildObservabilityLayer(runtimeConfig),
   )
+}
 
+/**
+ * Builds the minimal infrastructure layer used by sandboxed workers.
+ * Omits observability and uses empty runtime extensions.
+ */
+export function buildWorkerInfrastructureLayer(runtimeConfig: ResolvedLotaRuntimeConfig) {
+  const infrastructureLayer = buildBaseConfigLayers(runtimeConfig, { runtimeExtensions: {} })
   return QueueJobServiceLive.pipe(Layer.provideMerge(infrastructureLayer))
 }

package/src/effect/runtime.ts

@@ -1,4 +1,5 @@
-import type { Effect, ManagedRuntime } from 'effect'
+import { Effect } from 'effect'
+import type { Context, ManagedRuntime } from 'effect'
 
 import { clearCurrentRuntime, getCurrentRuntime, getOptionalCurrentRuntime, setCurrentRuntime } from './runtime-ref'
 
@@ -19,12 +20,26 @@ export function getLotaSdkRuntime() {
   return getCurrentRuntime()
 }
 
+export function resolveLotaService<I, T>(tag: Context.Key<I, T>): T {
+  return getCurrentRuntime().runSync(Effect.service(tag))
+}
+
+export function resolveOptionalLotaService<I, T>(tag: Context.Key<I, T>): T | null {
+  const runtime = getOptionalCurrentRuntime()
+  return runtime ? runtime.runSync(Effect.service(tag)) : null
+}
+
+export function runPromiseWithOptionalLotaRuntime<A, E>(effect: Effect.Effect<A, E, never>): Promise<A> {
+  const runtime = getOptionalCurrentRuntime()
+  return runtime ? runtime.runPromise(effect) : Effect.runPromise(effect)
+}
+
 /**
  * Run an effect as a Promise using the current managed runtime's context.
  * The runtime must be initialized via `createLotaRuntime()` before any call.
  */
-export function runPromise<A, E>(
-  effect: Effect.Effect<A, E, never>,
+export function runPromise<A, E, R>(
+  effect: Effect.Effect<A, E, R>,
   options?: { readonly signal?: AbortSignal },
 ): Promise<A> {
   return getCurrentRuntime().runPromise(effect, options)

package/src/effect/services.ts

@@ -11,18 +11,22 @@ import type { ResolvedLotaRuntimeConfig } from '../runtime/runtime-config'
 import type { LotaRuntimeAdapters, LotaRuntimeTurnHooks } from '../runtime/runtime-extensions'
 import type { LotaRuntimeWorkerExtensions } from '../runtime/runtime-worker-registry'
 
-export class DatabaseServiceTag extends Context.Service<DatabaseServiceTag, SurrealDBService>()('DatabaseService') {}
+export class DatabaseServiceTag extends Context.Service<DatabaseServiceTag, SurrealDBService>()(
+  '@lota-sdk/core/DatabaseService',
+) {}
 
-export class RedisServiceTag extends Context.Service<RedisServiceTag, RedisConnectionManager>()('RedisService') {}
+export class RedisServiceTag extends Context.Service<RedisServiceTag, RedisConnectionManager>()(
+  '@lota-sdk/core/RedisService',
+) {}
 
-export class AppLoggerTag extends Context.Service<AppLoggerTag, LotaLoggerSet>()('AppLogger') {}
+export class AppLoggerTag extends Context.Service<AppLoggerTag, LotaLoggerSet>()('@lota-sdk/core/AppLogger') {}
 
 export class RuntimeConfigServiceTag extends Context.Service<RuntimeConfigServiceTag, ResolvedLotaRuntimeConfig>()(
-  'RuntimeConfigService',
+  '@lota-sdk/core/RuntimeConfigService',
 ) {}
 
 export class AgentConfigServiceTag extends Context.Service<AgentConfigServiceTag, ResolvedAgentConfig>()(
-  'AgentConfigService',
+  '@lota-sdk/core/AgentConfigService',
 ) {}
 
 export class AgentFactoryServiceTag extends Context.Service<
@@ -33,25 +37,25 @@ export class AgentFactoryServiceTag extends Context.Service<
     readonly getAgentRuntimeConfig: AgentRuntimeConfigProvider
     readonly pluginRuntime?: Record<string, unknown>
   }
->()('AgentFactoryService') {}
+>()('@lota-sdk/core/AgentFactoryService') {}
 
 export class ThreadConfigServiceTag extends Context.Service<ThreadConfigServiceTag, ResolvedThreadBootstrapConfig>()(
-  'ThreadConfigService',
+  '@lota-sdk/core/ThreadConfigService',
 ) {}
 
 export class RuntimeAdaptersServiceTag extends Context.Service<RuntimeAdaptersServiceTag, LotaRuntimeAdapters>()(
-  'RuntimeAdaptersService',
+  '@lota-sdk/core/RuntimeAdaptersService',
 ) {}
 
 export class TurnHooksServiceTag extends Context.Service<TurnHooksServiceTag, LotaRuntimeTurnHooks>()(
-  'TurnHooksService',
+  '@lota-sdk/core/TurnHooksService',
 ) {}
 
 export class ToolProvidersServiceTag extends Context.Service<ToolProvidersServiceTag, ToolSet>()(
-  'ToolProvidersService',
+  '@lota-sdk/core/ToolProvidersService',
 ) {}
 
 export class RuntimeWorkerExtensionsServiceTag extends Context.Service<
   RuntimeWorkerExtensionsServiceTag,
   LotaRuntimeWorkerExtensions
->()('RuntimeWorkerExtensionsService') {}
+>()('@lota-sdk/core/RuntimeWorkerExtensionsService') {}