@lota-sdk/core 0.4.8 → 0.4.10

package/src/utils/null-proto-record.ts

@@ -0,0 +1,41 @@
+import { isSafePath } from '@lota-sdk/shared'
+
+import { BadRequestError } from '../effect/errors'
+import { isRecord } from './string'
+
+export function createNullProtoRecord(): Record<string, unknown> {
+  return Object.create(null) as Record<string, unknown>
+}
+
+export function cloneToNullProtoRecord(value: Record<string, unknown>): Record<string, unknown> {
+  const clone = createNullProtoRecord()
+  for (const [key, entry] of Object.entries(value)) {
+    clone[key] = entry
+  }
+  return clone
+}
+
+export function setPathValue(target: Record<string, unknown>, path: string, value: unknown): void {
+  if (!isSafePath(path)) {
+    throw new BadRequestError({ message: `Unsafe path "${path}"` })
+  }
+
+  const segments = path.split('.').map((part) => part.trim())
+  const lastSegment = segments[segments.length - 1]
+  if (!lastSegment) {
+    throw new BadRequestError({ message: `Unsafe path "${path}"` })
+  }
+
+  let current: Record<string, unknown> = target
+  for (const segment of segments.slice(0, -1)) {
+    const next = current[segment]
+    if (!isRecord(next)) {
+      current[segment] = createNullProtoRecord()
+    } else if (Object.getPrototypeOf(next) !== null) {
+      current[segment] = cloneToNullProtoRecord(next)
+    }
+    current = current[segment] as Record<string, unknown>
+  }
+
+  current[lastSegment] = value
+}

package/src/utils/sse-keepalive.ts

@@ -1,3 +1,5 @@
+import { Duration, Effect, Fiber } from 'effect'
+
 const KEEPALIVE_COMMENT = new TextEncoder().encode(': keepalive\n\n')
 const DEFAULT_KEEPALIVE_INTERVAL_MS = 20_000
 
@@ -10,27 +12,128 @@ export function wrapResponseWithKeepalive(response: Response, intervalMs = DEFAU
   const body = response.body
   if (!body) return response
 
-  let intervalHandle: ReturnType<typeof setInterval> | null = null
-
-  const transformed = body.pipeThrough(
-    new TransformStream<Uint8Array, Uint8Array>({
-      start(controller) {
-        intervalHandle = setInterval(() => {
-          try {
-            controller.enqueue(KEEPALIVE_COMMENT)
-          } catch {
-            if (intervalHandle) clearInterval(intervalHandle)
-          }
-        }, intervalMs)
-      },
-      transform(chunk, controller) {
-        controller.enqueue(chunk)
-      },
-      flush() {
-        if (intervalHandle) clearInterval(intervalHandle)
-      },
-    }),
-  )
+  let closed = false
+  let reader: ReadableStreamDefaultReader<Uint8Array> | null = null
+  let keepaliveFiber: ReturnType<typeof Effect.runFork> | null = null
+  let bodyPumpFiber: ReturnType<typeof Effect.runFork> | null = null
+
+  const interruptFiber = (fiber: ReturnType<typeof Effect.runFork> | null) => {
+    if (!fiber) return
+    void Effect.runFork(Fiber.interrupt(fiber))
+  }
+
+  const stopKeepalive = () => {
+    const fiber = keepaliveFiber
+    keepaliveFiber = null
+    interruptFiber(fiber)
+  }
+
+  const stopBodyPump = () => {
+    const fiber = bodyPumpFiber
+    bodyPumpFiber = null
+    interruptFiber(fiber)
+  }
+
+  const releaseReader = (bodyReader: ReadableStreamDefaultReader<Uint8Array>) => {
+    try {
+      bodyReader.releaseLock()
+    } catch {
+      // Best-effort cleanup.
+    }
+  }
+
+  const enqueueChunk = (controller: ReadableStreamDefaultController<Uint8Array>, chunk: Uint8Array): boolean => {
+    if (closed) return false
+
+    try {
+      controller.enqueue(chunk)
+      return true
+    } catch {
+      closed = true
+      return false
+    }
+  }
+
+  const closeStream = (controller: ReadableStreamDefaultController<Uint8Array>) => {
+    if (closed) return
+    closed = true
+
+    try {
+      controller.close()
+    } catch {
+      // Best-effort cleanup.
+    }
+  }
+
+  const errorStream = (controller: ReadableStreamDefaultController<Uint8Array>, error: unknown) => {
+    if (closed) return
+    closed = true
+
+    try {
+      controller.error(error)
+    } catch {
+      // Best-effort cleanup.
+    }
+  }
+
+  const keepaliveEffect = (controller: ReadableStreamDefaultController<Uint8Array>): Effect.Effect<void> =>
+    Effect.sleep(Duration.millis(intervalMs)).pipe(
+      Effect.flatMap(() => Effect.sync(() => enqueueChunk(controller, KEEPALIVE_COMMENT))),
+      Effect.flatMap((shouldContinue) => (shouldContinue ? keepaliveEffect(controller) : Effect.void)),
+    )
+
+  const pumpBodyEffect = (
+    bodyReader: ReadableStreamDefaultReader<Uint8Array>,
+    controller: ReadableStreamDefaultController<Uint8Array>,
+  ): Effect.Effect<void> =>
+    Effect.gen(function* () {
+      for (;;) {
+        if (closed) return
+
+        const { done, value } = yield* Effect.tryPromise(() => bodyReader.read())
+        if (done) {
+          yield* Effect.sync(() => closeStream(controller))
+          return
+        }
+
+        if (!enqueueChunk(controller, value)) {
+          return
+        }
+      }
+    }).pipe(
+      Effect.catch((error: unknown) => Effect.sync(() => errorStream(controller, error))),
+      Effect.ensuring(
+        Effect.sync(() => {
+          closed = true
+          stopKeepalive()
+          bodyPumpFiber = null
+          reader = null
+          releaseReader(bodyReader)
+        }),
+      ),
+    )
+
+  const transformed = new ReadableStream<Uint8Array>({
+    start(controller) {
+      const bodyReader = body.getReader()
+      reader = bodyReader
+      keepaliveFiber = Effect.runFork(keepaliveEffect(controller))
+      bodyPumpFiber = Effect.runFork(pumpBodyEffect(bodyReader, controller))
+    },
+    cancel(reason) {
+      closed = true
+      stopKeepalive()
+      stopBodyPump()
+
+      const bodyReader = reader
+      reader = null
+      if (!bodyReader) {
+        return
+      }
+
+      void bodyReader.cancel(reason).catch(() => {})
+    },
+  })
 
   return new Response(transformed, {
     headers: response.headers,

package/src/workers/bootstrap.ts

@@ -1,61 +1,173 @@
-import { configureLotaLogger, serverLogger } from '../config/logger'
-import { LOTA_SDK_DATABASE_NAME } from '../db/sdk-database'
-import { SurrealDBService, databaseService, setDatabaseService } from '../db/service'
+import { ConfigProvider, Option, Schema, Effect, Layer, ManagedRuntime, Redacted } from 'effect'
+
+import { AiGatewayLive } from '../ai-gateway/ai-gateway'
+import { EmbeddingCacheLive } from '../ai/embedding-cache'
+import { configureLotaLogger, resolveLotaLogLevel, serverLogger } from '../config/logger'
 import { connectWithStartupRetry, waitForDatabaseBootstrap } from '../db/startup'
-import { parseWorkerBootstrapEnv } from '../runtime/runtime-config'
+import { buildWorkerInfrastructureLayer, setLotaSdkRuntime } from '../effect'
+import { DatabaseServiceTag } from '../effect/services'
+import { lotaRuntimeEnvConfig, parseLotaRuntimeConfig, parseWorkerBootstrapEnv } from '../runtime/runtime-config'
 import { getConfiguredPluginDatabaseConnector } from '../runtime/runtime-extensions'
+import { FirecrawlLive } from '../tools/firecrawl-client'
+import { getErrorMessage } from '../utils/errors'
 
-function ensureDatabaseServiceConfigured(): void {
-  const env = parseWorkerBootstrapEnv(process.env)
-  const db = new SurrealDBService({
-    url: env.SURREALDB_URL,
-    namespace: env.SURREALDB_NAMESPACE,
-    database: LOTA_SDK_DATABASE_NAME,
-    username: env.SURREALDB_USER,
-    password: env.SURREALDB_PASSWORD,
-  })
-  setDatabaseService(db)
+class SandboxedWorkerBootstrapError extends Schema.TaggedErrorClass<SandboxedWorkerBootstrapError>()(
+  'SandboxedWorkerBootstrapError',
+  {
+    stage: Schema.Literals(['setup', 'initialize', 'connect-db', 'connect-plugin-db', 'bootstrap-wait']),
+    message: Schema.String,
+    cause: Schema.Defect,
+  },
+) {}
+
+function toSandboxedWorkerBootstrapError(
+  stage: SandboxedWorkerBootstrapError['stage'],
+  cause: unknown,
+): SandboxedWorkerBootstrapError {
+  return new SandboxedWorkerBootstrapError({ stage, message: getErrorMessage(cause), cause })
 }
 
-let sandboxedWorkerRuntimePromise: Promise<void> | null = null
+function buildSandboxedWorkerRuntimeConfigEffect() {
+  return lotaRuntimeEnvConfig
+    .parse(ConfigProvider.fromEnv())
+    .pipe(
+      Effect.map((env) =>
+        parseLotaRuntimeConfig({
+          database: {
+            url: env.surrealdbUrl,
+            namespace: env.surrealdbNamespace,
+            username: env.surrealdbUser,
+            password: Redacted.value(env.surrealdbPassword),
+          },
+          redis: { url: env.redisUrl },
+          aiGateway: {
+            url: env.aiGatewayUrl,
+            key: Redacted.value(env.aiGatewayKey),
+            ...(Option.isSome(env.openRouterApiKey)
+              ? { openRouterApiKey: Redacted.value(env.openRouterApiKey.value) }
+              : {}),
+          },
+          s3: {
+            endpoint: env.s3Endpoint,
+            bucket: env.s3Bucket,
+            region: env.s3Region,
+            accessKeyId: Redacted.value(env.s3AccessKeyId),
+            secretAccessKey: Redacted.value(env.s3SecretAccessKey),
+            attachmentUrlExpiresIn: env.attachmentUrlExpiresIn,
+          },
+          firecrawl: {
+            apiKey: Redacted.value(env.firecrawlApiKey),
+            ...(Option.isSome(env.firecrawlApiBaseUrl) ? { apiBaseUrl: env.firecrawlApiBaseUrl.value } : {}),
+          },
+          agents: {
+            roster: ['worker'],
+            leadAgentId: 'worker',
+            displayNames: { worker: 'Worker' },
+            teamConsultParticipants: [],
+          },
+        }),
+      ),
+    )
+}
+
+// eslint-disable-next-line typescript-eslint/no-explicit-any -- wildcard for host-provided ManagedRuntime
+type WorkerManagedRuntime = ManagedRuntime.ManagedRuntime<any, any>
+
+let sandboxedWorkerSetupPromise: Promise<WorkerManagedRuntime> | null = null
+let sandboxedWorkerInitPromise: Promise<WorkerManagedRuntime> | null = null
+
+function ensureSandboxedWorkerRuntimeConfigured(): Promise<WorkerManagedRuntime> {
+  if (sandboxedWorkerSetupPromise) {
+    return sandboxedWorkerSetupPromise
+  }
+
+  // Assign before the async kicks off so concurrent callers observe the in-flight promise.
+  sandboxedWorkerSetupPromise = Effect.runPromise(
+    Effect.gen(function* () {
+      const runtimeConfig = yield* buildSandboxedWorkerRuntimeConfigEffect()
+      yield* Effect.sync(() => configureLotaLogger(resolveLotaLogLevel(Bun.env.LOG_LEVEL) ?? 'info'))
+
+      const infrastructureLayer = buildWorkerInfrastructureLayer(runtimeConfig)
+
+      const layer = Layer.mergeAll(infrastructureLayer, Layer.provide(AiGatewayLive, infrastructureLayer))
+
+      const fullLayer = Layer.mergeAll(layer, Layer.provide(Layer.mergeAll(EmbeddingCacheLive, FirecrawlLive), layer))
 
-export async function initializeSandboxedWorkerRuntime(): Promise<void> {
-  if (sandboxedWorkerRuntimePromise) {
-    await sandboxedWorkerRuntimePromise
-    return
+      const managedRuntime = ManagedRuntime.make(fullLayer)
+
+      yield* Effect.sync(() => {
+        setLotaSdkRuntime(managedRuntime)
+      })
+
+      return managedRuntime
+    }),
+  ).catch((error) => {
+    sandboxedWorkerSetupPromise = null
+    throw error
+  })
+
+  return sandboxedWorkerSetupPromise
+}
+
+export function initializeSandboxedWorkerRuntime(): Promise<WorkerManagedRuntime> {
+  if (sandboxedWorkerInitPromise) {
+    return sandboxedWorkerInitPromise
   }
 
-  sandboxedWorkerRuntimePromise = (async () => {
-    const env = parseWorkerBootstrapEnv(process.env)
-    await configureLotaLogger()
-
-    ensureDatabaseServiceConfigured()
-
-    await connectWithStartupRetry({
-      connect: () => databaseService.connect(),
-      label: 'sandboxed worker AI database runtime',
-      logger: serverLogger,
-    })
-
-    await connectWithStartupRetry({
-      connect: async () => {
-        const connectPluginRuntimeDatabases = getConfiguredPluginDatabaseConnector()
-        if (connectPluginRuntimeDatabases) {
-          await connectPluginRuntimeDatabases()
-        }
-      },
-      label: 'sandboxed worker plugin database runtime',
-      logger: serverLogger,
-    })
-
-    await waitForDatabaseBootstrap({
-      databaseService,
-      expectedFingerprint: env.DB_SCHEMA_FINGERPRINT,
-      label: 'sandboxed worker runtime',
-      logger: serverLogger,
-      connect: () => databaseService.connect(),
-    })
-  })()
-
-  await sandboxedWorkerRuntimePromise
+  // Assign before the async kicks off so concurrent callers observe the in-flight promise.
+  sandboxedWorkerInitPromise = Effect.runPromise(
+    Effect.gen(function* () {
+      const env = parseWorkerBootstrapEnv(Bun.env)
+      const runtime = yield* Effect.tryPromise({
+        try: () => ensureSandboxedWorkerRuntimeConfigured(),
+        catch: (error) => toSandboxedWorkerBootstrapError('setup', error),
+      })
+      const db = yield* Effect.tryPromise({
+        try: () => runtime.runPromise(Effect.service(DatabaseServiceTag)),
+        catch: (error) => toSandboxedWorkerBootstrapError('initialize', error),
+      })
+
+      yield* Effect.tryPromise({
+        try: () =>
+          connectWithStartupRetry({
+            connect: () => db.connect(),
+            label: 'sandboxed worker AI database runtime',
+            logger: serverLogger,
+          }),
+        catch: (error) => toSandboxedWorkerBootstrapError('connect-db', error),
+      })
+
+      yield* Effect.tryPromise({
+        try: () =>
+          connectWithStartupRetry({
+            connect: () => {
+              const connectPluginRuntimeDatabases = getConfiguredPluginDatabaseConnector()
+              return connectPluginRuntimeDatabases ? connectPluginRuntimeDatabases() : Promise.resolve()
+            },
+            label: 'sandboxed worker plugin database runtime',
+            logger: serverLogger,
+          }),
+        catch: (error) => toSandboxedWorkerBootstrapError('connect-plugin-db', error),
+      })
+
+      yield* Effect.tryPromise({
+        try: () =>
+          waitForDatabaseBootstrap({
+            databaseService: db,
+            expectedFingerprint: env.DB_SCHEMA_FINGERPRINT,
+            label: 'sandboxed worker runtime',
+            logger: serverLogger,
+            connect: () => db.connect(),
+          }),
+        catch: (error) => toSandboxedWorkerBootstrapError('bootstrap-wait', error),
+      })
+
+      return runtime
+    }),
+  ).catch((error) => {
+    sandboxedWorkerInitPromise = null
+    throw error
+  })
+
+  return sandboxedWorkerInitPromise
 }