@lota-sdk/core 0.4.9 → 0.4.10

package/src/workers/bootstrap.ts

@@ -1,13 +1,12 @@
-import { Config, ConfigProvider, Schema, Effect, Layer, ManagedRuntime, Redacted } from 'effect'
+import { ConfigProvider, Option, Schema, Effect, Layer, ManagedRuntime, Redacted } from 'effect'
 
 import { AiGatewayLive } from '../ai-gateway/ai-gateway'
 import { EmbeddingCacheLive } from '../ai/embedding-cache'
-import { DEFAULT_AI_GATEWAY_URL } from '../config/constants'
 import { configureLotaLogger, resolveLotaLogLevel, serverLogger } from '../config/logger'
 import { connectWithStartupRetry, waitForDatabaseBootstrap } from '../db/startup'
 import { buildWorkerInfrastructureLayer, setLotaSdkRuntime } from '../effect'
 import { DatabaseServiceTag } from '../effect/services'
-import { parseLotaRuntimeConfig, parseWorkerBootstrapEnv } from '../runtime/runtime-config'
+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'
@@ -28,27 +27,8 @@ function toSandboxedWorkerBootstrapError(
   return new SandboxedWorkerBootstrapError({ stage, message: getErrorMessage(cause), cause })
 }
 
-const workerConfig = Config.all({
-  surrealdbUrl: Config.string('SURREALDB_URL'),
-  surrealdbNamespace: Config.string('SURREALDB_NAMESPACE'),
-  surrealdbUser: Config.string('SURREALDB_USER'),
-  surrealdbPassword: Config.redacted('SURREALDB_PASSWORD'),
-  redisUrl: Config.string('REDIS_URL'),
-  aiGatewayUrl: Config.string('AI_GATEWAY_URL').pipe(Config.withDefault(DEFAULT_AI_GATEWAY_URL)),
-  aiGatewayKey: Config.redacted('AI_GATEWAY_KEY'),
-  openRouterApiKey: Config.redacted('OPENROUTER_API_KEY'),
-  s3Endpoint: Config.string('S3_ENDPOINT'),
-  s3Bucket: Config.string('S3_BUCKET'),
-  s3Region: Config.string('S3_REGION').pipe(Config.withDefault('garage')),
-  s3AccessKeyId: Config.redacted('S3_ACCESS_KEY_ID'),
-  s3SecretAccessKey: Config.redacted('S3_SECRET_ACCESS_KEY'),
-  attachmentUrlExpiresIn: Config.string('ATTACHMENT_URL_EXPIRES_IN').pipe(Config.withDefault('1800')),
-  firecrawlApiKey: Config.redacted('FIRECRAWL_API_KEY'),
-  firecrawlApiBaseUrl: Config.string('FIRECRAWL_API_BASE_URL').pipe(Config.option),
-})
-
 function buildSandboxedWorkerRuntimeConfigEffect() {
-  return workerConfig
+  return lotaRuntimeEnvConfig
     .parse(ConfigProvider.fromEnv())
     .pipe(
       Effect.map((env) =>
@@ -63,7 +43,9 @@ function buildSandboxedWorkerRuntimeConfigEffect() {
           aiGateway: {
             url: env.aiGatewayUrl,
             key: Redacted.value(env.aiGatewayKey),
-            openRouterApiKey: Redacted.value(env.openRouterApiKey),
+            ...(Option.isSome(env.openRouterApiKey)
+              ? { openRouterApiKey: Redacted.value(env.openRouterApiKey.value) }
+              : {}),
           },
           s3: {
             endpoint: env.s3Endpoint,
@@ -75,7 +57,7 @@ function buildSandboxedWorkerRuntimeConfigEffect() {
           },
           firecrawl: {
             apiKey: Redacted.value(env.firecrawlApiKey),
-            ...(env.firecrawlApiBaseUrl._tag === 'Some' ? { apiBaseUrl: env.firecrawlApiBaseUrl.value } : {}),
+            ...(Option.isSome(env.firecrawlApiBaseUrl) ? { apiBaseUrl: env.firecrawlApiBaseUrl.value } : {}),
           },
           agents: {
             roster: ['worker'],
@@ -91,20 +73,16 @@ function buildSandboxedWorkerRuntimeConfigEffect() {
 // eslint-disable-next-line typescript-eslint/no-explicit-any -- wildcard for host-provided ManagedRuntime
 type WorkerManagedRuntime = ManagedRuntime.ManagedRuntime<any, any>
 
-let sandboxedWorkerRuntimePromise: Promise<WorkerManagedRuntime> | null = null
-let sandboxedWorkerRuntime: WorkerManagedRuntime | null = null
-let sandboxedWorkerRuntimeSetupPromise: Promise<WorkerManagedRuntime> | null = null
+let sandboxedWorkerSetupPromise: Promise<WorkerManagedRuntime> | null = null
+let sandboxedWorkerInitPromise: Promise<WorkerManagedRuntime> | null = null
 
 function ensureSandboxedWorkerRuntimeConfigured(): Promise<WorkerManagedRuntime> {
-  if (sandboxedWorkerRuntime) {
-    return Promise.resolve(sandboxedWorkerRuntime)
-  }
-
-  if (sandboxedWorkerRuntimeSetupPromise) {
-    return sandboxedWorkerRuntimeSetupPromise
+  if (sandboxedWorkerSetupPromise) {
+    return sandboxedWorkerSetupPromise
   }
 
-  const setupPromise = Effect.runPromise(
+  // 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'))
@@ -119,25 +97,25 @@ function ensureSandboxedWorkerRuntimeConfigured(): Promise<WorkerManagedRuntime>
 
       yield* Effect.sync(() => {
         setLotaSdkRuntime(managedRuntime)
-        sandboxedWorkerRuntime = managedRuntime
       })
 
       return managedRuntime
     }),
-  ).finally(() => {
-    sandboxedWorkerRuntimeSetupPromise = null
+  ).catch((error) => {
+    sandboxedWorkerSetupPromise = null
+    throw error
   })
 
-  sandboxedWorkerRuntimeSetupPromise = setupPromise
-  return setupPromise
+  return sandboxedWorkerSetupPromise
 }
 
 export function initializeSandboxedWorkerRuntime(): Promise<WorkerManagedRuntime> {
-  if (sandboxedWorkerRuntimePromise) {
-    return sandboxedWorkerRuntimePromise
+  if (sandboxedWorkerInitPromise) {
+    return sandboxedWorkerInitPromise
   }
 
-  const initPromise = Effect.runPromise(
+  // 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({
@@ -186,11 +164,10 @@ export function initializeSandboxedWorkerRuntime(): Promise<WorkerManagedRuntime
 
       return runtime
     }),
-  )
-
-  sandboxedWorkerRuntimePromise = initPromise
-  return initPromise.catch((error) => {
-    sandboxedWorkerRuntimePromise = null
+  ).catch((error) => {
+    sandboxedWorkerInitPromise = null
     throw error
   })
+
+  return sandboxedWorkerInitPromise
 }

package/src/workers/organization-learning.worker.ts

@@ -18,7 +18,7 @@ import { toSandboxedWorkerError } from './utils/sandbox-error'
 import { createTracedWorkerProcessor } from './worker-utils'
 
 const runtime = await initializeSandboxedWorkerRuntime()
-const resolve = async <I, T>(tag: Context.Key<I, T>): Promise<T> => await runtime.runPromise(Effect.service(tag))
+const resolve = <I, T>(tag: Context.Key<I, T>): Promise<T> => runtime.runPromise(Effect.service(tag))
 const regularChatDigestServices: RegularChatDigestServices = {
   databaseService: await resolve(DatabaseServiceTag),
   memoryService: await resolve(MemoryServiceTag),

package/src/workers/regular-chat-memory-digest.runner.ts

@@ -1,4 +1,4 @@
-import { Cause, Effect } from 'effect'
+import { Effect, Schema } from 'effect'
 import type { Context } from 'effect'
 import { BoundQuery } from 'surrealdb'
 import { z } from 'zod'
@@ -35,6 +35,11 @@ import type { DigestMessage } from './utils/thread-message-query'
 // can be digested into durable memory and profile projections in the background.
 const StructuredProfilePatchSchema = z.record(z.string(), z.unknown()).default({})
 
+class MemoryDigestError extends Schema.TaggedErrorClass<MemoryDigestError>()('MemoryDigestError', {
+  message: Schema.String,
+  cause: Schema.Defect,
+}) {}
+
 const REGULAR_CHAT_MEMORY_DIGEST_TIMEOUT_MS = 10 * 60 * 1000
 const WorkspaceMemoryRowSchema = z.object({ content: z.string() })
 export interface RegularChatDigestServices {
@@ -120,11 +125,9 @@ function hasNewEligibleThreadMessages(params: {
     Effect.gen(function* () {
       if (params.threadIds.length === 0) return false
 
-      let query: BoundQuery | null = null
-      if (params.cursor) {
-        const cursorRowId = ensureRecordId(params.cursor.id, TABLES.THREAD_MESSAGE)
-        query = new BoundQuery(
-          `SELECT id, createdAt FROM ${TABLES.THREAD_MESSAGE}
+      const query: BoundQuery | null = params.cursor
+        ? new BoundQuery(
+            `SELECT id, createdAt FROM ${TABLES.THREAD_MESSAGE}
            WHERE threadId IN $threadIds
              AND (
                createdAt > $cursorCreatedAt
@@ -132,18 +135,22 @@ function hasNewEligibleThreadMessages(params: {
              )
            ORDER BY createdAt ASC, id ASC
            LIMIT 1`,
-          { threadIds: params.threadIds, cursorCreatedAt: params.cursor.createdAt, cursorRowId },
-        )
-      } else if (params.onboardingCutoff) {
-        query = new BoundQuery(
-          `SELECT id, createdAt FROM ${TABLES.THREAD_MESSAGE}
+            {
+              threadIds: params.threadIds,
+              cursorCreatedAt: params.cursor.createdAt,
+              cursorRowId: ensureRecordId(params.cursor.id, TABLES.THREAD_MESSAGE),
+            },
+          )
+        : params.onboardingCutoff
+          ? new BoundQuery(
+              `SELECT id, createdAt FROM ${TABLES.THREAD_MESSAGE}
            WHERE threadId IN $threadIds
              AND createdAt > $onboardingCutoff
            ORDER BY createdAt ASC, id ASC
            LIMIT 1`,
-          { threadIds: params.threadIds, onboardingCutoff: params.onboardingCutoff },
-        )
-      }
+              { threadIds: params.threadIds, onboardingCutoff: params.onboardingCutoff },
+            )
+          : null
 
       if (!query) return false
       const rows = yield* effectTryPromise(() => params.db.query<unknown>(query))
@@ -261,7 +268,10 @@ function runRegularChatMemoryDigestEffect(
 
     const summaryBlock = normalizeBlock(synthesis.summaryBlock)
     if (!summaryBlock) {
-      return yield* new Cause.UnknownError(new Error('Regular chat memory digest returned an empty summaryBlock'))
+      return yield* new MemoryDigestError({
+        message: 'Regular chat memory digest returned an empty summaryBlock',
+        cause: new Error('Regular chat memory digest returned an empty summaryBlock'),
+      })
     }
 
     const processedThreadCursor = getLastCursor(threadMessages)

package/src/workers/worker-utils.ts

@@ -5,11 +5,21 @@ import { Effect } from 'effect'
 import type { Context } from 'effect'
 
 import { chatLogger } from '../config/logger'
-import { getCurrentRuntime } from '../effect/runtime-ref'
+import { resolveLotaService } from '../effect/runtime'
 import { QueueJobServiceTag } from '../services/queue-job.service'
 
+let currentQueueJobService: Context.Service.Shape<typeof QueueJobServiceTag> | null = null
+
+export function configureQueueJobService(service: Context.Service.Shape<typeof QueueJobServiceTag>): void {
+  currentQueueJobService = service
+}
+
+export function clearQueueJobService(): void {
+  currentQueueJobService = null
+}
+
 export function getQueueJobService(): Context.Service.Shape<typeof QueueJobServiceTag> {
-  return getCurrentRuntime().runSync(Effect.service(QueueJobServiceTag))
+  return currentQueueJobService ?? resolveLotaService(QueueJobServiceTag)
 }
 
 export const DEFAULT_JOB_RETENTION = { removeOnComplete: true, removeOnFail: { age: 24 * 60 * 60, count: 200 } }
@@ -132,6 +142,14 @@ export function createTracedWorkerProcessor<TJob extends TracedWorkerJobLike, TR
             )
             return yield* error
           }),
+      ).pipe(
+        Effect.withSpan(`worker.${queueName}.${job.name}`),
+        Effect.annotateSpans({
+          'job.id': trackedJob.id !== undefined ? String(trackedJob.id) : 'unknown',
+          'job.name': job.name,
+          'job.attemptsMade': typeof job.attemptsMade === 'number' ? job.attemptsMade : -1,
+          'queue.name': queueName,
+        }),
       ),
     )
   }

package/src/config/search.ts

@@ -1,3 +0,0 @@
-export { VECTOR_SEARCH_OVERFETCH_MULTIPLIER } from '@lota-sdk/shared'
-
-export const DEFAULT_MEMORY_SEARCH_LIMIT = 10

package/src/runtime/agent-types.ts

@@ -1 +0,0 @@
-export type { ChatMode, CreateHelperToolLoopAgentOptions, CreateRoutedAgentOptions } from '@lota-sdk/shared'