@lota-sdk/core 0.4.9 → 0.4.10

package/src/runtime/memory/memory-pipeline.ts

@@ -1,3 +1,5 @@
+import { Match } from 'effect'
+
 import { clampImportance, compactWhitespace } from '../../utils/string'
 
 const SCORE_WEIGHTS = {
@@ -123,20 +125,17 @@ function scoreFact<T extends MemoryFactInput>(fact: T): number {
   const durability = fact.durability ?? 'standard'
   const type = fact.type ?? 'fact'
 
-  const durabilityWeight =
-    durability === 'core'
-      ? SCORE_WEIGHTS.durability.core
-      : durability === 'standard'
-        ? SCORE_WEIGHTS.durability.standard
-        : SCORE_WEIGHTS.durability.weak
-  const typeWeight =
-    type === 'decision'
-      ? SCORE_WEIGHTS.type.decision
-      : type === 'fact'
-        ? SCORE_WEIGHTS.type.fact
-        : type === 'preference'
-          ? SCORE_WEIGHTS.type.preference
-          : SCORE_WEIGHTS.type.default
+  const durabilityWeight = Match.value(durability).pipe(
+    Match.when('core', () => SCORE_WEIGHTS.durability.core),
+    Match.when('standard', () => SCORE_WEIGHTS.durability.standard),
+    Match.orElse(() => SCORE_WEIGHTS.durability.weak),
+  )
+  const typeWeight = Match.value(type).pipe(
+    Match.when('decision', () => SCORE_WEIGHTS.type.decision),
+    Match.when('fact', () => SCORE_WEIGHTS.type.fact),
+    Match.when('preference', () => SCORE_WEIGHTS.type.preference),
+    Match.orElse(() => SCORE_WEIGHTS.type.default),
+  )
   const lengthWeight =
     Math.min(fact.content.length, SCORE_WEIGHTS.maxContentLength) / SCORE_WEIGHTS.maxContentLength / 10
 
@@ -340,61 +339,49 @@ export function compileMemoryUpdatesFromDelta(params: {
       deleteSet.add(invalidateId)
     }
 
-    if (item.classification === 'duplicate') {
-      const targetId = item.targetMemoryIds[0]
-      if (targetId) {
-        updates.push({ id: targetId, text: existingById.get(targetId) ?? item.fact, event: 'NONE' })
-      } else {
-        updates.push({ id: `noop_${item.index}`, text: item.fact, event: 'NONE' })
-      }
-      continue
-    }
-
-    if (item.classification === 'enriches') {
-      const targetId = item.targetMemoryIds[0]
-      if (targetId) {
-        const relations = buildRelations(item, 'new').filter((relation) => relation.memoryId !== targetId)
-        updates.push({
-          id: targetId,
-          text: item.fact,
-          event: 'UPDATE',
-          oldMemory: existingById.get(targetId),
-          ...(relations.length > 0 ? { relatesTo: relations } : {}),
-        })
-        continue
-      }
+    const nextUpdates = Match.value(item.classification).pipe(
+      Match.when('duplicate', (): MemoryUpdateItemLike[] => {
+        const targetId = item.targetMemoryIds[0]
+        if (targetId) {
+          return [{ id: targetId, text: existingById.get(targetId) ?? item.fact, event: 'NONE' }]
+        }
+        return [{ id: `noop_${item.index}`, text: item.fact, event: 'NONE' }]
+      }),
+      Match.when('enriches', (): MemoryUpdateItemLike[] => {
+        const targetId = item.targetMemoryIds[0]
+        if (targetId) {
+          const relations = buildRelations(item, 'new').filter((relation) => relation.memoryId !== targetId)
+          return [
+            {
+              id: targetId,
+              text: item.fact,
+              event: 'UPDATE',
+              oldMemory: existingById.get(targetId),
+              ...(relations.length > 0 ? { relatesTo: relations } : {}),
+            },
+          ]
+        }
 
-      const addId = addIdByFactIndex.get(item.index) ?? nextAddId()
-      const relations = buildRelations(item, 'new')
-      updates.push({
-        id: addId,
-        text: item.fact,
-        event: 'ADD',
-        ...(relations.length > 0 ? { relatesTo: relations } : {}),
-      })
-      continue
-    }
+        const addId = addIdByFactIndex.get(item.index) ?? nextAddId()
+        const relations = buildRelations(item, 'new')
+        return [{ id: addId, text: item.fact, event: 'ADD', ...(relations.length > 0 ? { relatesTo: relations } : {}) }]
+      }),
+      Match.whenOr('supersedes', 'contradicts', (classification): MemoryUpdateItemLike[] => {
+        const addId = addIdByFactIndex.get(item.index) ?? nextAddId()
+        const relations = buildRelations(item, classification)
+        return [{ id: addId, text: item.fact, event: 'ADD', ...(relations.length > 0 ? { relatesTo: relations } : {}) }]
+      }),
+      Match.when('new', (): MemoryUpdateItemLike[] => {
+        const addId = addIdByFactIndex.get(item.index) ?? nextAddId()
+        const relations = buildRelations(item, 'new')
+        return [{ id: addId, text: item.fact, event: 'ADD', ...(relations.length > 0 ? { relatesTo: relations } : {}) }]
+      }),
+      Match.exhaustive,
+    )
 
-    if (item.classification === 'supersedes' || item.classification === 'contradicts') {
-      const addId = addIdByFactIndex.get(item.index) ?? nextAddId()
-      const relations = buildRelations(item, item.classification)
-      updates.push({
-        id: addId,
-        text: item.fact,
-        event: 'ADD',
-        ...(relations.length > 0 ? { relatesTo: relations } : {}),
-      })
-      continue
+    for (const update of nextUpdates) {
+      updates.push(update)
     }
-
-    const addId = addIdByFactIndex.get(item.index) ?? nextAddId()
-    const relations = buildRelations(item, 'new')
-    updates.push({
-      id: addId,
-      text: item.fact,
-      event: 'ADD',
-      ...(relations.length > 0 ? { relatesTo: relations } : {}),
-    })
   }
 
   const preservedRelationTargetIds = new Set<string>()

package/src/runtime/memory/memory-scope.ts

@@ -1,4 +1,4 @@
-import { Schema } from 'effect'
+import { Effect, Schema } from 'effect'
 
 export const ORG_SCOPE_PREFIX = 'org'
 
@@ -9,41 +9,45 @@ export class MemoryScopeError extends Schema.TaggedErrorClass<MemoryScopeError>(
   message: Schema.String,
 }) {}
 
-function stripRecordPrefix(id: string): string {
+function stripRecordPrefix(id: string): Effect.Effect<string, MemoryScopeError> {
   if (typeof id !== 'string' || id.length === 0) {
-    throw new MemoryScopeError({ message: 'id must be a non-empty string' })
+    return Effect.fail(new MemoryScopeError({ message: 'id must be a non-empty string' }))
   }
   const [, ...rest] = id.split(':')
-  return rest.length > 0 ? rest.join(':') : id
+  return Effect.succeed(rest.length > 0 ? rest.join(':') : id)
 }
 
-export function scopeId(prefix: string, id: string): string {
-  if (typeof prefix !== 'string' || prefix.length === 0) {
-    throw new MemoryScopeError({ message: 'prefix must be a non-empty string' })
-  }
-  if (!SCOPE_PREFIX_REGEX.test(prefix)) {
-    throw new MemoryScopeError({ message: `Invalid scope prefix: ${prefix}` })
-  }
-
-  const stripped = stripRecordPrefix(id)
-  const scoped = `${prefix}:${stripped}`
-  if (scoped.length > SCOPE_ID_MAX_LENGTH) {
-    throw new MemoryScopeError({ message: 'scopeId exceeds maximum length' })
-  }
-
-  return scoped
+export function scopeId(prefix: string, id: string): Effect.Effect<string, MemoryScopeError> {
+  return Effect.gen(function* () {
+    if (typeof prefix !== 'string' || prefix.length === 0) {
+      return yield* new MemoryScopeError({ message: 'prefix must be a non-empty string' })
+    }
+    if (!SCOPE_PREFIX_REGEX.test(prefix)) {
+      return yield* new MemoryScopeError({ message: `Invalid scope prefix: ${prefix}` })
+    }
+
+    const stripped = yield* stripRecordPrefix(id)
+    const scoped = `${prefix}:${stripped}`
+    if (scoped.length > SCOPE_ID_MAX_LENGTH) {
+      return yield* new MemoryScopeError({ message: 'scopeId exceeds maximum length' })
+    }
+
+    return scoped
+  })
 }
 
-export function agentScopeId(orgId: string, agentName: string): string {
-  if (typeof agentName !== 'string' || agentName.trim().length === 0) {
-    throw new MemoryScopeError({ message: 'agentName must be a non-empty string' })
-  }
-  const strippedOrgId = stripRecordPrefix(orgId)
-  const scoped = `agent:${strippedOrgId}:${agentName.trim()}`
+export function agentScopeId(orgId: string, agentName: string): Effect.Effect<string, MemoryScopeError> {
+  return Effect.gen(function* () {
+    if (typeof agentName !== 'string' || agentName.trim().length === 0) {
+      return yield* new MemoryScopeError({ message: 'agentName must be a non-empty string' })
+    }
+    const strippedOrgId = yield* stripRecordPrefix(orgId)
+    const scoped = `agent:${strippedOrgId}:${agentName.trim()}`
 
-  if (scoped.length > SCOPE_ID_MAX_LENGTH) {
-    throw new MemoryScopeError({ message: 'scopeId exceeds maximum length' })
-  }
+    if (scoped.length > SCOPE_ID_MAX_LENGTH) {
+      return yield* new MemoryScopeError({ message: 'scopeId exceeds maximum length' })
+    }
 
-  return scoped
+    return scoped
+  })
 }

package/src/runtime/plugin-resolution.ts

@@ -35,63 +35,42 @@ function readFunctionEffect(
   return Effect.succeed(value as (...args: unknown[]) => PromiseLike<unknown>)
 }
 
+function configError(message: string): PluginResolutionError {
+  return new PluginResolutionError({ stage: 'configuration', message, cause: undefined })
+}
+
+function requireRecord(value: unknown, message: string): Effect.Effect<Record<string, unknown>, PluginResolutionError> {
+  return isRecord(value) ? Effect.succeed(value) : Effect.fail(configError(message))
+}
+
 function resolvePluginServiceEffect(
   pluginName: string,
   serviceName: string,
   methodName: string,
 ): Effect.Effect<(...args: unknown[]) => PromiseLike<unknown>, PluginResolutionError> {
-  const pluginRuntime = getPluginRuntime()
-  if (!pluginRuntime) {
-    return Effect.fail(
-      new PluginResolutionError({
-        stage: 'configuration',
-        message: `Plugin runtime is not configured. Missing "${pluginName}" integration.`,
-        cause: undefined,
-      }),
-    )
-  }
-
-  const plugin = pluginRuntime[pluginName]
-  if (!isRecord(plugin)) {
-    return Effect.fail(
-      new PluginResolutionError({
-        stage: 'configuration',
-        message: `Plugin "${pluginName}" is not configured in the current runtime.`,
-        cause: undefined,
-      }),
-    )
-  }
-
-  const services = plugin.services
-  if (!isRecord(services)) {
-    return Effect.fail(
-      new PluginResolutionError({
-        stage: 'configuration',
-        message: `Plugin "${pluginName}" does not expose a services registry.`,
-        cause: undefined,
-      }),
-    )
-  }
-
-  const service = services[serviceName]
-  if (!isRecord(service)) {
-    return Effect.fail(
-      new PluginResolutionError({
-        stage: 'configuration',
-        message: `Plugin "${pluginName}" service "${serviceName}" is not configured.`,
-        cause: undefined,
-      }),
-    )
-  }
-
-  return readFunctionEffect(
-    service[methodName],
-    `Plugin "${pluginName}" service "${serviceName}" is missing method "${methodName}".`,
-  ).pipe(
-    Effect.map(
-      (method) =>
-        (...args: unknown[]) =>
-          Reflect.apply(method, service, args),
+  return Effect.fromNullishOr(getPluginRuntime()).pipe(
+    Effect.mapError(() => configError(`Plugin runtime is not configured. Missing "${pluginName}" integration.`)),
+    Effect.flatMap((pluginRuntime) =>
+      requireRecord(pluginRuntime[pluginName], `Plugin "${pluginName}" is not configured in the current runtime.`),
+    ),
+    Effect.flatMap((plugin) =>
+      requireRecord(plugin.services, `Plugin "${pluginName}" does not expose a services registry.`),
+    ),
+    Effect.flatMap((services) =>
+      requireRecord(services[serviceName], `Plugin "${pluginName}" service "${serviceName}" is not configured.`).pipe(
+        Effect.flatMap((service) =>
+          readFunctionEffect(
+            service[methodName],
+            `Plugin "${pluginName}" service "${serviceName}" is missing method "${methodName}".`,
+          ).pipe(
+            Effect.map(
+              (method) =>
+                (...args: unknown[]) =>
+                  Reflect.apply(method, service, args),
+            ),
+          ),
+        ),
+      ),
     ),
   )
 }
@@ -100,8 +79,8 @@ function tryResolvePluginServiceEffect(
   pluginName: string,
   serviceName: string,
   methodName: string,
-): Effect.Effect<((...args: unknown[]) => PromiseLike<unknown>) | undefined> {
-  return Effect.catch(resolvePluginServiceEffect(pluginName, serviceName, methodName), () => Effect.succeed(undefined))
+): Effect.Effect<((...args: unknown[]) => PromiseLike<unknown>) | void, never, never> {
+  return Effect.catch(resolvePluginServiceEffect(pluginName, serviceName, methodName), () => Effect.void)
 }
 
 export function getLinearInstallationByOrgId(organizationId: RecordIdRef): Promise<unknown> {

package/src/runtime/post-turn-side-effects.ts

@@ -1,10 +1,9 @@
 import type { ChatMessage } from '@lota-sdk/shared'
 import { Schema, Effect } from 'effect'
-import type { Context } from 'effect'
 
 import type { ResolvedAgentConfig } from '../config/agent-defaults'
 import type { RecordIdRef } from '../db/record-id'
-import { getCurrentRuntime } from '../effect/runtime-ref'
+import { runPromise } from '../effect/runtime'
 import { AgentConfigServiceTag, RuntimeAdaptersServiceTag } from '../effect/services'
 import { enqueueMemoryConsolidation } from '../queues/memory-consolidation.queue'
 import { enqueueRegularChatMemoryDigest, enqueueSkillExtraction } from '../queues/organization-learning.queue'
@@ -21,7 +20,6 @@ import {
   shouldEnqueueOnboardingPostChatMemory,
   shouldEnqueueRegularDigestForThread,
 } from './memory/memory-digest-policy'
-import type { LotaRuntimeAdapters } from './runtime-extensions'
 import { shouldEnqueueSkillExtraction } from './skill-extraction-policy'
 import {
   appendPersistedThreadContextToHistoryMessages,
@@ -33,13 +31,6 @@ import {
   toHistoryMessages,
 } from './thread-chat-helpers'
 
-interface PostTurnSideEffectsServices {
-  recentActivityService: Context.Service.Shape<typeof RecentActivityServiceTag>
-  threadService: Context.Service.Shape<typeof ThreadServiceTag>
-  agentConfig: ResolvedAgentConfig
-  runtimeAdapters: LotaRuntimeAdapters
-}
-
 class PostTurnSideEffectsError extends Schema.TaggedErrorClass<PostTurnSideEffectsError>()('PostTurnSideEffectsError', {
   message: Schema.String,
   cause: Schema.Defect,
@@ -55,20 +46,6 @@ function tryPostTurnSideEffect<A>(
   })
 }
 
-function getPostTurnSideEffectsServices(): PostTurnSideEffectsServices {
-  const runtime = getCurrentRuntime()
-  return runtime.runSync(
-    Effect.gen(function* () {
-      return {
-        recentActivityService: yield* RecentActivityServiceTag,
-        threadService: yield* ThreadServiceTag,
-        agentConfig: yield* AgentConfigServiceTag,
-        runtimeAdapters: yield* RuntimeAdaptersServiceTag,
-      }
-    }),
-  )
-}
-
 function resolveDisplayName(
   agentConfig: ResolvedAgentConfig,
   agentId: string,
@@ -139,7 +116,10 @@ interface PostTurnSideEffectsParams {
 
 const runPostTurnSideEffectsEffect = (params: PostTurnSideEffectsParams) =>
   Effect.gen(function* () {
-    const { recentActivityService, threadService, agentConfig, runtimeAdapters } = getPostTurnSideEffectsServices()
+    const recentActivityService = yield* RecentActivityServiceTag
+    const threadService = yield* ThreadServiceTag
+    const agentConfig: ResolvedAgentConfig = yield* AgentConfigServiceTag
+    const runtimeAdapters = yield* RuntimeAdaptersServiceTag
     const recentHistory = yield* tryPostTurnSideEffect('Failed to load recent thread history.', () =>
       params.loadRecentHistory(),
     )
@@ -286,5 +266,5 @@ const runPostTurnSideEffectsEffect = (params: PostTurnSideEffectsParams) =>
   })
 
 export function runPostTurnSideEffects(params: PostTurnSideEffectsParams): Promise<void> {
-  return Effect.runPromise(runPostTurnSideEffectsEffect(params))
+  return runPromise(runPostTurnSideEffectsEffect(params))
 }

package/src/runtime/retrieval-adapters.ts

@@ -1,8 +1,8 @@
 import { Schema, Effect } from 'effect'
 
-interface ScopedRetrievalTask<TCandidate> {
+interface ScopedRetrievalTask<TCandidate, E = never> {
   scopeTag: string
-  retrieve: () => PromiseLike<TCandidate[]> | Effect.Effect<TCandidate[], unknown>
+  retrieve: () => PromiseLike<TCandidate[]> | Effect.Effect<TCandidate[], E>
 }
 
 interface ScopedRetrievalResult<TCandidate> {
@@ -20,8 +20,8 @@ function toScopedRetrievalError(scopeTag: string, cause: unknown): ScopedRetriev
   return new ScopedRetrievalError({ scopeTag, message: cause instanceof Error ? cause.message : String(cause), cause })
 }
 
-export function executeScopedRetrieval<TCandidate>(
-  tasks: ScopedRetrievalTask<TCandidate>[],
+export function executeScopedRetrieval<TCandidate, E>(
+  tasks: ScopedRetrievalTask<TCandidate, E>[],
 ): Effect.Effect<ScopedRetrievalResult<TCandidate>[], ScopedRetrievalError> {
   return Effect.forEach(
     tasks,

package/src/runtime/runtime-accessors.ts

@@ -0,0 +1,92 @@
+/**
+ * Installs and tears down the SDK's module-level runtime accessors.
+ *
+ * Several SDK modules expose `configure*`/`clear*` pairs so host code can read
+ * runtime-resolved services synchronously (AI gateway, agent defaults,
+ * firecrawl, graph designer, queue jobs, runtime extensions, redis, thread
+ * defaults). `createLotaRuntime` wires them once at boot and clears them on
+ * disconnect; this module keeps both phases in a single place so they stay
+ * symmetric.
+ */
+
+import type { Context, ManagedRuntime } from 'effect'
+import { Effect } from 'effect'
+
+import {
+  AiGatewayTag,
+  clearAiGatewayRuntimeAccessors,
+  configureAiGatewayRuntimeAccessors,
+} from '../ai-gateway/ai-gateway'
+import { clearAgentRuntimeDefaults, configureAgentRuntimeDefaults } from '../config/agent-defaults'
+import { clearThreadRuntimeDefaults, configureThreadRuntimeDefaults } from '../config/thread-defaults'
+import {
+  AgentConfigServiceTag,
+  AgentFactoryServiceTag,
+  RuntimeAdaptersServiceTag,
+  RuntimeWorkerExtensionsServiceTag,
+  ThreadConfigServiceTag,
+  ToolProvidersServiceTag,
+  TurnHooksServiceTag,
+} from '../effect'
+import type { RedisConnectionManager } from '../redis/connection'
+import { clearRuntimeRedisManager, configureRuntimeRedisManager } from '../redis/runtime-connection'
+import { QueueJobServiceTag } from '../services/queue-job.service'
+import { FirecrawlTag, clearFirecrawlClient, configureFirecrawlClient } from '../tools/firecrawl-client'
+import { clearQueueJobService, configureQueueJobService } from '../workers/worker-utils'
+import { clearGraphDesigner, configureGraphDesigner } from './graph-designer'
+import type { ResolvedLotaRuntimeConfig } from './runtime-config'
+import { clearRuntimeExtensionsAccessors, configureRuntimeExtensionsAccessors } from './runtime-extensions'
+
+// 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>
+
+interface ConfigureRuntimeAccessorsInput {
+  managedRuntime: SdkManagedRuntime
+  runtimeConfig: ResolvedLotaRuntimeConfig
+  redisManager: RedisConnectionManager
+}
+
+/**
+ * Resolve every service the SDK exposes through module-level accessors and
+ * install them. Must be called after `setLotaSdkRuntime(managedRuntime)`.
+ */
+export function configureRuntimeModuleAccessors(input: ConfigureRuntimeAccessorsInput): void {
+  const { managedRuntime, runtimeConfig, redisManager } = input
+  const resolve = <I, T>(tag: Context.Key<I, T>): T =>
+    // We know every tag is provided by the managed runtime; the cast bridges
+    // the erased service-set carried by `SdkManagedRuntime`.
+    managedRuntime.runSync(Effect.service(tag) as Effect.Effect<T, never, never>)
+
+  configureAiGatewayRuntimeAccessors({ aiGateway: resolve(AiGatewayTag), runtimeConfig })
+  configureAgentRuntimeDefaults({
+    agentConfig: resolve(AgentConfigServiceTag),
+    agentFactoryConfig: resolve(AgentFactoryServiceTag),
+  })
+  configureThreadRuntimeDefaults(resolve(ThreadConfigServiceTag))
+  configureRuntimeExtensionsAccessors({
+    adapters: resolve(RuntimeAdaptersServiceTag),
+    turnHooks: resolve(TurnHooksServiceTag),
+    toolProviders: resolve(ToolProvidersServiceTag),
+    extraWorkers: resolve(RuntimeWorkerExtensionsServiceTag),
+  })
+  configureFirecrawlClient(resolve(FirecrawlTag))
+  configureQueueJobService(resolve(QueueJobServiceTag))
+  configureRuntimeRedisManager(redisManager)
+  configureGraphDesigner(runtimeConfig.graphDesigner)
+}
+
+/**
+ * Clears every module-level accessor installed by
+ * `configureRuntimeModuleAccessors`. Always safe to call (idempotent per clear
+ * function).
+ */
+export function clearRuntimeModuleAccessors(): void {
+  clearAiGatewayRuntimeAccessors()
+  clearAgentRuntimeDefaults()
+  clearFirecrawlClient()
+  clearGraphDesigner()
+  clearQueueJobService()
+  clearRuntimeExtensionsAccessors()
+  clearRuntimeRedisManager()
+  clearThreadRuntimeDefaults()
+}

package/src/runtime/runtime-config.ts

@@ -329,7 +329,7 @@ export function parseWorkerBootstrapEnv(env: Record<string, string | undefined>)
   return WORKER_BOOTSTRAP_ENV_SCHEMA.parse(env)
 }
 
-const runtimeEnvironmentConfig = Config.all({
+export const lotaRuntimeEnvConfig = Config.all({
   surrealdbUrl: Config.string('SURREALDB_URL'),
   surrealdbNamespace: Config.string('SURREALDB_NAMESPACE'),
   surrealdbUser: Config.string('SURREALDB_USER'),
@@ -369,7 +369,7 @@ export function loadLotaRuntimeConfigFromEnv(
   overrides: LotaRuntimeEnvironmentOverrides,
   options: { configProvider?: ConfigProvider.ConfigProvider } = {},
 ) {
-  return runtimeEnvironmentConfig
+  return lotaRuntimeEnvConfig
     .parse(options.configProvider ?? ConfigProvider.fromEnv())
     .pipe(
       Effect.map((env) =>
@@ -403,7 +403,7 @@ export function loadLotaRuntimeConfigFromEnv(
             apiKey: Redacted.value(env.firecrawlApiKey),
             ...(Option.isSome(env.firecrawlApiBaseUrl) ? { apiBaseUrl: env.firecrawlApiBaseUrl.value } : {}),
           },
-          logging: overrides.logging ?? { level: env.logLevel as (typeof logLevelValues)[number] },
+          logging: overrides.logging ?? { level: z.enum(logLevelValues).parse(env.logLevel) },
           memory: {
             searchK: env.memorySearchK,
             rerankerStrategy: env.memoryRerankerStrategy as MemoryRerankerStrategy,

package/src/runtime/runtime-extensions.ts

@@ -6,11 +6,9 @@ import type {
   PlanSpecRecord,
 } from '@lota-sdk/shared'
 import type { ToolSet } from 'ai'
-import { Effect } from 'effect'
-import type { Context } from 'effect'
 
 import type { RecordIdRef } from '../db/record-id'
-import { getCurrentRuntime } from '../effect/runtime-ref'
+import { resolveLotaService } from '../effect/runtime'
 import {
   RuntimeAdaptersServiceTag,
   RuntimeWorkerExtensionsServiceTag,
@@ -202,20 +200,33 @@ export interface LotaRuntimeAdapters {
   withWorkspaceMemoryLock?: <T>(workspaceId: string, fn: () => Promise<T>) => Promise<T>
 }
 
-function resolveFromRuntime<I, T>(tag: Context.Key<I, T>): T {
-  return getCurrentRuntime().runSync(Effect.service(tag))
+interface RuntimeExtensionsAccessors {
+  adapters: LotaRuntimeAdapters
+  turnHooks: LotaRuntimeTurnHooks
+  toolProviders: ToolSet
+  extraWorkers: LotaRuntimeWorkerExtensions
+}
+
+let runtimeExtensionsAccessors: RuntimeExtensionsAccessors | null = null
+
+export function configureRuntimeExtensionsAccessors(accessors: RuntimeExtensionsAccessors): void {
+  runtimeExtensionsAccessors = accessors
+}
+
+export function clearRuntimeExtensionsAccessors(): void {
+  runtimeExtensionsAccessors = null
 }
 
 export function getRuntimeAdapters(): LotaRuntimeAdapters {
-  return resolveFromRuntime(RuntimeAdaptersServiceTag)
+  return runtimeExtensionsAccessors?.adapters ?? resolveLotaService(RuntimeAdaptersServiceTag)
 }
 
 export function getTurnHooks(): LotaRuntimeTurnHooks {
-  return resolveFromRuntime(TurnHooksServiceTag)
+  return runtimeExtensionsAccessors?.turnHooks ?? resolveLotaService(TurnHooksServiceTag)
 }
 
 export function getToolProviders(): ToolSet {
-  return resolveFromRuntime(ToolProvidersServiceTag)
+  return runtimeExtensionsAccessors?.toolProviders ?? resolveLotaService(ToolProvidersServiceTag)
 }
 
 export function getConfiguredPluginDatabaseConnector(): (() => Promise<void>) | undefined {
@@ -223,7 +234,7 @@ export function getConfiguredPluginDatabaseConnector(): (() => Promise<void>) |
 }
 
 export function getExtraWorkers(): LotaRuntimeWorkerExtensions {
-  return resolveFromRuntime(RuntimeWorkerExtensionsServiceTag)
+  return runtimeExtensionsAccessors?.extraWorkers ?? resolveLotaService(RuntimeWorkerExtensionsServiceTag)
 }
 
 export function withConfiguredWorkspaceMemoryLock<T>(workspaceId: string, fn: () => Promise<T>): Promise<T> {