@lota-sdk/core 0.4.9 → 0.4.11

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/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

@@ -1,22 +1,22 @@
-export * from './awaitable-effect'
 export * from './helpers'
 export * from './layers'
-export * from './runtime'
 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,10 +1,13 @@
 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'
 import type { AgentFactory, AgentRuntimeConfigProvider, AgentToolBuilder } from '../config/agent-types'
-import { configureLotaLogger, getLotaLoggers, toEffectLogLevel } from '../config/logger'
+import { getLotaLoggers, toEffectLogLevel } from '../config/logger'
 import type { LotaLogLevel } from '../config/logger'
 import { resolveThreadConfig } from '../config/thread-defaults'
 import type { LotaThreadConfig } from '../config/thread-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,35 +63,15 @@ 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') {
+  // The logger level used by `serverLogger`/`chatLogger`/`aiLogger` is read
+  // once from `LOG_LEVEL` at module load. This layer wires the Effect-side
+  // console logger and minimum level plus the `AppLoggerTag` for callers
+  // that want the logger set from context.
   return Layer.mergeAll(
-    Layer.effectDiscard(Effect.sync(() => configureLotaLogger(level))),
     Layer.succeed(AppLoggerTag, getLotaLoggers()),
     Logger.layer([Logger.consolePretty()]),
     Layer.succeed(References.MinimumLogLevel, toEffectLogLevel(level)),
@@ -143,12 +125,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 +143,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 +157,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 +166,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/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') {}

package/src/embeddings/provider.ts

@@ -2,7 +2,6 @@ import { embed, embedMany } from 'ai'
 import { Schema, Effect } from 'effect'
 
 import { ConfigurationError } from '../effect/errors'
-import { getOptionalCurrentRuntime } from '../effect/runtime-ref'
 import { getDirectOpenRouterProvider, normalizeDirectOpenRouterModelId } from '../openrouter/direct-provider'
 
 const SUPPORTED_EMBEDDING_PREFIXES = ['openai/', 'openrouter/'] as const
@@ -92,11 +91,6 @@ export class ProviderEmbeddings {
     return redisCache.get(this.getModelId(), text)
   }
 
-  private runEffect<A>(effect: Effect.Effect<A, EmbeddingProviderError>): Promise<A> {
-    const runtime = getOptionalCurrentRuntime()
-    return runtime ? runtime.runPromise(effect) : Effect.runPromise(effect)
-  }
-
   embedQuery(text: string): Promise<number[]> {
     const input = text.trim()
     if (!input) return Promise.resolve([])
@@ -105,7 +99,7 @@ export class ProviderEmbeddings {
     const pending = this.inflightEmbeddings.get(dedupKey)
     if (pending) return pending
 
-    const promise = this.runEffect(this.executeEmbedQueryEffect(input))
+    const promise = Effect.runPromise(this.executeEmbedQueryEffect(input))
     this.inflightEmbeddings.set(dedupKey, promise)
     void promise.finally(() => this.inflightEmbeddings.delete(dedupKey))
 
@@ -113,28 +107,28 @@ export class ProviderEmbeddings {
   }
 
   private executeEmbedQueryEffect(input: string): Effect.Effect<number[], EmbeddingProviderError> {
-    const self = this
-
-    return Effect.gen(function* () {
-      const cached = yield* tryEmbeddingPromise('Failed to load cached query embedding.', () =>
-        self.loadCachedEmbedding(input),
-      )
-      if (cached) {
-        return cached
-      }
-
-      const result = yield* tryEmbeddingPromise('Failed to generate query embedding.', () =>
-        self.embedFn({ model: self.getModel(), value: input, maxRetries: 2 }),
-      )
-      const embedding = normalizeEmbedding(result.embedding)
-
-      const redisCache = self.getCache()
-      if (redisCache) {
-        void redisCache.set(self.getModelId(), input, embedding)
-      }
-
-      return embedding
-    }).pipe(Effect.withSpan('ProviderEmbeddings.executeEmbedQuery'))
+    return Effect.gen(
+      function* (this: ProviderEmbeddings) {
+        const cached = yield* tryEmbeddingPromise('Failed to load cached query embedding.', () =>
+          this.loadCachedEmbedding(input),
+        )
+        if (cached) {
+          return cached
+        }
+
+        const result = yield* tryEmbeddingPromise('Failed to generate query embedding.', () =>
+          this.embedFn({ model: this.getModel(), value: input, maxRetries: 2 }),
+        )
+        const embedding = normalizeEmbedding(result.embedding)
+
+        const redisCache = this.getCache()
+        if (redisCache) {
+          void redisCache.set(this.getModelId(), input, embedding)
+        }
+
+        return embedding
+      }.bind(this),
+    ).pipe(Effect.withSpan('ProviderEmbeddings.executeEmbedQuery'))
   }
 
   embedDocuments(values: string[]): Promise<number[][]> {
@@ -150,58 +144,58 @@ export class ProviderEmbeddings {
     }
 
     const uniqueTexts = [...new Set(nonEmptyEntries.map((entry) => entry.value))]
-    return this.runEffect(this.embedDocumentsEffect(normalized, uniqueTexts))
+    return Effect.runPromise(this.embedDocumentsEffect(normalized, uniqueTexts))
   }
 
   private embedDocumentsEffect(
     normalized: string[],
     uniqueTexts: string[],
   ): Effect.Effect<number[][], EmbeddingProviderError> {
-    const self = this
-
-    return Effect.gen(function* () {
-      const embeddingsByText = new Map<string, number[]>()
-      let missingTexts = [...uniqueTexts]
-      const redisCache = self.getCache()
-      const redisResults =
-        redisCache && missingTexts.length > 0
-          ? yield* Effect.all(
-              missingTexts.map((text) =>
-                tryEmbeddingPromise('Failed to load cached document embedding.', () =>
-                  redisCache.get(self.getModelId(), text),
-                ).pipe(Effect.map((embedding) => ({ text, embedding }))),
-              ),
-            )
-          : ([] as Array<{ text: string; embedding: number[] | null }>)
-
-      if (redisCache && missingTexts.length > 0) {
-        missingTexts = []
-        for (const result of redisResults) {
-          if (!result.embedding) {
-            missingTexts.push(result.text)
-            continue
+    return Effect.gen(
+      function* (this: ProviderEmbeddings) {
+        const embeddingsByText = new Map<string, number[]>()
+        let missingTexts = [...uniqueTexts]
+        const redisCache = this.getCache()
+        const redisResults =
+          redisCache && missingTexts.length > 0
+            ? yield* Effect.all(
+                missingTexts.map((text) =>
+                  tryEmbeddingPromise('Failed to load cached document embedding.', () =>
+                    redisCache.get(this.getModelId(), text),
+                  ).pipe(Effect.map((embedding) => ({ text, embedding }))),
+                ),
+              )
+            : ([] as Array<{ text: string; embedding: number[] | null }>)
+
+        if (redisCache && missingTexts.length > 0) {
+          missingTexts = []
+          for (const result of redisResults) {
+            if (!result.embedding) {
+              missingTexts.push(result.text)
+              continue
+            }
+
+            embeddingsByText.set(result.text, result.embedding)
           }
-
-          embeddingsByText.set(result.text, result.embedding)
         }
-      }
 
-      if (missingTexts.length === 0) {
-        return normalized.map((text) => (text ? (embeddingsByText.get(text) ?? []) : []))
-      }
-
-      const result = yield* tryEmbeddingPromise('Failed to generate document embeddings.', () =>
-        self.embedManyFn({ model: self.getModel(), values: missingTexts, maxRetries: 2 }),
-      )
-      missingTexts.forEach((text, index) => {
-        const embedding = normalizeEmbedding(result.embeddings[index] ?? [])
-        embeddingsByText.set(text, embedding)
-        if (redisCache) {
-          void redisCache.set(self.getModelId(), text, embedding)
+        if (missingTexts.length === 0) {
+          return normalized.map((text) => (text ? (embeddingsByText.get(text) ?? []) : []))
         }
-      })
 
-      return normalized.map((text) => (text ? (embeddingsByText.get(text) ?? []) : []))
-    }).pipe(Effect.withSpan('ProviderEmbeddings.embedDocuments'))
+        const result = yield* tryEmbeddingPromise('Failed to generate document embeddings.', () =>
+          this.embedManyFn({ model: this.getModel(), values: missingTexts, maxRetries: 2 }),
+        )
+        missingTexts.forEach((text, index) => {
+          const embedding = normalizeEmbedding(result.embeddings[index] ?? [])
+          embeddingsByText.set(text, embedding)
+          if (redisCache) {
+            void redisCache.set(this.getModelId(), text, embedding)
+          }
+        })
+
+        return normalized.map((text) => (text ? (embeddingsByText.get(text) ?? []) : []))
+      }.bind(this),
+    ).pipe(Effect.withSpan('ProviderEmbeddings.embedDocuments'))
   }
 }