@lota-sdk/core 0.4.10 → 0.4.12

package/src/workers/worker-utils.ts

@@ -5,22 +5,9 @@ import { Effect } from 'effect'
 import type { Context } from 'effect'
 
 import { chatLogger } from '../config/logger'
-import { resolveLotaService } from '../effect/runtime'
-import { QueueJobServiceTag } from '../services/queue-job.service'
+import type { 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 currentQueueJobService ?? resolveLotaService(QueueJobServiceTag)
-}
+export type QueueJobService = Context.Service.Shape<typeof QueueJobServiceTag>
 
 export const DEFAULT_JOB_RETENTION = { removeOnComplete: true, removeOnFail: { age: 24 * 60 * 60, count: 200 } }
 export const LOW_JOB_RETENTION = { removeOnComplete: true, removeOnFail: { age: 6 * 60 * 60, count: 50 } }
@@ -98,6 +85,7 @@ export const createWorkerShutdown = (worker: Worker, name: string, logger: typeo
 export function createTracedWorkerProcessor<TJob extends TracedWorkerJobLike, TResult = void>(
   queueName: string,
   processor: (job: TJob) => Promise<TResult>,
+  queueJobService: QueueJobService,
 ): (job: TJob) => Promise<TResult> {
   return (job: TJob) => {
     const trackedJob = {
@@ -117,7 +105,7 @@ export function createTracedWorkerProcessor<TJob extends TracedWorkerJobLike, TR
     return Effect.runPromise(
       Effect.catch(
         Effect.gen(function* () {
-          yield* Effect.catch(getQueueJobService().markAttemptStarted(trackedJob), (error) =>
+          yield* Effect.catch(queueJobService.markAttemptStarted(trackedJob), (error) =>
             Effect.sync(() => {
               logPersistenceError('start', error)
             }),
@@ -125,7 +113,7 @@ export function createTracedWorkerProcessor<TJob extends TracedWorkerJobLike, TR
 
           const result = yield* Effect.tryPromise(() => processor(job))
 
-          yield* Effect.catch(getQueueJobService().markAttemptCompleted(trackedJob, result), (error) =>
+          yield* Effect.catch(queueJobService.markAttemptCompleted(trackedJob, result), (error) =>
             Effect.sync(() => {
               logPersistenceError('completion', error)
             }),
@@ -135,7 +123,7 @@ export function createTracedWorkerProcessor<TJob extends TracedWorkerJobLike, TR
         }),
         (error) =>
           Effect.gen(function* () {
-            yield* Effect.catch(getQueueJobService().markAttemptFailed(trackedJob, error), (persistenceError) =>
+            yield* Effect.catch(queueJobService.markAttemptFailed(trackedJob, error), (persistenceError) =>
               Effect.sync(() => {
                 logPersistenceError('failure', persistenceError)
               }),

package/src/effect/awaitable-effect.ts

@@ -1,96 +0,0 @@
-import { Effect } from 'effect'
-
-export type AwaitableEffect<A, E> = Effect.Effect<A, E, never> & Promise<A>
-
-export type AwaitableValue<T> = T extends (...args: infer TArgs) => Effect.Effect<infer A, infer E, never>
-  ? (...args: TArgs) => AwaitableEffect<A, E>
-  : T extends (...args: infer TArgs) => infer TResult
-    ? (...args: TArgs) => TResult
-    : T
-
-type AwaitableServiceMethods<T> = {
-  [K in keyof T]: AwaitableValue<T[K]>
-}
-
-export type AwaitableService<T> = AwaitableServiceMethods<T>
-
-export type MaybeAwaitableService<T extends object> = T | AwaitableService<T>
-
-type AwaitableEffectOptions = { runPromise?: <A, E>(effect: Effect.Effect<A, E, never>) => Promise<A> }
-
-type Callable = (...args: Array<unknown>) => unknown
-
-function isCallable(value: unknown): value is Callable {
-  return typeof value === 'function'
-}
-
-function isRuntimeEffect(value: unknown): value is Effect.Effect<unknown, never, never> {
-  return Effect.isEffect(value)
-}
-
-/**
- * Wraps an Effect so it can be `await`-ed as if it were a Promise, while still
- * passing `Effect.isEffect` checks and exposing the underlying Effect properties.
- *
- * Implementation: returns a `Proxy` around the Effect that only intercepts the
- * PromiseLike methods (`then`/`catch`/`finally`) plus `Symbol.toStringTag`. The
- * Promise is created lazily on first `await` and cached for the wrapper's
- * lifetime so repeated awaits share a result. The original Effect object is
- * never mutated.
- */
-export function toAwaitableEffect<A, E>(
-  effect: Effect.Effect<A, E, never>,
-  options?: AwaitableEffectOptions,
-): AwaitableEffect<A, E> {
-  const runPromise = options?.runPromise ?? Effect.runPromise
-  let cachedPromise: Promise<A> | undefined
-  const getPromise = (): Promise<A> => (cachedPromise ??= runPromise(effect))
-
-  const then: Promise<A>['then'] = (onFulfilled, onRejected) => getPromise().then(onFulfilled, onRejected)
-  const catchMethod: Promise<A>['catch'] = (onRejected) => getPromise().catch(onRejected)
-  const finallyMethod: Promise<A>['finally'] = (onFinally) => getPromise().finally(onFinally)
-
-  return new Proxy(effect as object, {
-    get(target, property, receiver) {
-      if (property === 'then') return then
-      if (property === 'catch') return catchMethod
-      if (property === 'finally') return finallyMethod
-      if (property === Symbol.toStringTag) return 'Promise'
-      return Reflect.get(target, property, receiver) as unknown
-    },
-  }) as AwaitableEffect<A, E>
-}
-
-/**
- * Returns a proxy over a service whose Effect-returning methods are
- * transparently wrapped with `toAwaitableEffect`. Non-Effect return values
- * pass through untouched.
- */
-export function toAwaitableService<T extends object>(
-  service: T,
-  options?: AwaitableEffectOptions,
-): AwaitableService<T> {
-  const wrappedMethods = new Map<PropertyKey, Callable>()
-
-  return new Proxy(service, {
-    get(target, property, receiver) {
-      const value = Reflect.get(target, property, receiver)
-      if (!isCallable(value)) {
-        return value
-      }
-
-      const existing = wrappedMethods.get(property)
-      if (existing) {
-        return existing
-      }
-
-      const wrapped: Callable = (...args) => {
-        const result = value.apply(target, args)
-        return isRuntimeEffect(result) ? toAwaitableEffect(result, options) : result
-      }
-
-      wrappedMethods.set(property, wrapped)
-      return wrapped
-    },
-  }) as AwaitableService<T>
-}

package/src/effect/runtime-ref.ts

@@ -1,25 +0,0 @@
-import type { ManagedRuntime } from 'effect'
-
-// 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>
-
-let currentRuntime: SdkManagedRuntime | null = null
-
-export function setCurrentRuntime<R, E>(runtime: ManagedRuntime.ManagedRuntime<R, E>): void {
-  currentRuntime = runtime as SdkManagedRuntime
-}
-
-export function clearCurrentRuntime(): void {
-  currentRuntime = null
-}
-
-export function getCurrentRuntime(): SdkManagedRuntime {
-  if (!currentRuntime) {
-    throw new Error('Lota Effect runtime is not configured. Call createLotaRuntime() first.')
-  }
-  return currentRuntime
-}
-
-export function getOptionalCurrentRuntime(): SdkManagedRuntime | null {
-  return currentRuntime
-}

package/src/effect/runtime.ts

@@ -1,46 +0,0 @@
-import { Effect } from 'effect'
-import type { Context, ManagedRuntime } from 'effect'
-
-import { clearCurrentRuntime, getCurrentRuntime, getOptionalCurrentRuntime, setCurrentRuntime } from './runtime-ref'
-
-export function setLotaSdkRuntime<R, E>(runtime: ManagedRuntime.ManagedRuntime<R, E>): void {
-  setCurrentRuntime(runtime)
-}
-
-export function clearLotaSdkRuntime(): void {
-  clearCurrentRuntime()
-}
-
-export function getOptionalLotaSdkRuntime() {
-  return getOptionalCurrentRuntime()
-}
-
-/** Returns the current managed runtime or throws. */
-export function getLotaSdkRuntime() {
-  return getCurrentRuntime()
-}
-
-export function resolveLotaService<I, T>(tag: Context.Key<I, T>): T {
-  return getCurrentRuntime().runSync(Effect.service(tag))
-}
-
-export function resolveOptionalLotaService<I, T>(tag: Context.Key<I, T>): T | null {
-  const runtime = getOptionalCurrentRuntime()
-  return runtime ? runtime.runSync(Effect.service(tag)) : null
-}
-
-export function runPromiseWithOptionalLotaRuntime<A, E>(effect: Effect.Effect<A, E, never>): Promise<A> {
-  const runtime = getOptionalCurrentRuntime()
-  return runtime ? runtime.runPromise(effect) : Effect.runPromise(effect)
-}
-
-/**
- * Run an effect as a Promise using the current managed runtime's context.
- * The runtime must be initialized via `createLotaRuntime()` before any call.
- */
-export function runPromise<A, E, R>(
-  effect: Effect.Effect<A, E, R>,
-  options?: { readonly signal?: AbortSignal },
-): Promise<A> {
-  return getCurrentRuntime().runPromise(effect, options)
-}

package/src/redis/runtime-connection.ts

@@ -1,20 +0,0 @@
-import type IORedis from 'ioredis'
-
-import { resolveLotaService } from '../effect/runtime'
-import { RedisServiceTag } from '../effect/services'
-import type { RedisConnectionManager } from './connection'
-
-let currentRedisManager: RedisConnectionManager | null = null
-
-export function configureRuntimeRedisManager(redisManager: RedisConnectionManager): void {
-  currentRedisManager = redisManager
-}
-
-export function clearRuntimeRedisManager(): void {
-  currentRedisManager = null
-}
-
-export function getRuntimeRedisConnection(): IORedis {
-  const redis = currentRedisManager ?? resolveLotaService(RedisServiceTag)
-  return redis.getConnection()
-}

package/src/runtime/runtime-accessors.ts

@@ -1,92 +0,0 @@
-/**
- * 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-token.ts

@@ -1,47 +0,0 @@
-/**
- * Single-slot runtime token. `createLotaRuntime()` claims the slot on success
- * and releases it on disconnect, enforcing the "one runtime per process"
- * invariant. Kept as a small, typed module so the guard is trivially testable
- * and stays out of the main entrypoint.
- */
-
-import { Effect } from 'effect'
-
-import { ConfigurationError } from '../effect/errors'
-
-let activeToken: symbol | null = null
-
-function buildConflictError(): ConfigurationError {
-  return new ConfigurationError({
-    message: 'createLotaRuntime() is process-scoped. Disconnect the active runtime before creating another one.',
-  })
-}
-
-/**
- * Claim the process-wide runtime slot. Fails with `ConfigurationError` if it
- * is already held. Preferred inside `Effect.gen` so the failure is expressed
- * through the typed error channel instead of a thrown value.
- */
-export function acquireRuntimeTokenEffect(): Effect.Effect<symbol, ConfigurationError> {
-  return Effect.suspend(() => {
-    if (activeToken) {
-      return Effect.fail(buildConflictError())
-    }
-
-    const token = Symbol('lota-runtime')
-    activeToken = token
-    return Effect.succeed(token)
-  })
-}
-
-/** Release the slot only if the caller holds the current token. */
-export function releaseRuntimeToken(token: symbol): void {
-  if (activeToken === token) {
-    activeToken = null
-  }
-}
-
-/** Diagnostic: whether a runtime is currently active in this process. */
-export function isRuntimeTokenActive(): boolean {
-  return activeToken !== null
-}