@lota-sdk/core 0.4.9 → 0.4.11

package/src/tools/team-think.tool.ts

@@ -3,16 +3,20 @@ import { stepCountIs } from 'ai'
 import type { ToolSet } from 'ai'
 import { Schema, Effect } from 'effect'
 
-import { getAgentRuntimeConfig, getResolvedAgentFactoryConfig } from '../config/agent-defaults'
 import { aiLogger } from '../config/logger'
 import type { RecordIdRef } from '../db/record-id'
 import { recordIdToString } from '../db/record-id'
 import { TABLES } from '../db/tables'
 import { effectTryMaybeAsync as effectTryMaybeAsyncShared } from '../effect/helpers'
+import {
+  AgentConfigServiceTag,
+  AgentFactoryServiceTag,
+  RuntimeAdaptersServiceTag,
+  TurnHooksServiceTag,
+} from '../effect/services'
 import { readRuntimeAgentIdentityOverrides } from '../runtime/agent-identity-overrides'
 import { mergeInstructionSections } from '../runtime/instruction-sections'
-import { getRuntimeAdapters, getTurnHooks } from '../runtime/runtime-extensions'
-import type { LotaRuntimeTeamThinkToolsParams } from '../runtime/runtime-extensions'
+import type { LotaRuntimeAdapters, LotaRuntimeTeamThinkToolsParams } from '../runtime/runtime-extensions'
 import { createConsultTeamTool as createConsultTeamToolSdk } from '../runtime/team-consultation/team-consultation-orchestrator'
 import type {
   DefaultRepoSections,
@@ -24,8 +28,9 @@ import type { ReadableUploadMetadata } from '../services/attachment.service'
 
 function buildTeamThinkAgentToolsEffect(
   params: LotaRuntimeTeamThinkToolsParams,
+  runtimeAdapters: LotaRuntimeAdapters,
 ): Effect.Effect<{ tools: ToolSet }, TeamThinkRuntimeError> {
-  const builder = getRuntimeAdapters().buildTeamThinkAgentTools
+  const builder = runtimeAdapters.buildTeamThinkAgentTools
   if (!builder) {
     return Effect.succeed({ tools: {} })
   }
@@ -72,124 +77,137 @@ export function createTeamThinkTool(params: {
   toolProviders?: ToolSet
   abortSignal: AbortSignal
 }) {
-  const agentIdentityOverrides = readRuntimeAgentIdentityOverrides(
-    (params.context as Record<string, unknown> | null | undefined) ?? null,
-  )
-  const participantRunner: TeamConsultationParticipantRunner = {
-    buildParticipantAgent(agentId, runParams) {
-      return Effect.runPromise(
-        Effect.gen(function* () {
-          const currentContext = yield* Effect.context()
-          const runPromiseWithCurrentContext = Effect.runPromiseWith(currentContext)
-          const dynamicInstructionSections = yield* effectTryMaybeAsync(
-            () => params.getAdditionalInstructionSections?.(),
-            'Failed to load dynamic team-think instruction sections.',
-          )
-          const agentResolution = asRecord(
-            yield* effectTryMaybeAsync(
-              () =>
-                getTurnHooks().resolveAgent?.({
-                  agentId,
-                  mode: 'fixedThreadMode',
-                  thread: null,
-                  threadRef: params.threadId,
-                  orgRef: params.orgId,
-                  userRef: params.userId,
-                  onboardingActive: false,
-                  linearInstalled: false,
-                  githubInstalled: params.githubInstalled,
-                  additionalInstructionSections: mergeInstructionSections(
-                    dynamicInstructionSections,
-                    params.additionalInstructionSections,
-                  ),
-                  context: (params.context as Record<string, unknown> | null | undefined) ?? null,
-                }),
-              'Failed to resolve team-think participant agent.',
-            ),
-          )
-          const resolvedAgentId = readOptionalString(agentResolution?.agentId) ?? agentId
-          const config = getAgentRuntimeConfig({
-            agentId: resolvedAgentId,
-            threadType: 'group' as const,
-            mode: 'fixedThreadMode',
-            onboardingActive: false,
-            linearInstalled: false,
-            systemWorkspaceDetails: runParams.systemWorkspaceDetails,
-            preSeededMemoriesSection: runParams.preSeededMemoriesSection,
-            retrievedKnowledgeSection: runParams.retrievedKnowledgeSection,
-            additionalInstructionSections: mergeInstructionSections(
-              dynamicInstructionSections,
-              params.additionalInstructionSections,
-              readInstructionSections(agentResolution?.additionalInstructionSections),
-            ),
-            responseGuardSection: buildTeamConsultationResponseGuard({
+  return Effect.gen(function* () {
+    const turnHooks = yield* TurnHooksServiceTag
+    const runtimeAdapters = yield* RuntimeAdaptersServiceTag
+    const agentConfig = yield* AgentConfigServiceTag
+    const agentFactoryConfig = yield* AgentFactoryServiceTag
+    const agentIdentityOverrides = readRuntimeAgentIdentityOverrides(
+      (params.context as Record<string, unknown> | null | undefined) ?? null,
+    )
+    const participantRunner: TeamConsultationParticipantRunner = {
+      buildParticipantAgent(agentId, runParams) {
+        return Effect.runPromise(
+          Effect.gen(function* () {
+            const currentContext = yield* Effect.context()
+            const runPromiseWithCurrentContext = Effect.runPromiseWith(currentContext)
+            const dynamicInstructionSections = yield* effectTryMaybeAsync(
+              () => params.getAdditionalInstructionSections?.(),
+              'Failed to load dynamic team-think instruction sections.',
+            )
+            const agentResolution = asRecord(
+              yield* effectTryMaybeAsync(
+                () =>
+                  turnHooks.resolveAgent?.({
+                    agentId,
+                    mode: 'fixedThreadMode',
+                    thread: null,
+                    threadRef: params.threadId,
+                    orgRef: params.orgId,
+                    userRef: params.userId,
+                    onboardingActive: false,
+                    linearInstalled: false,
+                    githubInstalled: params.githubInstalled,
+                    additionalInstructionSections: mergeInstructionSections(
+                      dynamicInstructionSections,
+                      params.additionalInstructionSections,
+                    ),
+                    context: (params.context as Record<string, unknown> | null | undefined) ?? null,
+                  }),
+                'Failed to resolve team-think participant agent.',
+              ),
+            )
+            const resolvedAgentId = readOptionalString(agentResolution?.agentId) ?? agentId
+            const config = agentFactoryConfig.getAgentRuntimeConfig({
               agentId: resolvedAgentId,
-              task: runParams.task,
-            }),
-          })
-          const { tools } = yield* buildTeamThinkAgentToolsEffect({
-            agentId: resolvedAgentId,
-            workspaceId: params.orgId,
-            userId: params.userId,
-            workspaceIdString: recordIdToString(params.orgId, TABLES.ORGANIZATION),
-            threadId: params.threadId,
-            githubInstalled: params.githubInstalled,
-            provideRepoTool: resolvedAgentId !== 'mentor' && params.provideRepoTool,
-            availableUploads: params.availableUploads,
-            defaultRepoSections: params.defaultRepoSectionsByAgent[resolvedAgentId],
-            context: params.context,
-            toolProviders: params.toolProviders,
-          })
-          const agentId_ = config.id || resolvedAgentId
-          const configuredMaxSteps = config.maxSteps
-          const maxSteps = Math.min(configuredMaxSteps, TEAM_THINK_AGENT_MAX_STEPS)
-          const agentFactory = getResolvedAgentFactoryConfig().createAgent[agentId_]
-          if (!agentFactory) {
-            return yield* new TeamThinkAgentFactoryNotConfiguredError({ agentId: agentId_ })
-          }
-          const agent = agentFactory({
-            mode: 'fixedThreadMode',
-            tools,
-            extraInstructions: config.extraInstructions,
-            maxRetries: TEAM_THINK_AGENT_MAX_RETRIES,
-            stopWhen: [stepCountIs(maxSteps)],
-          })
-          const observer = {
-            run: <T>(fn: () => T | Promise<T>): Promise<T> =>
-              runPromiseWithCurrentContext(effectTryMaybeAsync(fn, `Team-think participant run failed (${agentId}).`)),
-            recordError: (error: unknown) => {
-              aiLogger.error`Team-think participant failed (${agentId}): ${error}`
-            },
-            recordAbort: (error: unknown) => {
-              aiLogger.info`Team-think participant aborted (${agentId}): ${
-                error instanceof Error ? error.message : String(error)
-              }`
-            },
-          }
-          return {
-            agent: agent as Awaited<ReturnType<TeamConsultationParticipantRunner['buildParticipantAgent']>>['agent'],
-            observer,
-          }
-        }),
-      )
-    },
-  }
+              threadType: 'group' as const,
+              mode: 'fixedThreadMode',
+              onboardingActive: false,
+              linearInstalled: false,
+              systemWorkspaceDetails: runParams.systemWorkspaceDetails,
+              preSeededMemoriesSection: runParams.preSeededMemoriesSection,
+              retrievedKnowledgeSection: runParams.retrievedKnowledgeSection,
+              additionalInstructionSections: mergeInstructionSections(
+                dynamicInstructionSections,
+                params.additionalInstructionSections,
+                readInstructionSections(agentResolution?.additionalInstructionSections),
+              ),
+              responseGuardSection: buildTeamConsultationResponseGuard({
+                agentConfig,
+                agentId: resolvedAgentId,
+                task: runParams.task,
+              }),
+            })
+            const { tools } = yield* buildTeamThinkAgentToolsEffect(
+              {
+                agentId: resolvedAgentId,
+                workspaceId: params.orgId,
+                userId: params.userId,
+                workspaceIdString: recordIdToString(params.orgId, TABLES.ORGANIZATION),
+                threadId: params.threadId,
+                githubInstalled: params.githubInstalled,
+                provideRepoTool: resolvedAgentId !== 'mentor' && params.provideRepoTool,
+                availableUploads: params.availableUploads,
+                defaultRepoSections: params.defaultRepoSectionsByAgent[resolvedAgentId],
+                context: params.context,
+                toolProviders: params.toolProviders,
+              },
+              runtimeAdapters,
+            )
+            const agentId_ = config.id || resolvedAgentId
+            const configuredMaxSteps = config.maxSteps
+            const maxSteps = Math.min(configuredMaxSteps, TEAM_THINK_AGENT_MAX_STEPS)
+            const agentFactory = agentFactoryConfig.createAgent[agentId_]
+            if (!agentFactory) {
+              return yield* new TeamThinkAgentFactoryNotConfiguredError({ agentId: agentId_ })
+            }
+            const agent = agentFactory({
+              mode: 'fixedThreadMode',
+              tools,
+              extraInstructions: config.extraInstructions,
+              maxRetries: TEAM_THINK_AGENT_MAX_RETRIES,
+              stopWhen: [stepCountIs(maxSteps)],
+            })
+            const observer = {
+              run: <T>(fn: () => T | Promise<T>): Promise<T> =>
+                runPromiseWithCurrentContext(
+                  effectTryMaybeAsync(fn, `Team-think participant run failed (${agentId}).`),
+                ),
+              recordError: (error: unknown) => {
+                aiLogger.error`Team-think participant failed (${agentId}): ${error}`
+              },
+              recordAbort: (error: unknown) => {
+                aiLogger.debug`Team-think participant aborted (${agentId}): ${
+                  error instanceof Error ? error.message : String(error)
+                }`
+              },
+            }
+            return {
+              agent: agent as Awaited<ReturnType<TeamConsultationParticipantRunner['buildParticipantAgent']>>['agent'],
+              observer,
+            }
+          }).pipe(Effect.withSpan('tool.teamThink.buildParticipantAgent')),
+        )
+      },
+    }
 
-  return createConsultTeamToolSdk({
-    historyMessages: params.historyMessages,
-    latestUserMessageId: params.latestUserMessageId,
-    availableUploads: params.availableUploads,
-    defaultRepoSectionsByAgent: params.defaultRepoSectionsByAgent,
-    systemWorkspaceDetails: params.systemWorkspaceDetails,
-    getPreSeededMemoriesSection: params.getPreSeededMemoriesSection,
-    retrievedKnowledgeSection: params.retrievedKnowledgeSection,
-    displayNamesById: agentIdentityOverrides.displayNamesById,
-    abortSignal: params.abortSignal,
-    participantRunner,
-    onReadError: (agentId, error) => {
-      if (!(error instanceof Error && error.name === 'AbortError')) {
-        aiLogger.error`UI message read failed for team-think participant ${agentId}: ${error}`
-      }
-    },
+    return createConsultTeamToolSdk({
+      agentConfig,
+      historyMessages: params.historyMessages,
+      latestUserMessageId: params.latestUserMessageId,
+      availableUploads: params.availableUploads,
+      defaultRepoSectionsByAgent: params.defaultRepoSectionsByAgent,
+      systemWorkspaceDetails: params.systemWorkspaceDetails,
+      getPreSeededMemoriesSection: params.getPreSeededMemoriesSection,
+      retrievedKnowledgeSection: params.retrievedKnowledgeSection,
+      displayNamesById: agentIdentityOverrides.displayNamesById,
+      abortSignal: params.abortSignal,
+      participantRunner,
+      onReadError: (agentId, error) => {
+        if (!(error instanceof Error && error.name === 'AbortError')) {
+          aiLogger.error`UI message read failed for team-think participant ${agentId}: ${error}`
+        }
+      },
+    })
   })
 }

package/src/utils/async.ts

@@ -1,24 +1,33 @@
-import { Schema, Duration, Effect } from 'effect'
+import { Cause, Duration, Effect, Exit, Schema } from 'effect'
 
 import { serverLogger } from '../config/logger'
 import { TimeoutError } from '../effect/errors'
-import { getErrorMessage } from './errors'
+import { getErrorMessage, toError } from './errors'
 
 class TimedOperationError extends Schema.TaggedErrorClass<TimedOperationError>()('TimedOperationError', {
   operation: Schema.String,
   cause: Schema.Defect,
 }) {}
 
+function isTimedOperationError(error: unknown): error is TimedOperationError {
+  return typeof error === 'object' && error !== null && '_tag' in error && error._tag === 'TimedOperationError'
+}
+
 export function withTimeout<T>(promise: Promise<T>, ms: number, operation: string): Promise<T> {
   return Effect.runPromise(
     Effect.tryPromise({ try: () => promise, catch: (cause) => new TimedOperationError({ operation, cause }) }).pipe(
       Effect.timeout(Duration.millis(ms)),
       Effect.catchTag('TimeoutError', () => Effect.fail(new TimeoutError({ operation, ms }))),
-      Effect.catchTag('TimedOperationError', (error) =>
-        Effect.fail(error.cause instanceof Error ? error.cause : new Error(String(error.cause))),
-      ),
+      Effect.exit,
     ),
-  )
+  ).then((exit) => {
+    if (Exit.isSuccess(exit)) {
+      return exit.value
+    }
+
+    const error = Cause.squash(exit.cause)
+    throw isTimedOperationError(error) ? toError(error.cause) : error
+  })
 }
 
 export function createSafeEnqueue(logger: { warn: (message: string) => void }) {

package/src/utils/errors.ts

@@ -1,5 +1,5 @@
 export { getErrorMessage } from '@lota-sdk/shared'
-import { Match } from 'effect'
+import { Data, Match } from 'effect'
 
 import type { EffectError, ValidationIssue } from '../effect/errors'
 import { BaseServicePersistenceError, isEffectError } from '../effect/errors'
@@ -19,18 +19,16 @@ export interface AppErrorResponse {
   body: { error: { code: string; message: string } }
 }
 
-export type AppErrorLike = Error & { code: string; statusCode: number; toResponse?: () => AppErrorResponse }
+export type AppErrorLike = Error & { code: string; statusCode: number; toResponse?: () => unknown }
 
-export class AppError extends Error {
+export class AppError extends Data.Error<{
+  readonly message: string
   readonly code: string
   readonly statusCode: number
-
+}> {
   constructor(message: string, code: string, statusCode: number) {
-    super(message)
+    super({ message, code, statusCode })
     this.name = new.target.name
-    this.code = code
-    this.statusCode = statusCode
-    Object.setPrototypeOf(this, new.target.prototype)
   }
 
   toResponse(): AppErrorResponse {
@@ -99,16 +97,30 @@ export function isAppErrorLike(error: unknown): error is AppErrorLike {
   return typeof candidate.code === 'string' && typeof candidate.statusCode === 'number'
 }
 
+function isAppErrorResponse(value: unknown): value is AppErrorResponse {
+  if (typeof value !== 'object' || value === null) {
+    return false
+  }
+
+  const candidate = value as {
+    status?: unknown
+    body?: { error?: { code?: unknown; message?: unknown } | null } | null
+  }
+  return (
+    typeof candidate.status === 'number' &&
+    typeof candidate.body === 'object' &&
+    candidate.body !== null &&
+    typeof candidate.body.error === 'object' &&
+    candidate.body.error !== null &&
+    typeof candidate.body.error.code === 'string' &&
+    typeof candidate.body.error.message === 'string'
+  )
+}
+
 export function toAppErrorResponse(error: AppErrorLike): AppErrorResponse {
   if (typeof error.toResponse === 'function') {
     const response = error.toResponse()
-    if (
-      response &&
-      typeof response === 'object' &&
-      typeof response.status === 'number' &&
-      response.body &&
-      typeof response.body === 'object'
-    ) {
+    if (isAppErrorResponse(response)) {
       return response
     }
   }

package/src/workers/bootstrap.ts

@@ -1,14 +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 { 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 { getConfiguredPluginDatabaseConnector } from '../runtime/runtime-extensions'
+import { buildWorkerInfrastructureLayer } from '../effect'
+import { DatabaseServiceTag, RuntimeAdaptersServiceTag } from '../effect/services'
+import { lotaRuntimeEnvConfig, parseLotaRuntimeConfig, parseWorkerBootstrapEnv } from '../runtime/runtime-config'
 import { FirecrawlLive } from '../tools/firecrawl-client'
 import { getErrorMessage } from '../utils/errors'
 
@@ -28,27 +26,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 +42,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 +56,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,23 +72,18 @@ 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'))
 
       const infrastructureLayer = buildWorkerInfrastructureLayer(runtimeConfig)
 
@@ -117,27 +93,23 @@ function ensureSandboxedWorkerRuntimeConfigured(): Promise<WorkerManagedRuntime>
 
       const managedRuntime = ManagedRuntime.make(fullLayer)
 
-      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({
@@ -159,11 +131,16 @@ export function initializeSandboxedWorkerRuntime(): Promise<WorkerManagedRuntime
         catch: (error) => toSandboxedWorkerBootstrapError('connect-db', error),
       })
 
+      const runtimeAdapters = yield* Effect.tryPromise({
+        try: () => runtime.runPromise(Effect.service(RuntimeAdaptersServiceTag)),
+        catch: (error) => toSandboxedWorkerBootstrapError('initialize', error),
+      })
+
       yield* Effect.tryPromise({
         try: () =>
           connectWithStartupRetry({
             connect: () => {
-              const connectPluginRuntimeDatabases = getConfiguredPluginDatabaseConnector()
+              const connectPluginRuntimeDatabases = runtimeAdapters.connectPluginDatabases
               return connectPluginRuntimeDatabases ? connectPluginRuntimeDatabases() : Promise.resolve()
             },
             label: 'sandboxed worker plugin database runtime',
@@ -186,11 +163,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/memory-consolidation.worker.ts

@@ -11,6 +11,7 @@ import { TABLES } from '../db/tables'
 import { effectTryPromise } from '../effect/helpers'
 import { DatabaseServiceTag } from '../effect/services'
 import type { MemoryConsolidationJob } from '../queues/memory-consolidation.queue'
+import { QueueJobServiceTag } from '../services/queue-job.service'
 import { nowDate, unsafeDateFrom } from '../utils/date-time'
 import { getErrorMessage } from '../utils/errors'
 import { initializeSandboxedWorkerRuntime } from './bootstrap'
@@ -59,6 +60,8 @@ const memoryConsolidationDatabaseService: SurrealDBService = await runtime.runPr
   Effect.service(DatabaseServiceTag),
 )
 
+const memoryConsolidationQueueJobService = await runtime.runPromise(Effect.service(QueueJobServiceTag))
+
 function db(): SurrealDBService {
   return memoryConsolidationDatabaseService
 }
@@ -395,4 +398,4 @@ const handler = (job: SandboxedJob<MemoryConsolidationJob>) =>
     ),
   )
 
-export default createTracedWorkerProcessor('memory-consolidation', handler)
+export default createTracedWorkerProcessor('memory-consolidation', handler, memoryConsolidationQueueJobService)

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

@@ -4,10 +4,17 @@ import type { Context } from 'effect'
 
 import { serverLogger } from '../config/logger'
 import { effectTryPromise } from '../effect/helpers'
-import { DatabaseServiceTag, RuntimeAdaptersServiceTag, RuntimeConfigServiceTag } from '../effect/services'
+import {
+  AgentConfigServiceTag,
+  DatabaseServiceTag,
+  RuntimeAdaptersServiceTag,
+  RuntimeConfigServiceTag,
+} from '../effect/services'
 import type { OrganizationLearningJob } from '../queues/organization-learning.queue'
+import { LotaQueuesServiceTag } from '../queues/queues.service'
 import { LearnedSkillServiceTag } from '../services/learned-skill.service'
 import { MemoryServiceTag } from '../services/memory/memory.service'
+import { QueueJobServiceTag } from '../services/queue-job.service'
 import { SocialChatHistoryServiceTag } from '../services/social-chat-history.service'
 import { initializeSandboxedWorkerRuntime } from './bootstrap'
 import { runRegularChatMemoryDigest } from './regular-chat-memory-digest.runner'
@@ -18,15 +25,20 @@ 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 agentConfig = await resolve(AgentConfigServiceTag)
+const queues = await resolve(LotaQueuesServiceTag)
 const regularChatDigestServices: RegularChatDigestServices = {
+  agentConfig,
   databaseService: await resolve(DatabaseServiceTag),
   memoryService: await resolve(MemoryServiceTag),
   socialChatHistoryService: await resolve(SocialChatHistoryServiceTag),
   runtimeAdapters: await resolve(RuntimeAdaptersServiceTag),
+  organizationLearningQueue: queues.organizationLearning,
 }
 const workerRuntimeConfig = await resolve(RuntimeConfigServiceTag)
 const skillExtractionServices: SkillExtractionServices = {
+  agentConfig,
   databaseService: await resolve(DatabaseServiceTag),
   learnedSkillService: await resolve(LearnedSkillServiceTag),
   socialChatHistoryService: await resolve(SocialChatHistoryServiceTag),
@@ -34,6 +46,7 @@ const skillExtractionServices: SkillExtractionServices = {
   embeddingModel: workerRuntimeConfig.aiGateway.embeddingModel,
   openRouterApiKey: workerRuntimeConfig.aiGateway.openRouterApiKey,
 }
+const organizationLearningQueueJobService = await resolve(QueueJobServiceTag)
 
 // One sandboxed worker handles both organization-learning branches so the
 // queue can dispatch digest and skill jobs without separate worker images.
@@ -62,4 +75,4 @@ const handler = (job: SandboxedJob<OrganizationLearningJob>) =>
     ),
   )
 
-export default createTracedWorkerProcessor('organization-learning', handler)
+export default createTracedWorkerProcessor('organization-learning', handler, organizationLearningQueueJobService)