@lota-sdk/core 0.4.8 → 0.4.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lota-sdk/core",
-  "version": "0.4.8",
+  "version": "0.4.9",
   "type": "module",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
@@ -28,18 +28,17 @@
   },
   "dependencies": {
     "@ai-sdk/devtools": "^0.0.15",
-    "@ai-sdk/openai": "^3.0.50",
-    "@chat-adapter/slack": "^4.23.0",
-    "@chat-adapter/state-ioredis": "^4.23.0",
-    "@logtape/logtape": "^2.0.5",
-    "@lota-sdk/shared": "0.4.8",
-    "@mendable/firecrawl-js": "^4.18.1",
+    "@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",
+    "@mendable/firecrawl-js": "^4.18.3",
     "@surrealdb/node": "^3.0.3",
-    "ai": "^6.0.145",
-    "bullmq": "^5.73.0",
-    "chat": "^4.23.0",
-    "cron-parser": "^5.5.0",
-    "hono": "^4.12.10",
+    "ai": "^6.0.167",
+    "bullmq": "^5.74.1",
+    "chat": "^4.26.0",
+    "effect": "^4.0.0-beta.50",
+    "hono": "^4.12.14",
     "ioredis": "5.9.3",
     "mammoth": "^1.12.0",
     "pdf-parse": "^2.4.5",

package/src/ai/embedding-cache.ts

@@ -1,47 +1,119 @@
+import { Context, Effect, Layer, Schema } from 'effect'
 import type IORedis from 'ioredis'
 
 import { aiLogger } from '../config/logger'
+import { RedisServiceTag, RuntimeConfigServiceTag } from '../effect/services'
+import { sha256Hex } from '../utils/crypto'
 
 export const DEFAULT_EMBEDDING_CACHE_TTL_SECONDS = 7200
 const EMBEDDING_CACHE_KEY_PREFIX = 'emb'
+const EmbeddingCacheJsonSchema = Schema.fromJsonString(Schema.Array(Schema.Number))
+
+class EmbeddingCacheError extends Schema.TaggedErrorClass<EmbeddingCacheError>()('EmbeddingCacheError', {
+  message: Schema.String,
+  operation: Schema.Literals(['get', 'set']),
+  cause: Schema.optional(Schema.Defect),
+}) {}
+
+function decodeEmbeddingCacheValue(raw: string): number[] {
+  return [...Schema.decodeUnknownSync(EmbeddingCacheJsonSchema)(raw)]
+}
+
+function encodeEmbeddingCacheValue(embedding: number[]): string {
+  return Schema.encodeSync(EmbeddingCacheJsonSchema)(embedding)
+}
 
 export class EmbeddingCache {
+  /** In-flight dedup: concurrent gets for the same key share a single Redis+API round-trip. */
+  private readonly inflight = new Map<string, Promise<number[] | null>>()
+
   constructor(
     private redis: IORedis,
     private ttlSeconds: number = DEFAULT_EMBEDDING_CACHE_TTL_SECONDS,
   ) {}
 
   private buildKey(model: string, text: string): string {
-    const hash = new Bun.CryptoHasher('sha256').update(text).digest('hex')
+    const hash = sha256Hex(text)
     return `${EMBEDDING_CACHE_KEY_PREFIX}:${model}:${hash}`
   }
 
-  async get(model: string, text: string): Promise<number[] | null> {
-    try {
-      const cached = await this.redis.getBuffer(this.buildKey(model, text))
+  private runEffect<A>(effect: Effect.Effect<A>): Promise<A> {
+    return Effect.runPromise(effect)
+  }
+
+  private fetchFromRedisEffect(key: string): Effect.Effect<number[] | null> {
+    const redis = this.redis
+
+    return Effect.gen(function* () {
+      const cached = yield* Effect.tryPromise({
+        try: () => redis.getBuffer(key),
+        catch: (cause) => new EmbeddingCacheError({ message: 'Embedding cache get failed.', operation: 'get', cause }),
+      })
+
       if (!cached) return null
-      return JSON.parse(cached.toString()) as number[]
-    } catch (error) {
-      aiLogger.warn`Embedding cache get failed: ${error}`
-      return null
-    }
+
+      return yield* Effect.try({
+        try: () => decodeEmbeddingCacheValue(cached.toString()),
+        catch: (cause) =>
+          new EmbeddingCacheError({ message: 'Embedding cache parse failed.', operation: 'get', cause }),
+      })
+    }).pipe(
+      Effect.catchTag('EmbeddingCacheError', (error) => {
+        aiLogger.warn`${error.message}: ${error.cause}`
+        return Effect.succeed<number[] | null>(null)
+      }),
+    )
   }
 
-  async set(model: string, text: string, embedding: number[]): Promise<void> {
-    try {
-      await this.redis.set(this.buildKey(model, text), JSON.stringify(embedding), 'EX', this.ttlSeconds)
-    } catch (error) {
-      aiLogger.warn`Embedding cache set failed: ${error}`
-    }
+  get(model: string, text: string): Promise<number[] | null> {
+    const key = this.buildKey(model, text)
+
+    const pending = this.inflight.get(key)
+    if (pending) return pending
+
+    const promise = this.runEffect(this.fetchFromRedisEffect(key))
+    this.inflight.set(key, promise)
+    void promise.finally(() => this.inflight.delete(key))
+
+    return promise
   }
-}
 
-let embeddingCacheInstance: EmbeddingCache | null = null
+  private setEffect(model: string, text: string, embedding: number[]): Effect.Effect<void> {
+    const redis = this.redis
+    const ttlSeconds = this.ttlSeconds
+    const key = this.buildKey(model, text)
 
-export function configureEmbeddingCache(redis: IORedis, ttlSeconds?: number): void {
-  embeddingCacheInstance = new EmbeddingCache(redis, ttlSeconds ?? DEFAULT_EMBEDDING_CACHE_TTL_SECONDS)
-}
+    return Effect.gen(function* () {
+      const serialized = yield* Effect.try({
+        try: () => encodeEmbeddingCacheValue(embedding),
+        catch: (cause) =>
+          new EmbeddingCacheError({ message: 'Embedding cache serialization failed.', operation: 'set', cause }),
+      })
+      yield* Effect.tryPromise({
+        try: () => redis.set(key, serialized, 'EX', ttlSeconds),
+        catch: (cause) => new EmbeddingCacheError({ message: 'Embedding cache set failed.', operation: 'set', cause }),
+      })
+    }).pipe(
+      Effect.asVoid,
+      Effect.catchTag('EmbeddingCacheError', (error) => {
+        aiLogger.warn`${error.message}: ${error.cause}`
+        return Effect.void
+      }),
+    )
+  }
 
-export function getEmbeddingCache(): EmbeddingCache | null {
-  return embeddingCacheInstance
+  set(model: string, text: string, embedding: number[]): Promise<void> {
+    return this.runEffect(this.setEffect(model, text, embedding))
+  }
 }
+
+export class EmbeddingCacheTag extends Context.Service<EmbeddingCacheTag, EmbeddingCache>()('EmbeddingCache') {}
+
+export const EmbeddingCacheLive = Layer.effect(
+  EmbeddingCacheTag,
+  Effect.gen(function* () {
+    const redis = yield* RedisServiceTag
+    const config = yield* RuntimeConfigServiceTag
+    return new EmbeddingCache(redis.getConnection(), config.memory.embeddingCacheTtlSeconds)
+  }),
+)