@lota-sdk/core 0.4.8 → 0.4.9

package/src/effect/layers.ts

@@ -0,0 +1,228 @@
+import type { ToolSet } from 'ai'
+import { Effect, Layer, Logger, References } from 'effect'
+
+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 type { LotaLogLevel } from '../config/logger'
+import { resolveThreadConfig } from '../config/thread-defaults'
+import type { LotaThreadConfig } from '../config/thread-defaults'
+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 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 {
+  AppLoggerTag,
+  AgentConfigServiceTag,
+  AgentFactoryServiceTag,
+  DatabaseServiceTag,
+  RedisServiceTag,
+  RuntimeAdaptersServiceTag,
+  RuntimeConfigServiceTag,
+  RuntimeWorkerExtensionsServiceTag,
+  ThreadConfigServiceTag,
+  ToolProvidersServiceTag,
+  TurnHooksServiceTag,
+} from './services'
+
+const EMPTY_TOOLS = {} as ToolSet
+const EMPTY_WORKERS: LotaRuntimeWorkerExtensions = {}
+
+export function DatabaseLive(config: SurrealDatabaseConfig) {
+  return Layer.effect(
+    DatabaseServiceTag,
+    Effect.acquireRelease(
+      Effect.try({
+        try: () => new SurrealDBService(config),
+        catch: (error) =>
+          new DatabaseError({ message: `Failed to create database service: ${getErrorMessage(error)}`, cause: error }),
+      }),
+      (databaseService) =>
+        Effect.ignore(
+          databaseService
+            .disconnect()
+            .pipe(
+              Effect.tapError((error) =>
+                Effect.logWarning(`Failed to clean up database service: ${getErrorMessage(error)}`),
+              ),
+            ),
+        ),
+    ),
+  )
+}
+
+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)}`),
+            ),
+          ),
+        ),
+    ),
+  )
+}
+
+export function AppLoggerLive(level: LotaLogLevel = 'info') {
+  return Layer.mergeAll(
+    Layer.effectDiscard(Effect.sync(() => configureLotaLogger(level))),
+    Layer.succeed(AppLoggerTag, getLotaLoggers()),
+    Logger.layer([Logger.consolePretty()]),
+    Layer.succeed(References.MinimumLogLevel, toEffectLogLevel(level)),
+  )
+}
+
+export function RuntimeConfigLive(config: ResolvedLotaRuntimeConfig) {
+  return Layer.succeed(RuntimeConfigServiceTag, config)
+}
+
+export function AgentConfigLive(config: {
+  roster: readonly string[]
+  leadAgentId: string
+  displayNames: Record<string, string>
+  shortDisplayNames?: Record<string, string>
+  descriptions?: Record<string, string>
+  routerModelId?: string
+  teamConsultParticipants: readonly string[]
+  getCoreThreadProfile?: (coreType: string) => CoreThreadProfile
+}) {
+  return Layer.succeed(AgentConfigServiceTag, resolveAgentConfig(config))
+}
+
+export function AgentFactoryLive(config: {
+  createAgent?: AgentFactory
+  buildAgentTools?: AgentToolBuilder
+  getAgentRuntimeConfig?: AgentRuntimeConfigProvider
+  pluginRuntime?: Record<string, unknown>
+}) {
+  return Layer.succeed(AgentFactoryServiceTag, resolveAgentFactoryConfig(config))
+}
+
+export function ThreadConfigLive(params: { agentRoster: readonly string[]; config?: LotaThreadConfig }) {
+  return Layer.succeed(ThreadConfigServiceTag, resolveThreadConfig(params))
+}
+
+export function RuntimeExtensionsLive(params: {
+  adapters?: LotaRuntimeAdapters
+  turnHooks?: LotaRuntimeTurnHooks
+  toolProviders?: ToolSet
+  extraWorkers?: LotaRuntimeWorkerExtensions
+}) {
+  return Layer.mergeAll(
+    Layer.succeed(RuntimeAdaptersServiceTag, params.adapters ?? {}),
+    Layer.succeed(TurnHooksServiceTag, params.turnHooks ?? {}),
+    Layer.succeed(ToolProvidersServiceTag, params.toolProviders ?? EMPTY_TOOLS),
+    Layer.succeed(RuntimeWorkerExtensionsServiceTag, params.extraWorkers ?? EMPTY_WORKERS),
+  )
+}
+
+// ── Shared Infrastructure Layer Builders ─────────────────────────────
+
+/**
+ * Builds the full infrastructure layer used by `createLotaRuntime`.
+ * Contains all config, database, redis, agent, thread, and extension layers.
+ */
+export function buildInfrastructureLayer(
+  runtimeConfig: ResolvedLotaRuntimeConfig,
+  options: { resolvedAgentDisplayNames: Record<string, string>; observabilityLayer: Layer.Layer<never> },
+) {
+  return Layer.mergeAll(
+    AppLoggerLive(runtimeConfig.logging.level),
+    RuntimeConfigLive(runtimeConfig),
+    AgentConfigLive({
+      roster: runtimeConfig.agents.roster,
+      leadAgentId: runtimeConfig.agents.leadAgentId,
+      displayNames: options.resolvedAgentDisplayNames,
+      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({
+      adapters: runtimeConfig.runtimeAdapters,
+      turnHooks: runtimeConfig.turnHooks,
+      toolProviders: runtimeConfig.toolProviders ?? {},
+      extraWorkers: runtimeConfig.extraWorkers,
+    }),
+    DatabaseLive({
+      url: runtimeConfig.database.url,
+      namespace: runtimeConfig.database.namespace,
+      database: LOTA_SDK_DATABASE_NAME,
+      username: runtimeConfig.database.username,
+      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.
+ */
+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,
+    }),
+    RedisLive({ url: runtimeConfig.redis.url }),
+  )
+
+  return QueueJobServiceLive.pipe(Layer.provideMerge(infrastructureLayer))
+}

package/src/effect/runtime-ref.ts

@@ -0,0 +1,25 @@
+import type { ManagedRuntime } from 'effect'
+
+// eslint-disable-next-line typescript-eslint/no-explicit-any -- ManagedRuntime is contravariant in R; `any` is the only valid wildcard
+type SdkManagedRuntime = ManagedRuntime.ManagedRuntime<any, any>
+
+let currentRuntime: SdkManagedRuntime | null = null
+
+export function setCurrentRuntime<R, E>(runtime: ManagedRuntime.ManagedRuntime<R, E>): void {
+  currentRuntime = runtime as SdkManagedRuntime
+}
+
+export function clearCurrentRuntime(): void {
+  currentRuntime = null
+}
+
+export function getCurrentRuntime(): SdkManagedRuntime {
+  if (!currentRuntime) {
+    throw new Error('Lota Effect runtime is not configured. Call createLotaRuntime() first.')
+  }
+  return currentRuntime
+}
+
+export function getOptionalCurrentRuntime(): SdkManagedRuntime | null {
+  return currentRuntime
+}

package/src/effect/runtime.ts

@@ -0,0 +1,31 @@
+import type { Effect, ManagedRuntime } from 'effect'
+
+import { clearCurrentRuntime, getCurrentRuntime, getOptionalCurrentRuntime, setCurrentRuntime } from './runtime-ref'
+
+export function setLotaSdkRuntime<R, E>(runtime: ManagedRuntime.ManagedRuntime<R, E>): void {
+  setCurrentRuntime(runtime)
+}
+
+export function clearLotaSdkRuntime(): void {
+  clearCurrentRuntime()
+}
+
+export function getOptionalLotaSdkRuntime() {
+  return getOptionalCurrentRuntime()
+}
+
+/** Returns the current managed runtime or throws. */
+export function getLotaSdkRuntime() {
+  return getCurrentRuntime()
+}
+
+/**
+ * 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>,
+  options?: { readonly signal?: AbortSignal },
+): Promise<A> {
+  return getCurrentRuntime().runPromise(effect, options)
+}

package/src/effect/services.ts

@@ -0,0 +1,57 @@
+import type { ToolSet } from 'ai'
+import { Context } from 'effect'
+
+import type { ResolvedAgentConfig } from '../config/agent-defaults'
+import type { AgentFactory, AgentRuntimeConfigProvider, AgentToolBuilder } from '../config/agent-types'
+import type { LotaLoggerSet } from '../config/logger'
+import type { ResolvedThreadBootstrapConfig } from '../config/thread-defaults'
+import type { SurrealDBService } from '../db/service'
+import type { RedisConnectionManager } 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'
+
+export class DatabaseServiceTag extends Context.Service<DatabaseServiceTag, SurrealDBService>()('DatabaseService') {}
+
+export class RedisServiceTag extends Context.Service<RedisServiceTag, RedisConnectionManager>()('RedisService') {}
+
+export class AppLoggerTag extends Context.Service<AppLoggerTag, LotaLoggerSet>()('AppLogger') {}
+
+export class RuntimeConfigServiceTag extends Context.Service<RuntimeConfigServiceTag, ResolvedLotaRuntimeConfig>()(
+  'RuntimeConfigService',
+) {}
+
+export class AgentConfigServiceTag extends Context.Service<AgentConfigServiceTag, ResolvedAgentConfig>()(
+  'AgentConfigService',
+) {}
+
+export class AgentFactoryServiceTag extends Context.Service<
+  AgentFactoryServiceTag,
+  {
+    readonly createAgent: AgentFactory
+    readonly buildAgentTools: AgentToolBuilder
+    readonly getAgentRuntimeConfig: AgentRuntimeConfigProvider
+    readonly pluginRuntime?: Record<string, unknown>
+  }
+>()('AgentFactoryService') {}
+
+export class ThreadConfigServiceTag extends Context.Service<ThreadConfigServiceTag, ResolvedThreadBootstrapConfig>()(
+  'ThreadConfigService',
+) {}
+
+export class RuntimeAdaptersServiceTag extends Context.Service<RuntimeAdaptersServiceTag, LotaRuntimeAdapters>()(
+  'RuntimeAdaptersService',
+) {}
+
+export class TurnHooksServiceTag extends Context.Service<TurnHooksServiceTag, LotaRuntimeTurnHooks>()(
+  'TurnHooksService',
+) {}
+
+export class ToolProvidersServiceTag extends Context.Service<ToolProvidersServiceTag, ToolSet>()(
+  'ToolProvidersService',
+) {}
+
+export class RuntimeWorkerExtensionsServiceTag extends Context.Service<
+  RuntimeWorkerExtensionsServiceTag,
+  LotaRuntimeWorkerExtensions
+>()('RuntimeWorkerExtensionsService') {}

package/src/effect/zod.ts

@@ -0,0 +1,43 @@
+import { Effect } from 'effect'
+import { ZodError } from 'zod'
+import type { z } from 'zod'
+
+import { ValidationError } from './errors'
+import type { ValidationIssue } from './errors'
+
+type ZodIssueLike = { readonly path: ReadonlyArray<PropertyKey>; readonly message: string }
+
+function toValidationIssuePath(path: ReadonlyArray<PropertyKey>): string {
+  return path.map((segment) => String(segment)).join('.') || 'root'
+}
+
+function getZodIssues(error: Pick<ZodError, 'issues'> | ReadonlyArray<ZodIssueLike>): ReadonlyArray<ZodIssueLike> {
+  return 'issues' in error ? error.issues : error
+}
+
+export function toValidationIssues(
+  error: Pick<ZodError, 'issues'> | ReadonlyArray<ZodIssueLike>,
+): ReadonlyArray<ValidationIssue> {
+  return getZodIssues(error).map((issue) => ({ path: toValidationIssuePath(issue.path), message: issue.message }))
+}
+
+export function summarizeZodIssues(issues: ReadonlyArray<ZodIssueLike>, maxIssues = 5): string {
+  return issues
+    .slice(0, maxIssues)
+    .map((issue) => `${toValidationIssuePath(issue.path)}: ${issue.message}`)
+    .join('; ')
+}
+
+export function toValidationError(error: unknown, message?: string): ValidationError {
+  return new ValidationError({
+    message: message ?? (error instanceof ZodError ? 'Schema validation failed' : 'Validation failed'),
+    issues: error instanceof ZodError ? toValidationIssues(error) : undefined,
+  })
+}
+
+export function zodParse<TSchema extends z.ZodTypeAny>(
+  schema: TSchema,
+  value: unknown,
+): Effect.Effect<z.infer<TSchema>, ValidationError> {
+  return Effect.try({ try: () => schema.parse(value), catch: toValidationError })
+}

package/src/embeddings/provider.ts

@@ -1,12 +1,9 @@
 import { embed, embedMany } from 'ai'
+import { Schema, Effect } from 'effect'
 
-import { getEmbeddingCache } from '../ai/embedding-cache'
-import {
-  getDirectOpenRouterProvider,
-  normalizeDirectOpenRouterModelId,
-  resetDirectOpenRouterProviderForTests,
-} from '../openrouter/direct-provider'
-import { getRuntimeConfig } from '../runtime/runtime-config'
+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
 
@@ -19,85 +16,129 @@ type ProviderEmbeddingsOptions = {
   embedFn?: typeof embed
   embedManyFn?: typeof embedMany
   getCache?: () => SharedEmbeddingCache | null
-  modelId?: string
+  modelId: string
+  openRouterApiKey?: string
 }
 
-function resolveEmbeddingModel(modelId: string) {
+function resolveEmbeddingModel(modelId: string, openRouterApiKey?: string) {
   const normalized = modelId.trim()
   if (!normalized) {
-    throw new Error('[embeddings-provider] Model id is required.')
+    throw new ConfigurationError({ message: '[embeddings-provider] Model id is required.', key: 'embeddingModelId' })
   }
 
   if (!SUPPORTED_EMBEDDING_PREFIXES.some((prefix) => normalized.startsWith(prefix))) {
-    throw new Error(
-      `[embeddings-provider] Unsupported model id "${modelId}". Use one of: ${SUPPORTED_EMBEDDING_PREFIXES.join(', ')}*.`,
-    )
+    throw new ConfigurationError({
+      message: `[embeddings-provider] Unsupported model id "${modelId}". Use one of: ${SUPPORTED_EMBEDDING_PREFIXES.join(', ')}*.`,
+      key: 'embeddingModelId',
+    })
   }
 
-  return getDirectOpenRouterProvider().embeddingModel(normalizeDirectOpenRouterModelId(normalized))
+  return getDirectOpenRouterProvider(openRouterApiKey).embeddingModel(normalizeDirectOpenRouterModelId(normalized))
 }
 
 function normalizeEmbedding(embedding: readonly number[]): number[] {
   return embedding.map((value) => Number(value))
 }
 
+class EmbeddingProviderError extends Schema.TaggedErrorClass<EmbeddingProviderError>()('EmbeddingProviderError', {
+  message: Schema.String,
+  cause: Schema.Defect,
+}) {}
+
+function tryEmbeddingPromise<A>(
+  message: string,
+  thunk: () => PromiseLike<A>,
+): Effect.Effect<A, EmbeddingProviderError> {
+  return Effect.tryPromise({
+    try: () => Promise.resolve(thunk()),
+    catch: (cause) => new EmbeddingProviderError({ message, cause }),
+  })
+}
+
 export class ProviderEmbeddings {
   private readonly embedFn: typeof embed
   private readonly embedManyFn: typeof embedMany
   private readonly getCache: () => SharedEmbeddingCache | null
-  private readonly configuredModelId?: string
-  private resolvedModelId: string | null = null
+  private readonly resolvedModelId: string
   private _model: ReturnType<typeof resolveEmbeddingModel> | null = null
+  /** In-flight dedup: concurrent embedQuery calls for the same text share one API round-trip. */
+  private readonly inflightEmbeddings = new Map<string, Promise<number[]>>()
+
+  private readonly openRouterApiKey: string | undefined
 
-  constructor(options: ProviderEmbeddingsOptions = {}) {
+  constructor(options: ProviderEmbeddingsOptions) {
     this.embedFn = options.embedFn ?? embed
     this.embedManyFn = options.embedManyFn ?? embedMany
-    this.getCache = options.getCache ?? getEmbeddingCache
-    this.configuredModelId = options.modelId
+    this.getCache = options.getCache ?? (() => null)
+    this.resolvedModelId = options.modelId
+    this.openRouterApiKey = options.openRouterApiKey
   }
 
   private getModelId(): string {
-    if (!this.resolvedModelId) {
-      this.resolvedModelId = this.configuredModelId ?? getRuntimeConfig().aiGateway.embeddingModel
-    }
-
     return this.resolvedModelId
   }
 
   private getModel() {
     if (!this._model) {
-      this._model = resolveEmbeddingModel(this.getModelId())
+      this._model = resolveEmbeddingModel(this.getModelId(), this.openRouterApiKey)
     }
     return this._model
   }
 
-  private async loadCachedEmbedding(text: string): Promise<number[] | null> {
+  private loadCachedEmbedding(text: string): Promise<number[] | null> {
     const redisCache = this.getCache()
-    if (!redisCache) return null
+    if (!redisCache) return Promise.resolve(null)
 
     return redisCache.get(this.getModelId(), text)
   }
 
-  async embedQuery(text: string): Promise<number[]> {
+  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 []
+    if (!input) return Promise.resolve([])
 
-    const cached = await this.loadCachedEmbedding(input)
-    if (cached) return cached
+    const dedupKey = `${this.getModelId()}:${input}`
+    const pending = this.inflightEmbeddings.get(dedupKey)
+    if (pending) return pending
 
-    const result = await this.embedFn({ model: this.getModel(), value: input, maxRetries: 2 })
-    const embedding = normalizeEmbedding(result.embedding)
+    const promise = this.runEffect(this.executeEmbedQueryEffect(input))
+    this.inflightEmbeddings.set(dedupKey, promise)
+    void promise.finally(() => this.inflightEmbeddings.delete(dedupKey))
 
-    const redisCache = this.getCache()
-    if (redisCache) {
-      void redisCache.set(this.getModelId(), input, embedding)
-    }
+    return promise
+  }
+
+  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
+      return embedding
+    }).pipe(Effect.withSpan('ProviderEmbeddings.executeEmbedQuery'))
   }
 
-  async embedDocuments(values: string[]): Promise<number[][]> {
-    if (values.length === 0) return []
+  embedDocuments(values: string[]): Promise<number[][]> {
+    if (values.length === 0) return Promise.resolve([])
 
     const normalized = values.map((value) => value.trim())
     const nonEmptyEntries = normalized
@@ -105,57 +146,62 @@ export class ProviderEmbeddings {
       .filter((entry) => entry.value.length > 0)
 
     if (nonEmptyEntries.length === 0) {
-      return normalized.map(() => [])
+      return Promise.resolve(normalized.map(() => []))
     }
 
     const uniqueTexts = [...new Set(nonEmptyEntries.map((entry) => entry.value))]
-    const embeddingsByText = new Map<string, number[]>()
-    let missingTexts = [...uniqueTexts]
-
-    const redisCache = this.getCache()
-    if (redisCache && missingTexts.length > 0) {
-      const redisResults = await Promise.all(
-        missingTexts.map(async (text) => ({ text, embedding: await redisCache.get(this.getModelId(), text) })),
-      )
+    return this.runEffect(this.embedDocumentsEffect(normalized, uniqueTexts))
+  }
 
-      missingTexts = []
-      for (const result of redisResults) {
-        if (!result.embedding) {
-          missingTexts.push(result.text)
-          continue
+  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
+          }
+
+          embeddingsByText.set(result.text, result.embedding)
         }
-
-        embeddingsByText.set(result.text, result.embedding)
       }
-    }
 
-    if (missingTexts.length > 0) {
-      const result = await this.embedManyFn({ model: this.getModel(), values: missingTexts, maxRetries: 2 })
+      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(this.getModelId(), text, embedding)
+          void redisCache.set(self.getModelId(), text, embedding)
         }
       })
-    }
-
-    return normalized.map((text) => (text ? (embeddingsByText.get(text) ?? []) : []))
-  }
-}
 
-let defaultEmbeddings: ProviderEmbeddings | null = null
-
-export function getDefaultEmbeddings(): ProviderEmbeddings {
-  if (!defaultEmbeddings) {
-    defaultEmbeddings = new ProviderEmbeddings()
+      return normalized.map((text) => (text ? (embeddingsByText.get(text) ?? []) : []))
+    }).pipe(Effect.withSpan('ProviderEmbeddings.embedDocuments'))
   }
-
-  return defaultEmbeddings
-}
-
-export function resetDefaultEmbeddingsForTests(): void {
-  defaultEmbeddings = null
-  resetDirectOpenRouterProviderForTests()
 }